Fraktionale Gates

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0

Diese Seite stellt zwei neu unterstützte Gate-Typen auf der QPU-Flotte von IBM Quantum® vor. Diese fraktionalen Gates werden auf Heron QPUs in folgender Form unterstützt:

• $R_{ZZ}(\theta)$ für $0 \lt \theta \leq \pi/2$
• $R_X(\theta)$ für beliebige $\theta$

Diese Seite behandelt die Anwendungsfälle, in denen die Implementierung fraktionaler Gates die Effizienz deiner Workflows verbessern kann, sowie die Verwendung dieser Gates auf IBM Quantum QPUs.

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

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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")

Wie man fraktionale Gates verwendet

Intern funktionieren diese fraktionalen Gates durch direkte Ausführung einer $R_{ZZ}(\theta)$ und $R_X(\theta)$ Rotation für einen beliebigen Winkel. Die Verwendung des $R_X(\theta)$ Gates kann die Dauer und den Fehler für Ein-Qubit-Rotationen beliebigen Winkels um bis zu einen Faktor zwei reduzieren. Die direkte Ausführung der $R_{ZZ}(\theta)$ Gate-Rotation vermeidet die Zerlegung in mehrere CZGate-Objekte und reduziert somit ebenfalls die Dauer und den Fehler eines Schaltkreises. Dies ist besonders nützlich für Schaltkreise, die viele Ein- und Zwei-Qubit-Rotationen enthalten, wie etwa bei der Simulation der Dynamik eines Quantensystems oder bei der Verwendung eines variationalen Ansatzes mit vielen Parametern.

Obwohl diese Arten von Gates in der Bibliothek der Standardgates enthalten sind, die ein QuantumCircuit besitzen kann, können sie nur auf spezifischen IBM Quantum QPUs verwendet werden und müssen mit dem auf True gesetzten Flag use_fractional_gates geladen werden (siehe unten). Dieses Flag stellt sicher, dass fraktionale Gates im Target des Backends für den Transpiler enthalten sind.

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

Dieses Codebeispiel demonstriert, wie fraktionale Gates im Kontext eines Workflows verwendet werden, der die Dynamik einer Ising-Kette unter Verwendung fraktionaler Gates simuliert. Die Schaltkreisdauer wird dann mit einem Backend verglichen, das keine fraktionalen Gates verwendet.

Hinweis zu gemeldeten Fehlerraten

Der im Target eines Backends mit aktivierten fraktionalen Gates gemeldete Fehlerwert ist lediglich eine Kopie des Gegenstücks des nicht-fraktionalen Gates (was möglicherweise nicht identisch ist). Dies liegt daran, dass die Meldung von Fehlerraten für fraktionale Gates noch nicht unterstützt wird.

Da jedoch die Gate-Zeit von fraktionalen und nicht-fraktionalen Gates gleich ist, ist es eine vernünftige Annahme, dass ihre Fehlerraten vergleichbar sind - insbesondere wenn die dominierende Fehlerquelle in einem Schaltkreis auf Relaxation zurückzuführen ist.

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

Spezifiziere zwei Backend-Objekte: eines mit aktivierten fraktionalen Gates und das andere mit deaktivierten Gates, und transpiliere beide.

service = QiskitRuntimeService()
backend_name = service.least_busy(operational=True, simulator=False).name
backend_fractional = service.backend(backend_name, use_fractional_gates=True)
backend_conventional = service.backend(
    backend_name, 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)

Zeige die Zeitachse des Schaltkreises unter Verwendung der beiden Gate-Typen an.

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

Winkelbeschränkungen

Für das Zwei-Qubit $R_{ZZ}(\theta)$ Gate können auf IBM Quantum Hardware nur Winkel zwischen $0$ und $\pi/2$ ausgeführt werden. Wenn ein Schaltkreis $R_{ZZ}(\theta)$ Gates mit einem Winkel außerhalb dieses Bereichs enthält, wird die Standard-Transpilations-Pipeline dies in der Regel mit einer geeigneten Schaltkreistransformation korrigieren (durch den FoldRzzAngle Pass). Für $R_{ZZ}(\theta)$ Gates, die einen oder mehrere Parameter enthalten, wird der Transpiler jedoch annehmen, dass diesen Parametern zur Laufzeit Winkel innerhalb dieses Bereichs zugewiesen werden. Der Job schlägt fehl, wenn einer der im an den IBM Quantum Compute Service übermittelten PUB angegebenen Parameterwerte außerhalb dieses Bereichs liegt.

