Quantenschaltkreis-Optimierung

hinweis

Toshinari Itoko (21. Juni 2024)

PDF der Originalvorlesung herunterladen. Bitte beachte, dass einige Code-Snippets veraltet sein können, da es sich um statische Bilder handelt.

Die ungefähre QPU-Zeit für dieses Experiment beträgt 15 s.

(Hinweis: Einige Zellen in Teil 2 stammen aus dem Notebook „Qiskit Deep Dive" von Matthew Treinish (Qiskit-Maintainer))

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

# !pip install 'qiskit[visualization]'
# !pip install qiskit_ibm_runtime qiskit_aer
# !pip install jupyter
# !pip install matplotlib pylatexenc pydot pillow

import qiskit

qiskit.__version__

'2.0.2'

import qiskit_ibm_runtime

qiskit_ibm_runtime.__version__

'0.40.1'

import qiskit_aer

qiskit_aer.__version__

'0.17.1'

1. Einführung

Diese Lektion behandelt verschiedene Aspekte der Circuit-Optimierung im Quantencomputing. Konkret werden wir den Nutzen der Circuit-Optimierung anhand der in Qiskit integrierten Optimierungseinstellungen kennenlernen. Anschließend gehen wir etwas tiefer und zeigen, was du als Experte in deinem Anwendungsbereich tun kannst, um Circuits gezielt zu konstruieren. Abschließend werfen wir einen genauen Blick darauf, was während der Transpilierung geschieht, um unsere Circuits zu optimieren.

2. Circuit-Optimierung ist wichtig

Wir vergleichen zunächst die Ergebnisse des Ausführens von 5-Qubit-GHZ-Zustands-Präparations-Circuits ($\frac{1}{\sqrt{2}} \left( |00000\rangle + |11111\rangle \right)$) mit und ohne Optimierung.

from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.primitives import BackendSamplerV2 as Sampler

from qiskit_ibm_runtime.fake_provider import FakeBrisbane

backend = FakeBrisbane()

Zunächst verwenden wir einen GHZ-Circuit, der naiv wie folgt synthetisiert wird.

num_qubits = 5

ghz_circ = QuantumCircuit(num_qubits)
ghz_circ.h(0)
[ghz_circ.cx(0, i) for i in range(1, num_qubits)]
ghz_circ.measure_all()
ghz_circ.draw("mpl")

2.1 Optimierungsstufe

Es stehen 4 optimization_level-Werte von 0–3 zur Verfügung. Je höher die Optimierungsstufe, desto mehr Rechenaufwand wird für die Optimierung des Circuits betrieben. Stufe 0 führt keine Optimierung durch und erledigt nur das Nötigste, damit der Circuit auf dem ausgewählten Backend ausgeführt werden kann. Stufe 3 investiert den größten Aufwand (und typischerweise die längste Laufzeit), um den Circuit zu optimieren. Stufe 1 ist die Standard-Optimierungsstufe. Wir transpilieren den Circuit ohne Optimierung (optimization_level=0) und mit Optimierung (optimization_level=2). Dabei sehen wir einen deutlichen Unterschied in der Länge der transpilierten Circuits.

pm0 = generate_preset_pass_manager(
    optimization_level=0, backend=backend, seed_transpiler=777
)
pm2 = generate_preset_pass_manager(
    optimization_level=2, backend=backend, seed_transpiler=777
)
circ0 = pm0.run(ghz_circ)
circ2 = pm2.run(ghz_circ)
print("optimization_level=0:")
display(circ0.draw("mpl", idle_wires=False, fold=-1))
print("optimization_level=2:")
display(circ2.draw("mpl", idle_wires=False, fold=-1))

optimization_level=0:

optimization_level=2:

2.2 Übung

Probiere auch optimization_level=1 aus und vergleiche den resultierenden Circuit mit den obigen zwei. Passe dazu den Code oben an.

Lösung:

pm1 = generate_preset_pass_manager(
    optimization_level=1, backend=backend, seed_transpiler=777
)
circ1 = pm1.run(ghz_circ)
print("optimization_level=1:")
display(circ1.draw("mpl", idle_wires=False, fold=-1))

optimization_level=1:

Ausführung auf einem Fake-Backend (verrauschte Simulation). Wie man auf einem echten Backend ausführt, ist in Anhang 1 beschrieben.

# run the circuits on the fake backend (noisy simulator)
sampler = Sampler(backend=backend)
job = sampler.run([circ0, circ2], shots=10000)
print(f"Job ID: {job.job_id()}")

Job ID: 93a4ac70-e3ea-44ad-aea9-5045840c9076

# get results
result = job.result()
unoptimized_result = result[0].data.meas.get_counts()
optimized_result = result[1].data.meas.get_counts()

from qiskit.visualization import plot_histogram

# plot
sim_result = {"0" * 5: 0.5, "1" * 5: 0.5}
plot_histogram(
    [result for result in [sim_result, unoptimized_result, optimized_result]],
    bar_labels=False,
    legend=[
        "ideal",
        "no optimization",
        "with optimization",
    ],
)

3. Circuit-Synthese ist wichtig

Als Nächstes vergleichen wir die Ergebnisse zweier unterschiedlich synthetisierter 5-Qubit-GHZ-Zustandspräparations-Circuits ($\frac{1}{\sqrt{2}} \left( |00000\rangle + |11111\rangle \right)$).

# Original GHZ circuit (naive synthesis)
ghz_circ.draw("mpl")

# A cleverly-synthesized GHZ circuit
ghz_circ2 = QuantumCircuit(5)
ghz_circ2.h(2)
ghz_circ2.cx(2, 1)
ghz_circ2.cx(2, 3)
ghz_circ2.cx(1, 0)
ghz_circ2.cx(3, 4)
ghz_circ2.measure_all()
ghz_circ2.draw("mpl")

# transpile both with the same optimization level 2
circ_org = pm2.run(ghz_circ)
circ_new = pm2.run(ghz_circ2)
print("original synthesis:")
display(circ_org.draw("mpl", idle_wires=False, fold=-1))
print("new synthesis:")
display(circ_new.draw("mpl", idle_wires=False, fold=-1))

original synthesis:

new synthesis:

Die neue Synthese erzeugt einen flacheren Circuit. Warum?

Das liegt daran, dass der neue Circuit auf linear verbundenen Qubits platziert werden kann und damit auch auf IBMs® Heavy-Hexagon-Kopplungsgraphen von Brisbane funktioniert, während der ursprüngliche Circuit eine sternförmige Konnektivität (ein Knoten vom Grad 4) erfordert und daher nicht auf dem Heavy-Hex-Kopplungsgraphen platziert werden kann, dessen Knoten maximal Grad 3 haben. Infolgedessen erfordert der ursprüngliche Circuit ein Qubit-Routing, das SWAP-Gates hinzufügt und damit die Gate-Anzahl erhöht.

Was wir mit dem neuen Circuit gemacht haben, lässt sich als manuelle „kopplungsbeschränkungsbewusste" Circuit-Synthese betrachten. Mit anderen Worten: Circuit-Synthese und Circuit-Mapping wurden gleichzeitig manuell gelöst.

# run the circuits
sampler = Sampler(backend=backend)
job = sampler.run([circ_org, circ_new], shots=10000)
print(f"Job ID: {job.job_id()}")

Job ID: 19d635b0-4d8b-44c2-a76e-49e4b9078b1b

# get results
result = job.result()
synthesis_org_result = result[0].data.meas.get_counts()
synthesis_new_result = result[1].data.meas.get_counts()

# plot
sim_result = {"0" * 5: 0.5, "1" * 5: 0.5}
plot_histogram(
    [
        result
        for result in [
            sim_result,
            unoptimized_result,
            synthesis_org_result,
            synthesis_new_result,
        ]
    ],
    bar_labels=False,
    legend=[
        "ideal",
        "no optimization",
        "synthesis_org",
        "synthesis_new",
    ],
)

Im Allgemeinen hängt die Circuit-Synthese von der Anwendung ab, und es ist für Software zu schwierig, alle möglichen Anwendungen abzudecken. Der Qiskit-Transpiler verfügt zufällig über keine Funktionen zur Synthese von GHZ-Zustandspräparations-Circuits. In solchen Fällen ist eine manuelle Circuit-Synthese wie oben gezeigt eine sinnvolle Option. In diesem Abschnitt untersuchen wir anhand des folgenden Beispiel-Circuits, wie der Qiskit-Transpiler im Detail funktioniert.

# Build a toy example circuit
from math import pi
import itertools
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import excitation_preserving

circuit = QuantumCircuit(4, name="Example circuit")
circuit.append(excitation_preserving(4, reps=1, flatten=True), range(4))
circuit.measure_all()

value_cycle = itertools.cycle([0, pi / 4, pi / 2, 3 * pi / 4, pi, 2 * pi])
circuit.assign_parameters(
    [x[1] for x in zip(range(len(circuit.parameters)), value_cycle)], inplace=True
)
circuit.draw("mpl")

3.1 Den gesamten Qiskit-Transpilierungsablauf darstellen

Wir betrachten die Transpiler-Passes (Aufgaben) für optimization_level=1.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# There is no need to read this entire image, but this outputs all the steps in the transpile() call
# for optimization level 1
pm = generate_preset_pass_manager(1, backend, seed_transpiler=42)
pm.draw()

Der Ablauf besteht aus sechs Stufen:

print(pm.stages)

('init', 'layout', 'routing', 'translation', 'optimization', 'scheduling')

3.2 Eine einzelne Stufe darstellen

Stellen wir zunächst alle Aufgaben (Transpiler-Passes) der init-Stufe dar.

pm.init.draw()

Wir können jede einzelne Stufe ausführen. Führen wir die init-Stufe für unseren Circuit aus. Durch Aktivierung des Loggers können wir die Details des Ablaufs sehen.

import logging

logger = logging.getLogger()
logger.setLevel("INFO")

init_out = pm.init.run(circuit)
init_out.draw("mpl", fold=-1)

INFO:qiskit.passmanager.base_tasks:Pass: UnitarySynthesis - 0.03576 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: HighLevelSynthesis - 0.16618 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: BasisTranslator - 0.07176 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: InverseCancellation - 0.27299 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: ContractIdleWiresInControlFlow - 0.00811 (ms)

3.3 Übung

Stelle die Passes der layout-Stufe dar und führe die Stufe für den Ausgabe-Circuit der init-Stufe (init_out) aus, indem du die oben verwendeten Zellen anpasst.

Lösung:

display(pm.layout.draw())
layout_out = pm.layout.run(init_out)
layout_out.draw("mpl", idle_wires=False, fold=-1)

INFO:qiskit.passmanager.base_tasks:Pass: SetLayout - 0.01001 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: TrivialLayout - 0.07129 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: CheckMap - 0.08917 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: VF2Layout - 1.24431 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: BarrierBeforeFinalMeasurements - 0.02599 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: SabreLayout - 5.11169 (ms)

Mache dasselbe für die translation-Stufe.

Lösung:

display(pm.translation.draw())
basis_out = pm.translation.run(layout_out)
basis_out.draw("mpl", idle_wires=False, fold=-1)

INFO:qiskit.passmanager.base_tasks:Pass: UnitarySynthesis - 0.03386 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: HighLevelSynthesis - 0.02718 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: BasisTranslator - 2.64192 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: CheckGateDirection - 0.02217 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: GateDirection - 0.36502 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: BasisTranslator - 0.64778 (ms)

Hinweis: Nicht jede einzelne Stufe kann immer unabhängig ausgeführt werden, da einige Informationen aus einer vorherigen Stufe übernehmen müssen.

3.4 Optimierungsstufe

Die letzte Standard-Stufe in der Pipeline ist die Optimierung. Nachdem der Circuit für das Zielsystem eingebettet wurde, ist er erheblich gewachsen. Das liegt hauptsächlich an Ineffizienzen in den Äquivalenzbeziehungen aus der Basis-Übersetzung und der SWAP-Einfügung. Die Optimierungsstufe versucht, Größe und Tiefe des Circuits zu minimieren. Sie führt eine Reihe von Passes in einer do while-Schleife aus, bis ein stabiles Ergebnis erreicht wird.

# pm.pre_optimization.draw()
pm.optimization.draw()

logger = logging.getLogger()
logger.setLevel("INFO")
opt_out = pm.optimization.run(basis_out)

INFO:qiskit.passmanager.base_tasks:Pass: Depth - 0.30112 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: FixedPoint - 0.03195 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Size - 0.01216 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: FixedPoint - 0.01001 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Optimize1qGatesDecomposition - 0.63729 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: InverseCancellation - 0.41723 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: ContractIdleWiresInControlFlow - 0.01192 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: GatesInBasis - 0.05484 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Depth - 0.08583 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: FixedPoint - 0.20599 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Size - 0.00787 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: FixedPoint - 0.00715 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Optimize1qGatesDecomposition - 0.16809 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: InverseCancellation - 0.17190 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: ContractIdleWiresInControlFlow - 0.00691 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: GatesInBasis - 0.02408 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Depth - 0.04935 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: FixedPoint - 0.00525 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: Size - 0.00620 (ms)
INFO:qiskit.passmanager.base_tasks:Pass: FixedPoint - 0.00286 (ms)

opt_out.draw("mpl", idle_wires=False, fold=-1)

4. Vertiefende Beispiele

4.1 Zwei-Qubit-Block-Optimierung mittels Zwei-Qubit-Unitärsynthese

Für die Stufen 2 und 3 gibt es mehr Passes (Collect2qBlocks, ConsolidateBlocks, UnitarySynthesis) für eine tiefergehende Optimierung, nämlich die Zwei-Qubit-Block-Optimierung. (Vergleiche den Optimierungsstufenablauf für Stufe 2 mit dem obigen für Stufe 1)

Die Zwei-Qubit-Block-Optimierung besteht aus zwei Schritten: dem Sammeln und Konsolidieren von 2-Qubit-Blöcken sowie der Synthese der 2-Qubit-Unitärmatrizen.

pm2 = generate_preset_pass_manager(2, backend, seed_transpiler=42)
pm2.optimization.draw()

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import (
    Collect2qBlocks,
    ConsolidateBlocks,
    UnitarySynthesis,
)

# Collect 2q blocks and consolidate to unitary when we expect that we can reduce the 2q gate count for that unitary
consolidate_pm = PassManager(
    [
        Collect2qBlocks(),
        ConsolidateBlocks(target=backend.target),
    ]
)

display(basis_out.draw("mpl", idle_wires=False, fold=-1))

consolidated = consolidate_pm.run(basis_out)
consolidated.draw("mpl", idle_wires=False, fold=-1)

# Synthesize unitaries
UnitarySynthesis(target=backend.target)(consolidated).draw(
    "mpl", idle_wires=False, fold=-1
)

logger.setLevel("WARNING")

Wir haben in Teil 2 gesehen, dass der echte Quantum-Compiler-Ablauf nicht so einfach ist und aus vielen Passes (Aufgaben) besteht. Das liegt hauptsächlich am softwaretechnischen Aufwand, der nötig ist, um eine gute Leistung für ein breites Spektrum von Anwendungs-Circuits und die Wartbarkeit der Software sicherzustellen. Der Qiskit-Transpiler funktioniert in den meisten Fällen gut, aber wenn du feststellst, dass dein Circuit nicht optimal von ihm optimiert wird, wäre es eine gute Gelegenheit, eine anwendungsspezifische Circuit-Optimierung wie in Teil 1 zu entwickeln. Die Transpiler-Technologie entwickelt sich weiter — dein F&E-Beitrag ist willkommen.

from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
sampler = Sampler(backend)

circ = QuantumCircuit(3)
circ.ccx(0, 1, 2)
circ.measure_all()
circ.draw("mpl")

sampler.run([circ])  # IBMInputValueError will be raised

4.2 Circuit-Optimierung ist wichtig

Wir vergleichen zunächst die Ergebnisse des Ausführens von 5-Qubit-GHZ-Zustandspräparations-Circuits ($\frac{1}{\sqrt{2}} \left( |00000\rangle + |11111\rangle \right)$) mit und ohne Optimierung.

from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

service = QiskitRuntimeService()

# backend = service.backend('ibm_brisbane')
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)  # Eagle
backend

