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.3.0

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.

Gate-uri standard

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

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

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit

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 Gate-uri standard în documentația API a bibliotecii de Circuit-uri.

Nu știi cum se numește Gate-ul tău? Încearcă să întrebi Asistentul de Cod Qiskit.

Circuit-uri N-local

Aceste Circuit-uri alternează straturi de Gate-uri de rotație cu un singur Qubit cu straturi de Gate-uri de entanglement cu 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 Gate-urilor 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 Gate-urile de entanglement sunt Gate-uri cu doi Qubiți. Acest Circuit intercalează blocuri de Gate-uri cu un singur Qubit parametrizate, urmate de blocuri de entanglement cu Gate-uri cu doi Qubiți. Următorul cod creează un Circuit cu trei Qubiți, cu Gate-uri RX cu un singur Qubit și Gate-uri 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ă Gate-uri 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 Gate-uri 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 Gate-uri diagonale (în baza computațională) între blocuri de Gate-uri 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 cu 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 în loc (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 pentru toate cele 1024 de rulări (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.