Gate-uri fracționare

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
qiskit-ibm-runtime~=0.43.1

Această pagină prezintă două tipuri de gate-uri nou acceptate pe flota de QPU-uri IBM Quantum®. Aceste gate-uri fracționare sunt acceptate pe QPU-urile Heron sub forma:

• $R_{ZZ}(\theta)$ pentru $0 \lt \theta \leq \pi/2$
• $R_X(\theta)$ pentru orice $\theta$

Această pagină discută cazurile de utilizare în care implementarea gate-urilor fracționare poate îmbunătăți eficiența fluxurilor tale de lucru, precum și modul de utilizare a acestor gate-uri pe QPU-urile IBM Quantum.

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

Cum să folosești gate-urile fracționare

Intern, aceste gate-uri fracționare funcționează prin executarea directă a unei rotații $R_{ZZ}(\theta)$ și $R_X(\theta)$ pentru un unghi arbitrar. Utilizarea gate-ului $R_X(\theta)$ poate reduce durata și eroarea pentru rotațiile pe un singur qubit cu unghi arbitrar cu un factor de până la doi. Executarea directă a rotației gate-ului $R_{ZZ}(\theta)$ evită descompunerea în mai multe obiecte CZGate, reducând în mod similar durata și eroarea unui Circuit. Acest lucru este deosebit de util pentru Circuit-uri care conțin multe rotații pe unul și doi qubiți, cum ar fi atunci când se simulează dinamica unui sistem cuantic sau când se folosește un ansatz variațional cu mulți parametri.

Deși aceste tipuri de gate-uri se află în biblioteca de gate-uri standard pe care o poate deține un QuantumCircuit, ele pot fi folosite doar pe QPU-uri IBM Quantum specifice, și trebuie încărcate cu indicatorul use_fractional_gates setat la True (arătat mai jos). Acest indicator va asigura că gate-urile fracționare sunt incluse în Target-ul Backend-ului pentru Transpiler.

service = QiskitRuntimeService()
backend = service.backend('ibm_torino', use_fractional_gates=True)

Acest exemplu de cod demonstrează cum să folosești gate-urile fracționare în contextul unui flux de lucru care simulează dinamica unui lanț Ising folosind gate-uri fracționare. Durata Circuit-ului este apoi comparată cu un Backend care nu folosește gate-uri fracționare.

Notă despre ratele de eroare raportate

Valoarea erorii raportate în Target-ul unui Backend cu gate-uri fracționare activate este doar o copie a omologului gate-ului non-fracționar (care poate să nu fie aceeași). Aceasta se datorează faptului că raportarea ratelor de eroare pentru gate-urile fracționare nu este încă acceptată.

Cu toate acestea, deoarece timpul de gate al gate-urilor fracționare față de cele non-fracționare este același, este o presupunere rezonabilă că ratele lor de eroare sunt comparabile -- mai ales când sursa dominantă de eroare într-un Circuit se datorează relaxării.

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization.timeline import draw as draw_timeline, IQXSimple

from qiskit_ibm_runtime import QiskitRuntimeService

num_qubits = 5
num_time_steps = 3
rx_angle = 0.1
rzz_angle = 0.1

ising_circuit = QuantumCircuit(num_qubits)
for i in range(num_time_steps):
    # rx layer
    for q in range(num_qubits):
        ising_circuit.rx(rx_angle, q)
    for q in range(1, num_qubits - 1, 2):
        ising_circuit.rzz(rzz_angle, q, q + 1)
    # 2nd rzz layer
    for q in range(0, num_qubits - 1, 2):
        ising_circuit.rzz(rzz_angle, q, q + 1)
    ising_circuit.barrier()
ising_circuit.draw("mpl")

Specifică două obiecte Backend: unul cu gate-uri fracționare activate și celălalt cu acestea dezactivate, apoi transpilează-le pe amândouă.

service = QiskitRuntimeService()
backend_fractional = service.backend("ibm_torino", use_fractional_gates=True)
backend_conventional = service.backend(
    "ibm_torino", use_fractional_gates=False
)

pm_fractional = generate_preset_pass_manager(
    optimization_level=3, backend=backend_fractional, scheduling_method="alap"
)
pm_conventional = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend_conventional,
    scheduling_method="alap",
)

ising_circuit_fractional = pm_fractional.run(ising_circuit)
ising_circuit_conventional = pm_conventional.run(ising_circuit)

Afișează cronologia Circuit-ului folosind cele două tipuri de gate-uri.

# Draw timeline of circuit with conventional gates
draw_timeline(
    ising_circuit_conventional,
    idle_wires=False,
    target=backend_conventional.target,
    time_range=(0, 500),
    style=IQXSimple(),
)