Zunächst verwenden wir einen GHZ-Circuit, der naiv wie folgt synthetisiert wird.

num_qubits = 5

ghz_circ = QuantumCircuit(num_qubits)
ghz_circ.h(0)
[ghz_circ.cx(0, i) for i in range(1, num_qubits)]
ghz_circ.measure_all()
ghz_circ.draw("mpl")

Wir transpilieren den Circuit ohne Optimierung (optimization_level=0) und mit Optimierung (optimization_level=2). Wie du sehen kannst, gibt es einen deutlichen Unterschied in der Länge der transpilierten Circuits.

pm0 = generate_preset_pass_manager(
    optimization_level=0, backend=backend, seed_transpiler=777
)
pm2 = generate_preset_pass_manager(
    optimization_level=2, backend=backend, seed_transpiler=777
)
circ0 = pm0.run(ghz_circ)
circ2 = pm2.run(ghz_circ)
print("optimization_level=0:")
display(circ0.draw("mpl", idle_wires=False, fold=-1))
print("optimization_level=2:")
display(circ2.draw("mpl", idle_wires=False, fold=-1))

optimization_level=0:

optimization_level=2:

# run the circuits
sampler = Sampler(backend)
job = sampler.run([circ0, circ2], shots=10000)
job_id = job.job_id()
print(f"Job ID: {job_id}")

