Zlomkové Gate

Verze balíčků

Kód na této stránce byl vyvinut s použitím následujících požadavků. Doporučujeme použít tyto verze nebo novější.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Tato stránka představuje dva nově podporované typy Gate na flotile QPU IBM Quantum®. Tyto zlomkové Gate jsou podporovány na Heron QPU v podobě:

• $R_{ZZ}(\theta)$ pro $0 \lt \theta \leq \pi/2$
• $R_X(\theta)$ pro libovolné $\theta$

Tato stránka popisuje případy použití, kde implementace zlomkových Gate může zlepšit efektivitu tvých pracovních postupů, a také jak tyto Gate používat na QPU IBM Quantum.

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

Jak používat zlomkové Gate

Interně tyto zlomkové Gate fungují tak, že přímo provádějí rotaci $R_{ZZ}(\theta)$ a $R_X(\theta)$ pro libovolný úhel. Použití Gate $R_X(\theta)$ může snížit dobu trvání a chybu pro jednoqubitové rotace libovolného úhlu až o faktor dvou. Přímé provedení rotace Gate $R_{ZZ}(\theta)$ se vyhýbá rozkladu na více objektů CZGate, čímž podobně snižuje dobu trvání Circuit a její chybu. To je obzvlášť užitečné pro Circuit obsahující mnoho jednoqubitových a dvouqubitových rotací, například při simulaci dynamiky kvantového systému nebo při použití variačního ansatzu s mnoha parametry.

Přestože tyto typy Gate jsou v knihovně standardních Gate, které může QuantumCircuit obsahovat, lze je použít pouze na konkrétních QPU IBM Quantum, přičemž musejí být načteny s příznakem use_fractional_gates nastaveným na True (viz níže). Tento příznak zajistí, že zlomkové Gate budou zahrnuty do Target Backendu pro Transpiler.

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

Tento příklad kódu ukazuje, jak použít zlomkové Gate v kontextu pracovního postupu, který simuluje dynamiku Isingova řetězce pomocí zlomkových Gate. Doba trvání Circuit je poté porovnána s Backendem, který zlomkové Gate nepoužívá.

Poznámka k hlášeným chybovým sazbám

Hodnota chyby hlášená v Target Backendu se zapnutými zlomkovými Gate je pouze kopií protějšku nefrakčního Gate (která nemusí být stejná). Důvodem je, že hlášení chybových sazeb pro zlomkové Gate zatím není podporováno.

Jelikož jsou však doby trvání Gate u zlomkových a nefrakčních Gate stejné, je rozumné předpokládat, že jejich chybové sazby jsou srovnatelné — zejména pokud je dominantním zdrojem chyby v Circuit relaxace.

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")

Zadej dva objekty Backend: jeden se zapnutými zlomkovými Gate a druhý s vypnutými, poté oba transpiluj.

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)

Zobraz časovou osu Circuit s použitím obou typů Gate.

# 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(),
)

Omezení úhlů

Pro dvouqubitový Gate $R_{ZZ}(\theta)$ lze na hardwaru IBM Quantum provádět pouze úhly mezi $0$ a $\pi/2$. Pokud Circuit obsahuje jakékoli Gate $R_{ZZ}(\theta)$ s úhlem mimo tento rozsah, standardní transpilační pipeline toto obecně opraví příslušnou transformací Circuit (prostřednictvím průchodu FoldRzzAngle). Pro jakýkoli Gate $R_{ZZ}(\theta)$ obsahující jeden nebo více Parameterů však Transpiler předpokládá, že tyto parametry budou za běhu přiřazeny úhly v tomto rozsahu. Úloha selže, pokud některá z hodnot parametrů zadaných v PUB odeslaném do Qiskit Runtime leží mimo tento rozsah.

Kde používat zlomkové Gate

Historicky byly bázové Gate dostupné na QPU IBM Quantum CZ, X, RZ, SX a ID, které nemohou efektivně reprezentovat Circuit s jednoqubitovými a dvouqubitovými rotacemi, jež nejsou násobky $\pi / 2$. Například Gate $R_X(\theta)$, pokud je transpilován, musí být rozložen do série Gate $RZ$ a $\sqrt{X}$, čímž vznikne Circuit se dvěma Gate konečné doby trvání místo jednoho.

Podobně, když jsou dvouqubitové rotace jako Gate $R_{ZZ}(\theta)$ transpilovány, rozklad vyžaduje dva Gate CZ a několik jednoqubitových Gate, což zvyšuje hloubku Circuit. Tyto rozklady jsou znázorněny v následujícím kódu.

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)

Pro pracovní postupy vyžadující mnoho jednoqubitových rotací $R_X(\theta)$ nebo dvouqubitových rotací (například ve variačním ansatzu nebo při simulaci časového vývoje kvantových systémů) způsobuje toto omezení rychlý nárůst hloubky Circuit. Zlomkové Gate však tento požadavek odstraňují, protože jednoqubitové a dvouqubitové rotace jsou prováděny přímo a vytvářejí efektivnější (a tedy chybami méně ovlivněný) kvantový Circuit.

Kdy zlomkové Gate nepoužívat

Je důležité poznamenat, že zlomkové Gate jsou experimentální funkcí a chování příznaku use_fractional_gates se může v budoucnu změnit. Další informace najdeš v poznámkách k vydání nových verzí Qiskit Runtime. Viz také referenční dokumentaci API pro QiskitRuntimeService.backend, která popisuje use_fractional_gates.

Transpiler Qiskit má navíc omezenou schopnost využívat $R_{ZZ}(\theta)$ ve svých optimalizačních průchodech. To vyžaduje, abys věnoval větší pozornost tvorbě a optimalizaci Circuit obsahujících tyto instrukce.

A konečně, použití zlomkových Gate není podporováno pro:

• Dynamické Circuit
• Pauliho twirling — avšak twirling měření pomocí TREX je podporován.
• Pravděpodobnostní rušení chyb
• Extrapolace nulového šumu (pomocí pravděpodobnostního zesílení chyb)

Přečti si průvodce možnostmi primitive a zjisti více o přizpůsobení technik zmírnění a potlačení chyb pro danou kvantovou zátěž.

Další kroky

Doporučení

• Chceš-li se dozvědět více o transpilaci, přečti si stránku úvod do transpilace.
• Přečti si o psaní vlastního průchodu Transpileru.
• Zjisti, jak nakonfigurovat zmírnění chyb pro Qiskit Runtime.