Suche

Qubits, Quantengatter und Quantenschaltkreise – aus der Informatikperspektive: Teil 2 Quantengatter und Quantenschaltkreise

Coverbild Illustration

Übersicht

Sekundarstufe

Informatik

Quantencomputing

Deutsch

Kontext

Dieses Material ist Teil der dreiteiligen Unterrichtseinheit „Qubits, Quantengatter und Quantenschaltkreise – aus der Informatikperspektive“. Teil 2 führt die Schüler*innen in Quantengatter und Quantenschaltkreise ein und erläutert deren Zweck sowie, wie sie den Zustand eines Qubits manipulieren.

1. Quantengatter und Quantenschaltkreise

Aufgaben für Schüler*innen

Aufgabe 1: Definiere die folgenden Gatter der klassischen Logik: „UND“, „ODER“, „ENTWEDER‑ODER“ und „NICHT“ (auf Englisch: AND, OR, XOR und NOT. Wir werden im Folgenden auch die englischen Bezeichnungen verwenden, da im Quantencomputing auch im Deutschen die englischen Bezeichnungen verwendet werden.). Stelle die entsprechenden Wahrheitstabellen auf. Recherchiere die Ergebnisse von „NICHT (A UND B)“ und „NICHT (A ODER B)“.

Für Aufgabe 1

Das Logikgatter „UND“ hat folgende Wahrheitstabelle:

ABA UND B
FalschFalschFalsch
FalschWahrFalsch
WahrFalschFalsch
WahrWahrWahr

 

Das Logikgatter „ODER“ hat folgende Wahrheitstabelle:

ABA ODER B
FalschFalschFalsch
FalschWahrWahr
WahrFalschWahr
WahrWahrWahr

 

Das Logikgatter „EXKLUSIVES ODER“ hat folgende Wahrheitstabelle:

ABA EXKLUSIVES ODER B
FalschFalschFalsch
FalschWahrWahr
WahrFalschWahr
WahrWahrFalsch

 

Das Logikgatter „NICHT“ hat folgende Wahrheitstabelle:

ANICHT A
FalschWahr
WahrFalsch

Der Ausdruck „NICHT (A UND B)“ ist gleich dem „(NICHT A) ODER (NICHT B)“:

ABA UND BNICHT (A UND B)
FalschFalschFalschWahr
FalschWahrFalschWahr
WahrFalschFalschWahr
WahrWahrWahrFalsch

 

ABNICHT ANICHT B(NICHT A) ODER (NICHT B)
FalschFalschWahrWahrWahr
FalschWahrWahrFalschWahr
WahrFalschFalschWahrWahr
WahrWahrFalschFalschFalsch

 

Der Ausdruck „NICHT (A ODER B)“ ist gleich dem „(NICHT A) UND (NICHT B)“:

ABA ODER BNICHT (A ODER B)
FalschFalschFalschWahr
FalschWahrWahrFalsch
WahrFalschWahrFalsch
WahrWahrWahrFalsch

 

ABNICHT ANICHT B(NICHT A) UND (NICHT B)
FalschFalschWahrWahrWahr
FalschWahrWahrFalschFalsch
WahrFalschFalschWahrFalsch
WahrWahrFalschFalschFalsch

 

Diese beiden Gleichungen heißen de Morgan’sche Gesetze.

Aufgabe 2: Vergleiche den Umgang mit den Logikgattern „UND“ und „ODER“ mit der Multiplikation und Addition von Zahlen.

(Klassische Logikgatter werden in der Unterrichtsstunde Klassische Computer – Einführung in Logikgatter behandelt.)