Job ID: d13rnnemya70008ek1zg

# REPLACE WITH YOUR OWN JOB IDS
job = service.job(job_id)

# get results
result = job.result()
unoptimized_result = result[0].data.meas.get_counts()
optimized_result = result[1].data.meas.get_counts()

from qiskit.visualization import plot_histogram

# plot
sim_result = {"0" * 5: 0.5, "1" * 5: 0.5}
plot_histogram(
    [result for result in [sim_result, unoptimized_result, optimized_result]],
    bar_labels=False,
    legend=[
        "ideal",
        "no optimization",
        "with optimization",
    ],
)

4.3 Circuit-Synthese ist wichtig

Als Nächstes vergleichen wir die Ergebnisse zweier unterschiedlich synthetisierter 5-Qubit-GHZ-Zustandspräparations-Circuits ($\frac{1}{\sqrt{2}} \left( |00000\rangle + |11111\rangle \right)$).

# Original GHZ circuit (naive synthesis)
ghz_circ.draw("mpl")

# A better GHZ circuit (smarter synthesis), you learned in a previous lecture
ghz_circ2 = QuantumCircuit(5)
ghz_circ2.h(2)
ghz_circ2.cx(2, 1)
ghz_circ2.cx(2, 3)
ghz_circ2.cx(1, 0)
ghz_circ2.cx(3, 4)
ghz_circ2.measure_all()
ghz_circ2.draw("mpl")

