Biblioteca de Circuit-uri

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm utilizarea acestor versiuni sau a unora mai noi.

qiskit[all]~=2.6.1

SDK-ul Qiskit include o bibliotecă de circuit-uri populare pentru a fi folosite ca blocuri de construcție în propriile tale programe. Utilizarea Circuit-urilor predefinite economisește timp de cercetare, scriere de cod și depanare. Biblioteca include Circuit-uri populare în calculul cuantic, Circuit-uri dificil de simulat clasic și Circuit-uri utile pentru evaluarea comparativă a hardware-ului cuantic.

Această pagină listează diferitele categorii de circuit-uri oferite de bibliotecă. Pentru o listă completă de circuit-uri, consultă documentația API a bibliotecii de circuit-uri.

Porți standard

Biblioteca de circuit-uri include, de asemenea, porți cuantice standard. Unele sunt porți mai fundamentale (cum ar fi UGate), iar altele sunt porți cu mai mulți Qubiți care de obicei trebuie construite din porți cu unul sau doi Qubiți. Pentru a adăuga porți importate în Circuit-ul tău, folosește metoda append; primul argument este poarta, iar următorul argument este o listă de Qubiți la care să aplici poarta.

De exemplu, următoarea celulă de cod creează un circuit cu o poartă Hadamard și o poartă multi-controlled-X.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, MCXGate

mcx_gate = MCXGate(3)
hadamard_gate = HGate()

qc = QuantumCircuit(4)
qc.append(hadamard_gate, [0])
qc.append(mcx_gate, [0, 1, 2, 3])
qc.draw("mpl")

Vezi Porți standard în documentația API a bibliotecii de circuit-uri.

Circuit-uri N-local

Aceste circuit-uri alternează straturi de porți de rotație pe un singur qubit cu straturi de porți de entanglement pe mai mulți qubiți.

Această familie de circuit-uri este populară în algoritmii cuantici variaționali deoarece pot produce o gamă largă de stări cuantice. Algoritmii variaționali ajustează parametrii porților pentru a găsi stări care au anumite proprietăți (cum ar fi stări care reprezintă o soluție bună la o problemă de optimizare). În acest scop, multe Circuit-uri din bibliotecă sunt parametrizate, ceea ce înseamnă că le poți defini fără valori fixe.

Următoarea celulă de cod importă un circuit n_local, în care porțile de entanglement sunt porți cu doi Qubiți. Acest circuit intercalează blocuri de porți parametrizate cu un singur qubit, urmate de blocuri de entanglement cu porți cu doi Qubiți. Următorul cod creează un circuit cu trei Qubiți, cu porți RX cu un singur qubit și porți CZ cu doi Qubiți.

from qiskit.circuit.library import n_local

two_local = n_local(3, "rx", "cz")
two_local.draw("mpl")

Poți obține un obiect asemănător cu o listă al parametrilor Circuit-ului din atributul parameters.

two_local.parameters

ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])

Poți folosi, de asemenea, acest lucru pentru a atribui acești parametri unor valori reale folosind un dicționar de forma { Parameter: number }. Pentru a demonstra, următoarea celulă de cod atribuie fiecărui parametru din Circuit valoarea 0.

bound_circuit = two_local.assign_parameters(
    {p: 0 for p in two_local.parameters}
)
bound_circuit.decompose().draw("mpl")

Pentru mai multe informații, consultă Porți N-local în documentația API a bibliotecii de circuit-uri sau urmează cursul de proiectare a algoritmilor variaționali în IBM Quantum Learning.

Circuit-uri de codificare a datelor

Aceste circuit-uri parametrizate codifică date în stări cuantice pentru procesare de către algoritmi de învățare automată cuantică. Unele Circuit-uri suportate de Qiskit sunt:

• Codificarea prin amplitudine, care codifică fiecare număr în amplitudinea unei stări de bază. Aceasta poate stoca $2^n$ numere într-o singură stare, dar poate fi costisitoare de implementat.
• Codificarea prin bază, care codifică un număr întreg $k$ pregătind starea de bază corespunzătoare $|k\rangle$.
• Codificarea prin unghi, care setează fiecare număr din date ca un unghi de rotație într-un Circuit parametrizat.

Cea mai bună abordare depinde de specificul aplicației tale. Pe calculatoarele cuantice actuale, însă, folosim adesea Circuit-uri de codificare prin unghi, cum ar fi zz_feature_map.

from qiskit.circuit.library import zz_feature_map

features = [0.2, 0.4, 0.8]
feature_map = zz_feature_map(feature_dimension=len(features))

encoded = feature_map.assign_parameters(features)
encoded.draw("mpl")

Vezi Circuit-uri de codificare a datelor în documentația API a bibliotecii de circuit-uri.

Circuit-uri de evoluție temporală