Für Aufgabe 2
Das Logikgatter „UND“ lässt sich mit der Multiplikation vergleichen, wenn man „Falsch“ mit 0 und „Wahr“ mit 1 identifiziert. Wird auch die Zahl 2 als „Wahr“ interpretiert, so entspricht das Logikgatter „ODER“ der Addition. Betrachtet man hingegen bei der Addition nur das letzte Bit (d. h. die 2 wird als „Falsch“ interpretiert), so entspricht das Logikgatter „EXKLUSIVES ODER“ (XOR) der Addition. Unter dieser Annahme (2 wird als „Falsch“ interpretiert) entspricht das Logikgatter „NICHT“ dem Addieren von 1.

Definitionen

Genauso wie in klassischen Computern klassische Gatter verwendet werden, um elementare Operationen an klassischen Bits durchzuführen, werden in Quantencomputern Quantengatter verwendet, um Qubits zu manipulieren. 
Um ein Programm auf einem Quantencomputer laufen zu lassen, wählt man die passenden elementaren Quantengatter aus und wendet sie auf ein oder mehrere Qubits an. Dies lässt sich in einem Quantenschaltkreis veranschaulichen, der zeigt, wie die verschiedenen Bausteine des Programms – Qubits und Gatter – zusammengesetzt sind.

Definition eines Quantengatters

In Quantencomputern werden Operationen mithilfe von Quantengattern durchgeführt. Quantengatter wirken auf ein oder mehrere Qubits und können durch eine unitäre Matrix dargestellt werden. Werden Qubits mithilfe von Quantengattern manipuliert, entspricht das physikalischen Veränderungen dieser Qubits. Beispiele: Das Qubit geht von einem Basiszustand in den anderen über, oder es wird in eine Superposition der Basiszustände gebracht.

Definition eines Quantenschaltkreises

Ein Quantenschaltkreis ist eine visuelle Darstellung eines Quantenalgorithmus: Man kann damit Rechenvorschriften für einen Quantencomputer darstellen. Ein Quantenschaltkreis besteht aus Qubits und aus Quantengattern, die auf diese Qubits angewandt werden. In einem Quantenschaltkreis fließt die Zeit von links nach rechts. Am Anfang – ganz links – stehen die präparierten Qubits. Die Quantengatter werden dann nacheinander von links nach rechts auf die Qubits angewandt. Auch Messungen und deren Ergebnisse werden in einem Quantenschaltkreis dargestellt. Sie stehen in der Regel ganz rechts, oder auch mal zwischendurch.

Einen Quantenschaltkreis aufbauen

Mit Quantenschaltkreisen kann man einen Quantencomputer programmieren. Die einzelnen Schritte sind:

  1. Präpariere ein oder mehrere Qubits in einem bestimmten Anfangszustand (zum Beispiel |0 ).
  2. Wende ein oder mehrere Quantengatter auf das Qubit (oder die Qubits) an.
  3. Führe eine Messung durch und erhalte ein Ergebnis.

Man kann Quantenschaltkreise in einer grafischen Oberfläche zusammensetzen oder eine Programmiersprache wie zum Beispiel Qiskit verwenden.

Ein Quantenschaltkreis wird in der Regel viele Male ausgeführt, weil Quantencomputer anfällig sind für Rauschen: Auch wenn die Wahrscheinlichkeit für die Messung eines bestimmten Ergebnisses zu 100 % „0“ beträgt, führt das Rauschen dazu, dass das Ergebnis manchmal nicht „0“ ist. Es werden daher viele Durchläufe („Shots“) durchgeführt (z. B. 1000 Shots). Je größer die Anzahl der Durchläufe, desto eindeutiger wird das „richtige“ Ergebnis sichtbar – also zum Beispiel, dass 1 + 1 tatsächlich 2 ergibt.

Quantenschaltkreise können programmiert werden, indem die entsprechenden Quantengatter einfach per Drag-and-Drop in ein dafür vorgesehenes Feld gezogen und dort abgelegt werden.

