Schaltkreisbibliothek

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

  qiskit[all]~=2.5.2
  

Das Qiskit SDK enthält eine Bibliothek beliebter Schaltungen, die Sie als Bausteine für Ihre eigenen Programme verwenden können. Die Verwendung vordefinierter Schaltungen spart Zeit bei der Recherche, beim Schreiben von Code und bei der Fehlersuche. Die Bibliothek enthält populäre Schaltungen für die Quanteninformatik, Schaltungen, die auf klassischem Wege schwer zu simulieren sind, und Schaltungen, die für das Benchmarking von Quantenhardware nützlich sind.

Auf dieser Seite sind die verschiedenen Schaltkreiskategorien aufgeführt, die die Bibliothek anbietet. Eine vollständige Liste der Schaltkreise finden Sie in der API-Dokumentation der Schaltkreisbibliothek.

Standardtore

Die Schaltkreisbibliothek enthält auch Standard-Quantengatter. Einige sind grundlegendere Gatter (wie das UGate), andere sind Multi-Qubit-Gatter, die in der Regel aus Ein- und Zwei-Qubit-Gattern aufgebaut werden müssen. Um Ihrer Schaltung importierte Gatter hinzuzufügen, verwenden Sie die Methode append ; das erste Argument ist das Gatter und das nächste Argument ist eine Liste von Qubits, auf die das Gatter angewendet werden soll.

Die folgende Codezelle erzeugt beispielsweise eine Schaltung mit einem Hadamard-Gatter und einem mehrfach gesteuerten X-Gatter.

from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, MCXGate

mcx_gate = MCXGate(3)
hadamard_gate = HGate()

qc = QuantumCircuit(4)
qc.append(hadamard_gate, [0])
qc.append(mcx_gate, [0, 1, 2, 3])
qc.draw("mpl")

Output:

Siehe Standardgatter in der API-Dokumentation der Schaltkreisbibliothek.

N-lokale Schaltungen

Bei diesen Schaltungen wechseln sich Schichten von Ein-Qubit-Rotationsgattern mit Schichten von Mehr-Qubit-Verschränkungsgattern ab.

Diese Familie von Schaltkreisen ist bei variablen Quantenalgorithmen sehr beliebt, da sie eine breite Palette von Quantenzuständen erzeugen können. Variationsalgorithmen passen die Gatterparameter an, um Zustände zu finden, die bestimmte Eigenschaften aufweisen (z. B. Zustände, die eine gute Lösung für ein Optimierungsproblem darstellen). Zu diesem Zweck sind viele Schaltungen in der Bibliothek parametrisiert, das heißt, Sie können sie ohne feste Werte definieren.

Die folgende Codezelle importiert eine n_local -Schaltung, in der die Verschränkungsgatter Zwei-Qubit-Gatter sind. Diese Schaltung verschachtelt Blöcke von parametrisierten Ein-Qubit-Gattern, gefolgt von verschränkten Blöcken von Zwei-Qubit-Gattern. Der folgende Code erzeugt eine Drei-Qubit-Schaltung mit Ein-Qubit-RX-Toren und Zwei-Qubit-CZ-Toren.

from qiskit.circuit.library import n_local

two_local = n_local(3, "rx", "cz")
two_local.draw("mpl")

Output:

Über das Attribut parameters können Sie ein listenähnliches Objekt mit den Parametern des Stromkreises abrufen.

two_local.parameters

Output:

ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])

Sie können diese Parameter auch mit Hilfe eines Wörterbuchs der Form { Parameter: number } realen Werten zuordnen. Zur Veranschaulichung weist die folgende Codezelle jeden Parameter in der Schaltung 0 zu.

bound_circuit = two_local.assign_parameters(
    {p: 0 for p in two_local.parameters}
)
bound_circuit.decompose().draw("mpl")

Output:

Weitere Informationen finden Sie unter N-lokale Gatter in der API-Dokumentation der Schaltkreisbibliothek oder im Kurs Entwurf von Variationsalgorithmen unter IBM Quantum Learning.

Datenkodierungsschaltungen

Diese parametrisierten Schaltkreise kodieren Daten in Quantenzustände, die von Algorithmen des maschinellen Lernens auf Quantenbasis verarbeitet werden. Einige von Qiskit unterstützte Schaltungen sind:

• Amplitudencodierung, bei der jede Zahl in die Amplitude eines Basiszustands codiert wird. Damit können $2^n$ Zahlen in einem einzigen Zustand gespeichert werden, was jedoch kostspielig sein kann.
• Basiscodierung, die eine ganze Zahl $k$ durch die Vorbereitung des entsprechenden Basiszustands $|k\rangle$ codiert.
• Winkelcodierung, die jede Zahl in den Daten als Drehwinkel in einer parametrisierten Schaltung festlegt.

Welcher Ansatz der beste ist, hängt von den Besonderheiten Ihrer Anwendung ab. Auf aktuellen Quantencomputern werden jedoch häufig winkelcodierende Schaltungen wie die zz_feature_map verwendet.

from qiskit.circuit.library import zz_feature_map

features = [0.2, 0.4, 0.8]
feature_map = zz_feature_map(feature_dimension=len(features))

encoded = feature_map.assign_parameters(features)
encoded.draw("mpl")

Output:

Siehe Datenkodierungsschaltungen in der API-Dokumentation der Schaltkreisbibliothek.