circ_org = pm2.run(ghz_circ)
circ_new = pm2.run(ghz_circ2)
print("original synthesis:")
display(circ_org.draw("mpl", idle_wires=False, fold=-1))
print("new synthesis:")
display(circ_new.draw("mpl", idle_wires=False, fold=-1))

original synthesis:

new synthesis:

# run the circuits
sampler = Sampler(backend)
job = sampler.run([circ_org, circ_new], shots=10000)
job_id = job.job_id()
print(f"Job ID: {job_id}")

Job ID: d13rp283grvg008j12fg

# REPLACE WITH YOUR OWN JOB IDS
job = service.job(job_id)

# get results
result = job.result()
synthesis_org_result = result[0].data.meas.get_counts()
synthesis_new_result = result[1].data.meas.get_counts()

# plot
sim_result = {"0" * 5: 0.5, "1" * 5: 0.5}
plot_histogram(
    [result for result in [sim_result, synthesis_org_result, synthesis_new_result]],
    bar_labels=False,
    legend=[
        "ideal",
        "synthesis_org",
        "synthesis_new",
    ],
)

4.4 Allgemeine 1-Qubit-Gate-Zerlegung

from qiskit import QuantumCircuit, transpile
from qiskit.circuit import Parameter
from qiskit.circuit.library.standard_gates import UGate