Im Fall des IBM Quantum Composer werden Gatter aus einer Auswahl oben links in das Arbeitsfeld in der Mitte des Bildschirms gezogen. Die Anzahl der Qubits sowie der klassischen Bits (Register) für den Quantenschaltkreis kann unter <Edit>–<Manage Registers>festgelegt werden. Die Wahrscheinlichkeitsverteilung und der Zustand des Systems werden am unteren Rand des Bildschirms angezeigt, und Exportoptionen – beispielsweise nach Qiskit – stehen auf der rechten Seite zur Verfügung. Sie können Ihren Schaltkreis auf einem echten IBM-Quantencomputer ausführen, wenn Sie über ein Konto verfügen und angemeldet sind. Andernfalls können Sie den integrierten Simulator verwenden, der den Schaltkreis auf einem klassischen Computer ausführt und zeigt, wie sich ein ideales, rauschfreies Quantensystem verhalten würde.

In dieser Einführung in Qiskit finden Sie hier weitere Informationen, einschließlich des Zugangs zu echter Quantenhardware: Quantenschaltkreise programmieren.

Beispiel: Mit dem Pauli‑X‑Gatter die Zustände eines Qubits vertauschen

Das Pauli‑X‑Gatter ändert den Zustand eines Qubits von |0 zu |1 oder von |1 zu |0: Es vertauscht die beiden Zustände des Qubits. Aufgrund seiner Ähnlichkeit mit dem klassischen NOT‑Gatter wird es auch manchmal als NOT‑(Quanten‑)Gatter bezeichnet.

Das Pauli‑X‑Quantengatter kann durch die Matrix X = 01 10 dargestellt werden:

X | 0 = [ 0 1 1 0 ] | 0 = [ 0 1 1 0 ] [ 1 0 ] = [ 0 1 + 1 0 1 1 + 0 0 ] = [ 0 1 ] = | 1  und

X | 1 = [ 0 1 1 0 ] | 1 = [ 0 1 1 0 ] [ 0 1 ] = [ 0 0 + 1 1 1 0 + 0 1 ] = [ 1 0 ] = | 0

Im Folgenden wird dies ganz konkret und Schritt für Schritt anhand des obigen Beispiels (ein Pauli‑X‑Gatter wird auf ein Qubit im Zustand |0 angewendet) beschrieben.

Der Quantenschaltkreis für ein Pauli‑X‑Quantengatter, das auf ein Qubit angewendet wird, sieht wie folgt aus:

Abb. 1: Quantenschaltkreis für ein Pauli‑X‑Gatter, das auf ein Qubit angewendet wird, inklusive anschließender Messung. 

In Abbildung 1 ist q0 das Quantenregister. Man kann sich das so vorstellen: Ein Qubit wird in einem bestimmten Anfangszustand präpariert, sodass ein oder mehrere Quantengatter darauf angewendet werden können. Das „q“ in q0 steht für „Quanten“, und die „0“ bedeutet, dass dies das erste (und in diesem Fall einzige) Qubit ist. Ein zweites Qubit könnte im Register q1 präpariert werden, ein drittes im Register q2 usw. Das blaue Quadrat mit dem „X“ symbolisiert das Pauli‑X‑Gatter. Das graue Quadrat (eine Art „Messgerät“) zeigt an, dass eine Messung durchgeführt wird. Der Pfeil verdeutlicht, dass die Messung am Qubit q0 vorgenommen wird. Die Messung ergibt eine reelle Zahl (in diesem Fall entweder 0 oder 1), daher ist das Register, in dem das Messergebnis gespeichert wird, ein klassisches Register mit der Bezeichnung c0 („c“ steht für „klassisch“, und die „0“ bedeutet, dass es das erste und einzige Register ist, das in diesem Beispiel benötigt wird).

Qiskit verwenden

Anstatt ein Programm visuell mithilfe eines Quantenschaltkreises zusammenzustellen, kann man es auch mit Qiskit schreiben, ein von IBM entwickeltes Open‑Source‑Framework zur Programmierung von Quantencomputern.