Aceste circuit-uri simulează evoluția în timp a unei stări cuantice. Folosește Circuit-uri de evoluție temporală pentru a investiga efecte fizice precum transferul de căldură sau tranzițiile de fază într-un sistem. Circuit-urile de evoluție temporală sunt, de asemenea, un bloc fundamental de construcție al funcțiilor de undă din chimie (cum ar fi stările de probă unitary coupled-cluster) și al algoritmului QAOA pe care îl folosim pentru problemele de optimizare.

from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp

# Prepare an initial state with a Hadamard on the middle qubit
state = QuantumCircuit(3)
state.h(1)

hamiltonian = SparsePauliOp(["ZZI", "IZZ"])
evolution = PauliEvolutionGate(hamiltonian, time=1)

# Evolve state by appending the evolution gate
state.compose(evolution, inplace=True)

state.draw("mpl")

Citește documentația API PauliEvolutionGate.

Circuit-uri de evaluare comparativă și teoria complexității

Circuit-urile de evaluare comparativă ne oferă o idee despre cât de bine funcționează de fapt hardware-ul nostru, iar Circuit-urile din teoria complexității ne ajută să înțelegem cât de dificile sunt problemele pe care dorim să le rezolvăm.

De exemplu, evaluarea comparativă „quantum volume" măsoară cât de precis execută un calculator cuantic un tip de circuit cuantic aleatoriu. Scorul calculatorului cuantic crește odată cu dimensiunea Circuit-ului pe care îl poate rula în mod fiabil. Aceasta ia în considerare toate aspectele calculatorului, inclusiv numărul de Qubiți, fidelitatea instrucțiunilor, conectivitatea Qubiților și stiva de software care transpilează și post-procesează rezultatele. Citește mai multe despre quantum volume în lucrarea originală despre quantum volume.

Următorul cod prezintă un exemplu de circuit quantum volume construit în Qiskit care rulează pe patru Qubiți (blocurile unitary sunt porți cu doi Qubiți randomizate).

from qiskit.circuit.library import quantum_volume

quantum_volume(4).draw("mpl")

Biblioteca de circuit-uri include, de asemenea, Circuit-uri considerate dificil de simulat clasic, cum ar fi Circuit-urile instantaneous quantum polynomial (iqp). Aceste circuit-uri intercalează anumite porți diagonale (în baza computațională) între blocuri de porți Hadamard.

Alte Circuit-uri includ grover_operator pentru utilizare în algoritmul Grover și Circuit-ul fourier_checking pentru problema de verificare Fourier. Vezi aceste circuit-uri în Circuit-uri cuantice particulare în documentația API a bibliotecii de circuit-uri.

Circuit-uri aritmetice

Operațiile aritmetice sunt funcții clasice, cum ar fi adunarea numerelor întregi și operațiile pe biți. Acestea pot fi utile în algoritmi precum estimarea amplitudinii pentru aplicații financiare și în algoritmi precum algoritmul HHL, care rezolvă sisteme liniare de ecuații.

Ca exemplu, să încercăm adunarea a două numere de trei biți folosind un circuit „ripple-carry" pentru a efectua adunarea pe loc (in-place) (FullAdderGate). Acest sumator adună două numere (pe care le vom numi „A" și „B") și scrie rezultatul în registrul care conținea B. În exemplul următor, A=2 și B=3.

from qiskit.circuit.library import FullAdderGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

adder = FullAdderGate(3)  # Adder of 3-bit numbers

# Create the number A=2
reg_a = QuantumRegister(3, "a")
number_a = QuantumCircuit(reg_a)
number_a.initialize(2)  # Number 2; |010>

# Create the number B=3
reg_b = QuantumRegister(3, "b")
number_b = QuantumCircuit(reg_b)
number_b.initialize(3)  # Number 3; |011>

# Create a circuit to hold everything, including a classical register for
# the result
qregs = [
    QuantumRegister(1, "cin"),
    QuantumRegister(3, "a"),
    QuantumRegister(3, "b"),
    QuantumRegister(1, "cout"),
]
reg_result = ClassicalRegister(3)
circuit = QuantumCircuit(*qregs, reg_result)

# Compose number initializers with the adder. Adder stores the result to
# register B, so we'll measure those qubits.
circuit = (
    circuit.compose(number_a, qubits=reg_a)
    .compose(number_b, qubits=reg_b)
    .compose(adder)
)
circuit.measure(reg_b, reg_result)
circuit.draw("mpl")

Simularea Circuit-ului arată că produce 5 în toate cele 1024 de shot-uri (măsurători) (adică este măsurat cu probabilitatea 1.0).

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([circuit]).result()

print(f"Count data:\n {result[0].data.c0.get_int_counts()}")

Count data:
 {5: 1024}

Vezi Aritmetică în documentația API a bibliotecii de circuit-uri.

Pași următori

Recomandări

• Învață metode avansate de creare a Circuit-urilor în subiectul Construiește Circuit-uri.
• Vezi un exemplu de circuit-uri utilizate în tutorialul Algoritmul lui Grover.
• Consultă referința API a bibliotecii de circuit-uri.