Wo man fraktionale Gates verwendet

Historisch waren die auf IBM Quantum QPUs verfügbaren Basis-Gates CZ, X, RZ, SX und ID, die Schaltkreise mit Ein- und Zwei-Qubit-Rotationen, die keine Vielfachen von $\pi / 2$ sind, nicht effizient darstellen können. Beispielsweise muss ein $R_X(\theta)$ Gate bei der Transpilation in eine Reihe von $RZ$ und $\sqrt{X}$ Gates zerlegt werden, was einen Schaltkreis mit zwei Gates endlicher Dauer anstelle von einem erzeugt.

Ebenso erfordert die Zerlegung von Zwei-Qubit-Rotationen wie einem $R_{ZZ}(\theta)$ Gate bei der Transpilation zwei CZ Gates und mehrere Ein-Qubit-Gates, was die Schaltkreistiefe erhöht. Diese Zerlegungen werden im folgenden Code gezeigt.

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.least_busy(operational=True, simulator=False)
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.least_busy(operational=True, simulator=False)
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

Für Workflows, die viele Ein-Qubit $R_X(\theta)$ oder Zwei-Qubit-Rotationen erfordern (wie in einem variationalen Ansatz oder bei der Simulation der Zeitentwicklung von Quantensystemen), führt diese Beschränkung zu einem schnellen Wachstum der Schaltkreistiefe. Fraktionale Gates beseitigen jedoch diese Anforderung, da die Ein- und Zwei-Qubit-Rotationen direkt ausgeführt werden und einen effizienteren (und damit fehlerunterdrückten) Quantenschaltkreis erzeugen.

Wann man fraktionale Gates nicht verwenden sollte

Es ist wichtig zu beachten, dass fraktionale Gates eine experimentelle Funktion sind und sich das Verhalten des use_fractional_gates-Flags in Zukunft ändern kann. Schau in den Release Notes für neue Versionen von qiskit-ibm-runtime nach weiteren Informationen. Siehe auch die API-Referenzdokumentation für QiskitRuntimeService.backend, die use_fractional_gates beschreibt.

Zusätzlich hat der Qiskit-Transpiler nur begrenzte Fähigkeiten, $R_{ZZ}(\theta)$ in seinen Optimierungsdurchläufen (Passes) zu verwenden. Dies erfordert mehr Sorgfalt beim Erstellen und Optimieren von Schaltkreisen, die diese Instruktionen enthalten.

Schließlich wird die Verwendung fraktionaler Gates nicht unterstützt für:

• Pauli Twirling - jedoch wird Measurement Twirling mit TREX unterstützt.
• Probabilistic Error Cancellation
• Zero-Noise Extrapolation (unter Verwendung von Probabilistic Error Amplification)

Lies den Leitfaden zu Primitive-Optionen, um mehr über die Anpassung der Fehlermilderungs- und Fehlerunterdrückungstechniken für einen bestimmten Quanten-Workload zu erfahren.

Welche Backends unterstützen fraktionale Gates?

Nicht alle Backends unterstützen fraktionale Gates. Führe service.backends(use_fractional_gates=True) aus, um die Backends zu finden, die sie unterstützen. Mit der Veröffentlichung von qiskit-ibm-runtime v0.48 kannst du auch service.least_busy(fractional_gates=True) ausführen, um das am wenigsten ausgelastete Backend zu finden, das fraktionale Gates unterstützt. Ein Fake-Backend unterstützt fraktionale Gates nur, wenn das zugehörige "echte" Backend sie unterstützt.

Beachte, dass Fake-Backends fraktionale Gates standardmäßig nicht unterstützen, da fraktionale Gates standardmäßig deaktiviert sind. Um fraktionale Gates auf einem Fake-Backend zu aktivieren, das sie unterstützt, aktualisiere dessen Konfiguration.

Beispiel:

service = QiskitRuntimeService()
fake_backend = FakeBoston()
fake_backend.refresh(service=service, use_fractional_gates=True)

Nächste Schritte

Empfehlungen

• Um mehr über Transpilation zu erfahren, siehe die Seite Einführung in die Transpilation.
• Lies über das Schreiben eines benutzerdefinierten Transpiler-Passes.
• Verstehe, wie du Fehlerminderung konfigurierst.