phi, theta, lam = Parameter("φ"), Parameter("θ"), Parameter("λ")

qc = QuantumCircuit(1)
qc.append(UGate(theta, phi, lam), [0])
qc.draw(output="mpl")

transpile(qc, basis_gates=["rz", "sx"]).draw(output="mpl")

4.5 1-Qubit-Block-Optimierung

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.x(0)
qc.y(0)
qc.z(0)
qc.rx(1.23, 0)
qc.ry(1.23, 0)
qc.rz(1.23, 0)
qc.h(0)
qc.s(0)
qc.t(0)
qc.sx(0)
qc.sdg(0)
qc.tdg(0)
qc.draw(output="mpl")

from qiskit.quantum_info import Operator

Operator(qc)

Operator([[ 0.45292511-0.57266982j, -0.66852684-0.14135058j],
          [ 0.14135058+0.66852684j, -0.57266982+0.45292511j]],
         input_dims=(2,), output_dims=(2,))

from qiskit import transpile

qc_opt = transpile(qc, basis_gates=["rz", "sx"])
qc_opt.draw(output="mpl")

Operator(qc_opt)

Operator([[ 0.45292511-0.57266982j, -0.66852684-0.14135058j],
          [ 0.14135058+0.66852684j, -0.57266982+0.45292511j]],
         input_dims=(2,), output_dims=(2,))