# Man braucht ein Quantenregister.
quantum_registers = QuantumRegister(1, 'q')
# Man braucht ein klassisches Register.
classical_registers = ClassicalRegister(1, 'c')
# Beide Register werden in den Quantenschaltkreis eingefügt.
circuit = QuantumCircuit(quantum_registers, classical_registers)
# Das Pauli‑X‑Gatter wird auf das Quantenregister angewandt.
circuit.x(quantum_registers[0])
# Am Quantenregister wird eine Messung durchgeführt; das Ergebnis wird im klassischen Register gespeichert. 
circuit.measure(quantum_registers[0], classical_registers[0])

Diese Code‑Zeilen beschreiben nur den eigentlichen Quantenschaltkreis. Sie müssen noch um folgende Zeilen ergänzt werden und werden an der rot markierten Stelle eingefügt:[1]

# Einen Quantenschaltkreis erzeugen
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
# Den Quantenschaltkreis optimieren
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
# Zugang zu IBM Quantum
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService( channel="ibm_quantum", token="Füge hier deinen API token hinzu, siehe Profile Settings -> API token" ) 
# Wähle den am wenigsten ausgelasteten Quantencomputer als Backend aus. 
backend = service.least_busy(operational=True, simulator=False)
# Erstellt einen Sampler, der mit dem ausgewählten Backend verbunden ist, um das Programm auszuführen. 
sampler = Sampler(backend)
# Erstellt einen Pass‑Manager für die Schaltungsoptimierung für das ausgewählte Backend; Optimierungsstufe 3 (die höchstmögliche Stufe; niedrigere Stufen sind für Menschen leichter verständlich, führen jedoch zu schlechteren Ergebnissen). 
passmanager = generate_preset_pass_manager(3, backend=backend)

# Programmiere an dieser Stelle deinen Quantenschaltkreis.

# Erzeugt den optimierten Quantenschaltkreis
optimized_circuit = passmanager.run(circuit)

# Stellt den Quantenschaltkreis als Auftrag (job) in die Warteschlange (queue) 
job = sampler.run([optimized_circuit], shots=1000)
# Druckt die Job‑ID aus
print("job id:", job.job_id())
# Wartet auf die Ergebnisse; dies kann einige Zeit dauern, aber die Ergebnisse sind auch auf der IBM‑Quantum‑Plattform verfügbar, falls der Job abgebrochen wird 
result = job.result()
print(result[0].data.c.get_counts())

Der obige Code enthält einen sogenannten Transpiler, der den Quantenschaltkreis das Rauschen der den Quantenschaltkreis optimiert. des Schaltkreises und erzielen bessere Ergebnisse.

Für das folgende Ergebnis wurde das oben beschriebene Programm auf einem realen Quantencomputer gerechnet (die y‑Achse zeigt die Anzahl der Shots an):

Dies ist notwendig, da physikalische Quantencomputer nicht immer alle gewünschten Gatter bieten.

Abb. 2: Ein Pauli‑X‑Quantengatter wird auf ein Qubit im Zustand |0 angewendet. Das Ergebnis zeigt, dass sich das Qubit nun in dem anderen Basiszustand befindet, dem Zustand |1. Je höher die Anzahl der Shots (auf der y‑Achse aufgetragen), desto deutlicher sticht das „richtige“ Ergebnis heraus. Je mehr das Rauschen unterdrückt wird, desto kleiner ist der linke Balken in Abb. 2. 

2. Elementare Quantengatter

Das Identitätsgatter

Neben dem Pauli‑X‑Gatter ist das Identitätsgatter ein weiteres elementares und sehr einfaches Quantengatter: Es verändert den Zustand des Qubits nicht.

Die dazugehörende Matrix ist die Identitätsmatrix I = 10 01 :

I |0 = 10 01 |0 = 10 01 1 0 = 11+00 01+10 = 1 0 = |0  und

I |1 = 10 01 |1 = 10 01 0 1 = 10+01 00+11 = 0 1 = |1 .

