Portes fractionnaires

Versions des paquets

Le code de cette page a été développé avec les dépendances suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

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

Cette page présente deux nouveaux types de portes désormais pris en charge sur la flotte de QPUs IBM Quantum®. Ces portes fractionnaires sont disponibles sur les QPUs Heron sous la forme suivante :

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

Cette page aborde les cas d'usage dans lesquels l'implémentation de portes fractionnaires peut améliorer l'efficacité de tes workflows, ainsi que la manière d'utiliser ces portes sur les QPUs IBM Quantum.

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

Comment utiliser les portes fractionnaires

En interne, ces portes fractionnaires fonctionnent en exécutant directement une rotation $R_{ZZ}(\theta)$ et $R_X(\theta)$ pour un angle arbitraire. L'utilisation de la porte $R_X(\theta)$ peut réduire la durée et l'erreur des rotations à un seul qubit d'angle arbitraire par un facteur pouvant aller jusqu'à deux. L'exécution directe de la rotation de la porte $R_{ZZ}(\theta)$ évite la décomposition en plusieurs objets CZGate, réduisant ainsi la durée et l'erreur d'un circuit. C'est particulièrement utile pour les circuits qui contiennent de nombreuses rotations à un et deux qubits, comme lors de la simulation de la dynamique d'un système quantique ou lors de l'utilisation d'un ansatz variationnel avec de nombreux paramètres.

Bien que ces types de portes fassent partie de la bibliothèque de portes standard qu'un QuantumCircuit peut posséder, elles ne peuvent être utilisées que sur des QPUs IBM Quantum spécifiques, et doivent être chargées avec l'option use_fractional_gates définie à True (comme indiqué ci-dessous). Cette option garantit que les portes fractionnaires sont incluses dans le Target du backend pour le transpiler.

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

Cet exemple de code montre comment utiliser les portes fractionnaires dans le cadre d'un workflow qui simule la dynamique d'une chaîne d'Ising avec des portes fractionnaires. La durée du circuit est ensuite comparée à celle d'un backend qui n'utilise pas de portes fractionnaires.

Note sur les taux d'erreur rapportés

La valeur d'erreur rapportée dans le Target d'un backend avec les portes fractionnaires activées n'est qu'une copie de l'équivalent de la porte non fractionnaire (qui peut ne pas être identique). En effet, la communication des taux d'erreur pour les portes fractionnaires n'est pas encore prise en charge.

Cependant, étant donné que le temps de porte des portes fractionnaires et non fractionnaires est identique, il est raisonnable de supposer que leurs taux d'erreur sont comparables — en particulier lorsque la principale source d'erreur dans un circuit est due à la relaxation.

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

Spécifie deux objets backend : l'un avec les portes fractionnaires activées, et l'autre avec elles désactivées, puis transpile-les tous les deux.

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)

Affiche la chronologie du circuit en utilisant les deux types de portes.

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

Contraintes d'angle

Pour la porte à deux qubits $R_{ZZ}(\theta)$, seuls les angles compris entre $0$ et $\pi/2$ peuvent être exécutés sur le matériel IBM Quantum. Si un circuit contient des portes $R_{ZZ}(\theta)$ dont l'angle est en dehors de cette plage, le pipeline de transpilation standard corrigera généralement cela par une transformation de circuit appropriée (via la passe FoldRzzAngle). Cependant, pour toute porte $R_{ZZ}(\theta)$ contenant un ou plusieurs Parameters, le transpiler supposera que ces paramètres se verront attribuer des angles dans cette plage au moment de l'exécution. Le job échouera si l'une des valeurs de paramètre spécifiées dans le PUB soumis à Qiskit Runtime est en dehors de cette plage.

Où utiliser les portes fractionnaires

Historiquement, les portes de base disponibles sur les QPUs IBM Quantum ont été CZ, X, RZ, SX et ID, qui ne peuvent pas représenter efficacement les circuits avec des rotations à un et deux qubits qui ne sont pas des multiples de $\pi / 2$. Par exemple, une porte $R_X(\theta)$, lorsqu'elle est transpilée, doit se décomposer en une série de portes $RZ$ et $\sqrt{X}$, ce qui crée un circuit avec deux portes de durée finie au lieu d'une.

De même, lorsque des rotations à deux qubits telles qu'une porte $R_{ZZ}(\theta)$ sont transpilées, la décomposition nécessite deux portes CZ et plusieurs portes à un qubit, ce qui augmente la profondeur du circuit. Ces décompositions sont illustrées dans le code suivant.

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)

Pour les workflows qui nécessitent de nombreuses rotations $R_X(\theta)$ à un qubit ou à deux qubits (comme dans un ansatz variationnel ou lors de la simulation de l'évolution temporelle de systèmes quantiques), cette contrainte fait croître rapidement la profondeur du circuit. Cependant, les portes fractionnaires suppriment cette contrainte, car les rotations à un et deux qubits sont exécutées directement, créant ainsi un circuit quantique plus efficace (et donc moins sujet aux erreurs).

Quand ne pas utiliser les portes fractionnaires

Il est important de noter que les portes fractionnaires sont une fonctionnalité expérimentale et que le comportement de l'option use_fractional_gates est susceptible d'évoluer dans les futures versions. Consulte les notes de version des nouvelles versions de Qiskit Runtime pour plus d'informations. Voir aussi la documentation de référence de l'API pour QiskitRuntimeService.backend, qui décrit use_fractional_gates.

De plus, le transpiler Qiskit a une capacité limitée à utiliser $R_{ZZ}(\theta)$ dans ses passes d'optimisation. Cela t'oblige à être plus attentif dans la conception et l'optimisation des circuits contenant ces instructions.

Enfin, l'utilisation de portes fractionnaires n'est pas prise en charge pour :

• Les circuits dynamiques
• Le Pauli twirling — en revanche, le measurement twirling avec TREX est pris en charge.
• L'annulation probabiliste des erreurs
• L'extrapolation zéro-bruit (utilisant l'amplification probabiliste des erreurs)

Lis le guide sur les options primitives pour en savoir plus sur la personnalisation des techniques de mitigation et de suppression des erreurs pour un workload quantique donné.

Prochaines étapes

Recommandations

• Pour en savoir plus sur la transpilation, consulte la page introduction à la transpilation.
• Lis la page sur l'écriture d'une passe de transpileur personnalisée.
• Comprends comment configurer la mitigation des erreurs pour Qiskit Runtime.