Operator(qc).equiv(Operator(qc_opt))

True

4.6 Toffoli-Zerlegung

qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
qc.draw(output="mpl")

from qiskit import QuantumCircuit, transpile

qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
qc = transpile(qc, basis_gates=["rz", "sx", "cx"])
qc.draw(output="mpl")

4.7 CU-Gate-Zerlegung

from qiskit.circuit.library.standard_gates import CUGate

phi, theta, lam, gamma = Parameter("φ"), Parameter("θ"), Parameter("λ"), Parameter("γ")
qc = QuantumCircuit(2)
# qc.cu(theta, phi, lam, gamma, 0, 1)
qc.append(CUGate(theta, phi, lam, gamma), [0, 1])
qc.draw(output="mpl")

from qiskit.circuit.library.standard_gates import CUGate

phi, theta, lam, gamma = Parameter("φ"), Parameter("θ"), Parameter("λ"), Parameter("γ")
qc = QuantumCircuit(2)
qc.append(CUGate(theta, phi, lam, gamma), [0, 1])
qc = transpile(qc, basis_gates=["rz", "sx", "cx"])
qc.draw(output="mpl")

4.8 CX, ECR, CZ sind bis auf lokale Cliffords äquivalent

Beachte: $H$ (Hadamard), $S$ ($\pi/2$ Z-Rotation), $S^\dagger$ ($-\pi/2$ Z-Rotation) und $X$ (Pauli-X) sind allesamt Clifford-Gates.

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw(output="mpl", style="bw")

qc = QuantumCircuit(2)
qc.cx(0, 1)
transpile(qc, basis_gates=["x", "s", "h", "sdg", "ecr"]).draw(output="mpl", style="bw")

qc = QuantumCircuit(2)
qc.cx(0, 1)
transpile(qc, basis_gates=["h", "cz"]).draw(output="mpl", style="bw")

Verwendung der IBM-Backend-1-Qubit-Basis-Gates „rz", „sx" und „x".

qc = QuantumCircuit(2)
qc.cx(0, 1)
transpile(qc, basis_gates=["rz", "sx", "x", "ecr"]).draw(output="mpl", style="bw")

qc = QuantumCircuit(2)
qc.cx(0, 1)
transpile(qc, basis_gates=["rz", "sx", "x", "cz"]).draw(output="mpl", style="bw")

# Check Qiskit version
import qiskit

qiskit.__version__

'2.0.2'