In Kombination mit anderen Gattern kann das Identitätsgatter – mit anderen Worten: „tue nichts“ – in manchen Fällen nützlich sein. 
Der Quantenschaltkreis eines Identitätsgatters, das auf ein Qubit angewendet wird, sieht folgendermaßen aus:

Abb. 3: In diesem Quantenschaltkreis wird ein Identitätsgatter auf ein Qubit angewendet. Anschließend wird eine Messung durchgeführt. 

quantum_registers = QuantumRegister(1, 'q')
classical_registers = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(quantum_registers, classical_registers)
# Das Identitätsgatter wird auf den Quantenschaltkreis angewandt. 
circuit.id(quantum_registers[0])
# Messung 
circuit.measure(quantum_registers[0], classical_registers[0])

Abb. 4: Das Identitätsgatter wird auf ein Qubit im Zustand | 0 angewendet: Das Qubit bleibt im Zustand | 0

Das Hadamard‑Gatter

Ein besonderes Gatter ist das Hadamard‑Gatter: Es erzeugt aus dem Zustand |0 (oder dem Zustand |1 ) eine Superposition von |0 und |1 , den beiden Basiszuständen eines Qubits:

H | 0 = 1 2 | 0 + 1 2 | 1 = 1 2 [ 1 1 ] .

Das Hadamard‑Gatter wird durch die Matrix H = 1 2 1 1 1 1 dargestellt:

H | 0 = 1 2 [ 1 1 1 1 ] | 0 = 1 2 [ 1 1 1 1 ] [ 1 0 ] = 1 2 [ 1 1 + 1 0 1 1 + ( 1 ) 0 ]

= 1 2 [ 1 1 ] = 1 2 [ 1 0 ] + 1 2 [ 0 1 ] = 1 2 | 0 + 1 2 | 1

und

H | 1 = 1 2 [ 1 1 1 1 ] | 1 = 1 2 [ 1 1 1 1 ] [ 0 1 ] = 1 2 [ 1 0 + 1 1 1 0 + ( 1 ) 1 ]

= 1 2 [ 1 1 ] = 1 2 [ 1 0 ] 1 2 [ 0 1 ] = 1 2 | 0 1 2 | 1 .

Die beiden Amplituden des Superpositionszustands (d. h. die beiden Koeffizienten vor den Basiszuständen) sind in beiden Fällen gleich, 1 2 . Die Quadrate der Amplituden ergeben die Wahrscheinlichkeiten, das Qubit im Zustand |0 bzw. |1 zu finden (siehe Grundlagen der Quantenphysik). Das bedeutet, dass die Wahrscheinlichkeit, das Qubit im Zustand |0 zu finden, gleich [ 1 2 ] 2 = 12 = 50 % ist, und die Wahrscheinlichkeit, das Qubit im Zustand |1 zu finden, ebenfalls [ 1 2 ] 2 = 12 = 50 % beträgt.

Abb. 5: In diesem Quantenschaltkreis wird ein Hadamard‑Gatter auf ein Qubit angewendet. Anschließend wird eine Messung durchgeführt. 

quantum_registers = QuantumRegister(1, 'q')
classical_registers = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(quantum_registers, classical_registers)
# Wende ein Hadamard‑Gatter auf das Qubit im Quantenregister an  
circuit.h(quantum_registers[0])
# Messung 
circuit.measure(quantum_registers[0], classical_registers[0])

Abb. 6: Ein Hadamard‑Gatter wird auf ein Qubit angewendet (im Zustand | 0 oder | 1 , in beiden Fällen wird dasselbe Ergebnis erhalten). In etwa 50 % der Fälle wird das Qubit im Zustand | 0 gemessen, und in 50 % der Fälle im Zustand | 1

  1. Man muss Qiskit in einer Python-3-Umgebung installieren: https://docs.quantum.ibm.com/guides/install-qiskit

  2.  https://quantum.ibm.com/composer/

Close search