Zeitentwicklungs-Schaltungen

Diese Schaltungen simulieren einen Quantenzustand, der sich in der Zeit entwickelt. Verwenden Sie Zeitentwicklungsschaltungen, um physikalische Effekte wie Wärmeübertragung oder Phasenübergänge in einem System zu untersuchen. Zeit-Evolutions-Schaltkreise sind auch ein grundlegender Baustein für chemische Wellenfunktionen (wie unitäre gekoppelte Cluster-Versuchszustände) und für den QAOA-Algorithmus, den wir für Optimierungsprobleme verwenden.

from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp


# Prepare an initial state with a Hadamard on the middle qubit
state = QuantumCircuit(3)
state.h(1)

hamiltonian = SparsePauliOp(["ZZI", "IZZ"])
evolution = PauliEvolutionGate(hamiltonian, time=1)

# Evolve state by appending the evolution gate
state.compose(evolution, inplace=True)

state.draw("mpl")

Output:

Lesen Sie die PauliEvolutionGate API-Dokumentation.

Benchmarking und Komplexitätstheorie-Schaltungen

Benchmarking-Schaltungen geben uns ein Gefühl dafür, wie gut unsere Hardware tatsächlich funktioniert, und komplexitätstheoretische Schaltungen helfen uns zu verstehen, wie schwierig die Probleme sind, die wir lösen wollen.

Der "Quantenvolumen"-Benchmark beispielsweise misst, wie genau ein Quantencomputer eine Art zufälliger Quantenschaltung ausführt. Die Leistung des Quantencomputers steigt mit der Größe des Schaltkreises, den er zuverlässig ausführen kann. Dabei werden alle Aspekte des Computers berücksichtigt, einschließlich der Anzahl der Qubits, der Anweisungstreue, der Qubit-Konnektivität und der Software, die die Ergebnisse umsetzt und nachbearbeitet. Lesen Sie mehr über Quantenvolumen in der Originalarbeit über Quantenvolumen.

Der folgende Code zeigt ein Beispiel für einen in Qiskit erstellten Quantenvolumenschaltkreis, der mit vier Qubits arbeitet (die Blöcke von unitary sind randomisierte Zwei-Qubit-Gatter).

from qiskit.circuit.library import quantum_volume

quantum_volume(4).draw("mpl")

Output:

Die Schaltkreisbibliothek enthält auch Schaltkreise, die auf klassischem Wege nur schwer zu simulieren sind, wie z. B. instantane Quantenpolynomschaltungen (iqp). Bei diesen Schaltungen werden bestimmte diagonale Gatter (in der Berechnungsgrundlage) zwischen Blöcken von Hadamard-Gattern eingefügt.

Weitere Schaltungen sind grover_operator zur Verwendung im Grover-Algorithmus und die Schaltung fourier_checking für das Fourier-Prüfungsproblem. Siehe diese Schaltungen unter Besondere Quantenschaltungen in der API-Dokumentation der Schaltkreisbibliothek.

Arithmetische Schaltungen

Bei den arithmetischen Operationen handelt es sich um klassische Funktionen wie die Addition ganzer Zahlen und bitweise Operationen. Diese können bei Algorithmen wie der Amplitudenschätzung für Finanzanwendungen und bei Algorithmen wie dem HHL-Algorithmus, der lineare Gleichungssysteme löst, nützlich sein.

Versuchen wir zum Beispiel, zwei Drei-Bit-Zahlen zu addieren, indem wir eine "Ripple-Carry"-Schaltung verwenden, die die Addition an Ort und Stelle durchführt (FullAdderGate). Dieser Addierer addiert zwei Zahlen (wir nennen sie "A" und "B") und schreibt das Ergebnis in das Register, in dem B gespeichert war. Im folgenden Beispiel: A=2 und B=3.

from qiskit.circuit.library import FullAdderGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

adder = FullAdderGate(3)  # Adder of 3-bit numbers

# Create the number A=2
reg_a = QuantumRegister(3, "a")
number_a = QuantumCircuit(reg_a)
number_a.initialize(2)  # Number 2; |010>

# Create the number B=3
reg_b = QuantumRegister(3, "b")
number_b = QuantumCircuit(reg_b)
number_b.initialize(3)  # Number 3; |011>

# Create a circuit to hold everything, including a classical register for
# the result
qregs = [
    QuantumRegister(1, "cin"),
    QuantumRegister(3, "a"),
    QuantumRegister(3, "b"),
    QuantumRegister(1, "cout"),
]
reg_result = ClassicalRegister(3)
circuit = QuantumCircuit(*qregs, reg_result)

# Compose number initializers with the adder. Adder stores the result to
# register B, so we'll measure those qubits.
circuit = (
    circuit.compose(number_a, qubits=reg_a)
    .compose(number_b, qubits=reg_b)
    .compose(adder)
)
circuit.measure(reg_b, reg_result)
circuit.draw("mpl")

Output:

Die Simulation der Schaltung zeigt, dass sie für alle 1024 Schüsse 5 ausgibt (d. h. mit der Wahrscheinlichkeit 1.0 gemessen wird).

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([circuit]).result()

print(f"Count data:\n {result[0].data.c0.get_int_counts()}")

Output:

Count data:
 {5: 1024}

Siehe Arithmetik in der API-Dokumentation der Schaltkreisbibliothek.

Nächste Schritte