# Draw timeline of circuit with fractional gates
draw_timeline(
    ising_circuit_fractional,
    idle_wires=False,
    target=backend_fractional.target,
    time_range=(0, 500),
    style=IQXSimple(),
)

Constrângeri de unghi

Pentru gate-ul $R_{ZZ}(\theta)$ pe doi qubiți, doar unghiurile între $0$ și $\pi/2$ pot fi executate pe hardware-ul IBM Quantum. Dacă un Circuit conține gate-uri $R_{ZZ}(\theta)$ cu un unghi în afara acestui interval, atunci pipeline-ul standard de transpilare va corecta de obicei acest lucru printr-o transformare adecvată a Circuit-ului (prin pasul FoldRzzAngle). Cu toate acestea, pentru orice gate $R_{ZZ}(\theta)$ care conține unul sau mai mulți Parameter, Transpiler-ul va presupune că acestor parametri li se vor atribui unghiuri în acest interval la momentul execuției. Jobul va eșua dacă oricare dintre valorile parametrilor specificate în PUB-ul trimis la Qiskit Runtime se află în afara acestui interval.

Unde să folosești gate-urile fracționare

Istoric, gate-urile de bază disponibile pe QPU-urile IBM Quantum au fost CZ, X, RZ, SX și ID, care nu pot reprezenta eficient Circuit-uri cu rotații pe unul și doi qubiți care nu sunt multipli de $\pi / 2$. De exemplu, un gate $R_X(\theta)$, când este transpilat, trebuie descompus într-o serie de gate-uri $RZ$ și $\sqrt{X}$, ceea ce creează un Circuit cu două gate-uri de durată finită în loc de unul.

În mod similar, când rotațiile pe doi qubiți, cum ar fi un gate $R_{ZZ}(\theta)$, sunt transpilate, descompunerea necesită două gate-uri CZ și mai multe gate-uri pe un singur qubit, ceea ce crește adâncimea Circuit-ului. Aceste descompuneri sunt arătate în codul următor.

qc = QuantumCircuit(1)
param = Parameter("θ")
qc.rx(param, 0)
qc.draw("mpl")

# Decomposition of an RX(θ) gate using the IBM Quantum QPU basis
service = QiskitRuntimeService()
backend = service.backend("ibm_torino")
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService

qc = QuantumCircuit(2)
param = Parameter("θ")
qc.rzz(param, 0, 1)
qc.draw("mpl")

# Decomposition of an RZZ(θ) gate using the IBM Quantum QPU basis
service = QiskitRuntimeService()
backend = service.backend("ibm_torino")
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

Pentru fluxurile de lucru care necesită multe rotații $R_X(\theta)$ pe un singur Qubit sau pe doi qubiți (cum ar fi într-un ansatz variațional sau când se simulează evoluția în timp a sistemelor cuantice), această constrângere face ca adâncimea Circuit-ului să crească rapid. Cu toate acestea, gate-urile fracționare elimină această cerință, deoarece rotațiile pe unul și doi qubiți sunt executate direct, creând un Circuit cuantic mai eficient (și astfel cu erori suprimate).

Când să nu folosești gate-uri fracționare

Este important de menționat că gate-urile fracționare sunt o funcționalitate experimentală și comportamentul indicatorului use_fractional_gates poate să se schimbe în viitor. Consultă notele de lansare pentru versiunile noi ale Qiskit Runtime pentru mai multe informații. Vezi, de asemenea, documentația de referință API pentru QiskitRuntimeService.backend, care descrie use_fractional_gates.

În plus, Transpiler-ul Qiskit are capacitate limitată de a folosi $R_{ZZ}(\theta)$ în pasajele sale de optimizare. Acest lucru necesită să ai mai multă grijă în elaborarea și optimizarea Circuit-urilor care conțin aceste instrucțiuni.

În cele din urmă, utilizarea gate-urilor fracționare nu este acceptată pentru:

• Circuit-uri dinamice
• Pauli twirling - totuși, measurement twirling cu TREX este acceptat.
• Anularea probabilistică a erorilor
• Extrapolarea zgomotului zero (folosind amplificarea probabilistică a erorilor)

Citește ghidul despre opțiunile primitive pentru a afla mai multe despre personalizarea tehnicilor de atenuare și suprimare a erorilor pentru o anumită sarcină de lucru cuantică.

Pașii următori

Recomandări

• Pentru a afla mai multe despre transpilare, consultă pagina introducere în transpilare.
• Citește despre scrierea unui pas personalizat pentru Transpiler.
• Înțelege cum să configurezi atenuarea erorilor pentru Qiskit Runtime.