Dein erstes Quantenprogramm erstellen und ausführen

Einführung

Im folgenden Video führt dich Olivia Lanes durch die Inhalte dieser Lektion. Alternativ kannst du das YouTube-Video zu dieser Lektion in einem separaten Fenster öffnen.

Willkommen bei Use a quantum computer today! Das Ziel dieses Kurses ist es, dass du in kürzestmöglicher Zeit Code auf einem echten Quantencomputer ausführst – ganz ohne Vorkenntnisse. Lass uns loslegen.

Diese erste Lektion ist eine sanfte, praxisorientierte Einführung in das Quantencomputing, die sich sowohl für neugierige Einsteiger als auch für vielbeschäftigte Führungskräfte eignet. Du lernst etwas über Quantum Circuits und schreibst ein kleines Quantenprogramm, das Verschränkung erzeugt, und führst es auf einem echten IBM® Quantencomputer aus. Du hast auch die Möglichkeit, dasselbe Programm auf einem Simulator auszuführen, falls du das Ausführen auf einem echten Quantencomputer überspringen möchtest.

Du kannst dieses Notebook von oben nach unten in einer neuen Google Colab-Laufzeitumgebung ausführen oder es lokal betreiben.

Einrichtung

Um dieses Notebook in Google Colab auszuführen, benötigst du ein Google-Konto, damit du Notebooks öffnen und Zellen im Browser ausführen kannst.

Um auf einem echten IBM Quantencomputer auszuführen, benötigst du außerdem ein (kostenloses) IBM Quantum® Platform-Konto. Du kannst eine Instanz über den Open Plan öffnen und erhältst 10 Minuten Zeit auf einer Quantum Processor Unit (QPU) in einem rollierenden 28-Tage-Fenster – das ist tatsächlich recht viel! Wenn du Probleme mit deinem Konto hast, schau dir die Support-Seite an.

Du kannst dieses Notebook auch lokal ausführen, nachdem du Qiskit installiert hast. Folge dazu den Anweisungen auf IBM Quantum Platform.

Installation und Importe

In Colab installieren wir Abhängigkeiten innerhalb des Notebooks, damit alle dieselben Tools verwenden. Die nächste Zelle installiert Qiskit mit dem Visualisierungsmodul sowie zwei Add-ons: Aer (schnelle Simulatoren) und den IBM Runtime-Client (für Ausführungen auf dem Quantencomputer).

Als Nächstes haben wir eine Reihe von Importen. Die Klasse QuantumCircuit ist der Ort, an dem wir unsere Quantenbits, also Qubits, definieren und Operationen auf diesen Qubits festlegen. Das ist unser erster Quantenbegriff: Ein Qubit ist der grundlegende Baustein der Quantenberechnung, genauso wie ein Bit der Baustein der klassischen Berechnung ist. Wir werden mehr über die besonderen Eigenschaften von Qubits erfahren, während wir unseren Circuit erstellen. Als Nächstes wird plot_histogram verwendet, um die Ergebnisse unseres Quantum Circuit zu visualisieren. AerSimulator ermöglicht es uns, den Quantum Circuit auf einem klassischen Computer zu simulieren. Simulatoren können Quantum Circuits jedoch nicht in demselben Maßstab ausführen wie echte Quantencomputer; deshalb brauchen wir echte Quantencomputer. Dies kann für Tests, Debugging oder Bildungszwecke hilfreich sein oder wenn du deine 10 kostenlosen QPU-Minuten bereits aufgebraucht hast. Die preset_passmanagers helfen dabei, Circuits zu optimieren, damit sie effizient auf Hardware laufen – das wird wirklich wichtig, wenn unsere Circuits komplexer werden. Sampler und QiskitRuntimeService sind notwendig, um den Circuit tatsächlich auf dem Quantencomputer auszuführen. Mehr dazu später.

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

!pip install 'qiskit[visualization]' qiskit-ibm-runtime qiskit-aer
# Core Qiskit imports
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# IBM Runtime specific imports
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

Als Nächstes führen wir eine kurze Umgebungsprüfung durch. Wir bestätigen die Versionen und überprüfen die Importe.

Wenn hier etwas fehlschlägt, handelt es sich meist um ein Problem bei der Installation von Abhängigkeiten; das jetzt zu beheben verhindert verwirrende Fehler später.

import sys

import qiskit
import qiskit_aer
import qiskit_ibm_runtime

print("Python:", sys.version.split()[0])
print("qiskit:", qiskit.__version__)
print("qiskit-aer:", qiskit_aer.__version__)
print("qiskit-ibm-runtime:", qiskit_ibm_runtime.__version__)

Python: 3.12.2
qiskit: 2.2.3
qiskit-aer: 0.17.2
qiskit-ibm-runtime: 0.41.1

Ein kleiner Abstecher: den Composer verwenden

Bevor wir Code schreiben, ist es hilfreich, Circuits visuell zu sehen. Der IBM Quantum Composer ermöglicht es dir, Circuits zu erstellen, indem du Gates auf Drähte ziehst. Das ist eine großartige Möglichkeit, zu verstehen, was ein Circuit tut, ohne dich von der Syntax ablenken zu lassen.

Öffne den Composer hier.

Sobald er geladen ist, starte das geführte Tutorial über das Menü: Help | Build your first circuit. Arbeite es in deinem eigenen Tempo durch. Achte dabei darauf, wie jedes Gate verändert, was du zu messen erwartest.

Das Tutorial führt dich Schritt für Schritt durch die Erstellung des „Hello World"-Circuits. Er wird in einem sogenannten Circuit-Diagramm visualisiert, bei dem die Qubits durch horizontale Linien dargestellt werden und die auf diese Qubits wirkenden Gates durch Kästchen oder andere Symbole auf den Linien. Dieser Circuit stellt uns einige wichtige Eigenschaften von Qubits und Quantencomputern vor:

Erstens ist das rote Kästchen mit der Bezeichnung „H" ein Hadamard-Gate, das einen Superpositionszustand von Qubit 0 erzeugt. Anders als ein Bit, das sich nur im Zustand 1 oder 0 befinden kann, kann ein Qubit-Zustand beide Möglichkeiten gleichzeitig umfassen, mit bestimmten Gewichtungen (sogenannten Amplituden) für jede. Superposition bedeutet nicht, dass du beide Ergebnisse in einer einzigen Messung siehst; es bedeutet, dass der Zustand so eingerichtet ist, dass bei einer Messung jedes Ergebnis eintreten kann.

Zweitens sind die Kreise und die vertikale Linie, die die beiden Qubits verbindet, ein CNOT-Gate, das Verschränkung zwischen den beiden Qubits erzeugt. Verschränkung ist eine besondere Art von Verbindung zwischen Qubits. Wenn Qubits verschränkt sind, können die Messergebnisse auf eine Weise stark korreliert sein, die nicht dem entspricht, was wir von gewöhnlichen unabhängigen Münzwürfen oder klassischen Korrelationen erwarten würden. Wenn zwei Qubits verschränkt sind, verrät die Messung des einen sofort das Ergebnis der Messung des anderen.

Eine weitere wichtige Idee, die du im Tutorial sehen wirst, sind Shots. Da die Messung der Moment ist, in dem ein Qubit aufhört, sich wie ein Quantenzustand zu verhalten, und dir ein klassisches Ergebnis liefert, kollabiert ein Superpositionszustand bei der Messung probabilistisch entweder zu einer 0 oder einer 1. Um also etwas über diese Superposition zu erfahren, musst du sie viele Male messen, indem du denselben Circuit ausführst, um Statistiken zu sammeln. Diese werden Shots genannt.

Verständnisfragen

Denke über jede Frage nach und klicke dann, um die Antwort anzuzeigen.

Kannst du eine Superposition direkt aus einer einzigen Messung ablesen?

Antwort

Nein. Eine einzelne Messung liefert immer einen klassischen Wert: entweder 0 oder 1. Die „Mischung" zeigt sich erst in der Statistik, die du nach vielen Ausführungen siehst, auch Shots genannt.

Was gibt dir Verschränkung in einfachen Worten?

Antwort

Sie gibt dir verknüpfte Ergebnisse. Die Messung eines Qubits sagt dir etwas über das andere aus. Diese Verknüpfung ist stärker als unabhängige Zufälligkeit und stärker als jede rein klassische Korrelation oder gemeinsame Zufälligkeit erklären kann.

Wenn sich ein Qubit in einer Superposition befindet, was siehst du bei einer einzelnen Messung, und warum brauchst du viele Shots?

Antwort

Bei einer einzelnen Messung siehst du nur ein klassisches Ergebnis: entweder 0 oder 1. Du brauchst viele Shots, weil sich die „Superposition" als Wahrscheinlichkeitsverteilung zeigt, die du nur durch das Sammeln von Statistiken über viele Wiederholungen schätzen kannst.

Schau dir das Messung-Histogramm deines Hello World Circuits im Composer an. Was siehst du? Warum ist das ein Zeichen für Verschränkung?

Antwort

Es zeigt dir eine 50%ige Chance, im Zustand $|00\rangle$ zu sein, und eine 50%ige Chance, im Zustand $|11\rangle$ zu sein. Das bedeutet: Wenn du eine 0 misst, wird die andere auch 0 sein, und wenn du eine 1 misst, wird die andere auch 1 sein. Das ist eine Korrelation zwischen den beiden Qubits, die durch Verschränkung erklärt werden kann.

Ein Quantenprogramm mit Qiskit erstellen und ausführen

Okay, zurück zum Programmieren. Wir werden denselben verschränkten Zustand erzeugen wie im Composer (den $\Phi^+$ (Phi-plus) Bell-Zustand), aber diesmal schreiben wir den Code von Hand. Wir müssen diese Fähigkeit aufbauen, denn wenn wir auf mehr Qubits und komplexere Circuits skalieren, kann uns der Composer nicht mehr helfen.

Um den Bell-Zustand-Circuit zu erstellen, verwenden wir ein $H$ (Hadamard)-Gate, um das erste Qubit in eine gleiche Superposition zu versetzen. Dann wenden wir ein $CX$ (Controlled-NOT)-Gate an, das die beiden Zustände miteinander verschränkt. Die beiden Qubits sind nun auf eine Weise korreliert, die kein klassisches Äquivalent hat.

# --- Build the Bell circuit (phi-plus) ---
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()  # creates a classical register named "meas"

bell.draw("mpl")

Hilfsfunktion zum Ausführen von Circuits

Lass uns jetzt eine Hilfsfunktion definieren, die den Prozess der Ausführung eines Quantum Circuit und der Abfrage der Messergebnisse übernimmt. Diese Funktion kümmert sich um das Transpilieren des Circuit, damit er zum Instruction Set des Backends passt, führt ihn über ein Sampler-Primitive aus und extrahiert die Counts aus den Ergebnissen.

def run_circuit_and_get_counts(circuit, backend, shots=1000):
    """
    Runs a quantum circuit on a specified backend and returns the measurement counts.

    Args:
        circuit (QuantumCircuit): The quantum circuit to run.
        backend: The Qiskit backend (real device or simulator).
        shots (int): The number of shots to run the circuit.

    Returns:
        dict: A dictionary of measurement counts.
    """
    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
    isa_circuit = pm.run(circuit)

    sampler = Sampler(mode=backend)

    job = sampler.run([isa_circuit], shots=shots)
    result = job.result()

    return result[0].data.meas.get_counts()

Auf einer QPU ausführen und Ergebnisse visualisieren

Abschließend führen wir den Circuit auf einer IBM Quantum Processing Unit (QPU) in der Cloud für 1000 Shots aus und stellen die Ergebnisse grafisch dar. IBM QPUs sind physikalische Systeme, die Rauschen aufnehmen können, sodass Gates leicht unvollkommen sind, Messungen manchmal falsch sein können und die Gerätekalibrierung im Laufe der Zeit driftet.

Das Ausführen auf echten Quantencomputern bringt auch praktische Überlegungen mit sich. Jobs können in einer Warteschlange stehen, weil viele Personen möglicherweise dasselbe Gerät nutzen. Du musst auch eine Shot-Anzahl wählen, die statistische Überlegungen (mehr Shots bedeuten ein höheres Signal-Rausch-Verhältnis) mit Zeit- und Kostenbeschränkungen in Einklang bringt.

Befolge die Anweisungen in den Code-Kommentaren der nächsten Zelle. Nach dem Ausführen der Zelle solltest du ein Histogramm mit ungefähr gleichen Counts für die Bitstrings $00$ und $11$ sehen, mit einigen Vorkommnissen von $01$ oder $10$ aufgrund von Rauschen. Die folgende Zelle in diesem Notebook führt denselben Circuit auf einem Simulator aus, falls du das Ausführen auf einer QPU überspringen möchtest.

# Syntax for first saving your token.  Delete these lines after saving your credentials.
QiskitRuntimeService.save_account(
    channel="ibm_quantum_platform",
    token="YOUR_TOKEN_HERE",
    overwrite=True,
    set_as_default=True,
)
service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_fez".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_fez")
print(backend.name)

ibm_pittsburgh

counts = run_circuit_and_get_counts(bell, backend, shots=1000)
plot_histogram(counts)

Auf einem Simulator ausführen und Ergebnisse visualisieren

Ein Simulator ist eine „perfekte Welt"-Version des Quantencomputings. Hier führen wir den Circuit auf einem Simulator für 1000 Shots aus und stellen die Ergebnisse grafisch dar. Du solltest ungefähr gleiche Counts für die Zustände $00$ und $11$ sehen, ohne Vorkommnisse von $01$ oder $10$ – das ist das Merkmal der perfekten Korrelation des Bell-Zustands.

backend = AerSimulator()
counts = run_circuit_and_get_counts(bell, backend, shots=1000)

plot_histogram(counts)

Verständnisfragen

Welche zwei Gates erzeugen hier den Bell-Zustand?

Antwort

Ein H-Gate auf Qubit 0, gefolgt von einem CX-Gate mit Qubit 0 als Kontroll-Qubit und Qubit 1 als Ziel-Qubit.

Welche zwei Bitstrings sollten das Histogramm auf einem idealen Simulator dominieren?

Antwort

00 und 11 sollten dominieren.

Warum hätte ein perfekter Simulator nicht immer genau gleich viele 00-Counts wie 11-Counts?

Antwort

Obwohl ein Simulator „perfekt" ist und zu einem perfekten Bell-Zustand führt, simuliert er dennoch einen inhärent zufälligen Prozess, sodass statistische Schwankungen weiterhin auftreten. Es ist wie 1000 Mal eine Münze zu werfen: Selbst wenn die Chance genau 50-50 steht, bedeutet das nicht, dass du immer genau 500 Mal Kopf und 500 Mal Zahl bekommst.

Warum könnte ein echter Quantencomputer einige 01- oder 10-Ergebnisse zeigen, obwohl der Simulator das nicht tat?

Antwort

Weil echte Geräte Rauschen haben. Gates und Messungen sind nicht perfekt, und das kann gelegentliche Fehler einführen.

Was ist ein praktischer Unterschied zwischen Simulatoren und echten Quantencomputern abgesehen vom Rauschen?

Antwort

Quantencomputer können Wartezeiten in der Warteschlange, begrenzte Verfügbarkeit und gerätespezifische Einschränkungen mit sich bringen, die beeinflussen, wie Circuits ausgeführt werden.

Fazit

Wir haben begonnen, indem wir Qiskit in einer neuen Colab-Umgebung eingerichtet haben – genau so, wie viele reale Notebook-Workflows beginnen. Darauf folgte eine Reise ins Quantencomputing mit dem Composer. Anschließend haben wir einen einfachen Zwei-Qubit-Circuit erstellt, der den $\Phi^+$ Bell-Zustand erzeugt, wiederholtes Sampling verwendet und die Verschränkung als Korrelation im Qubit-Messung-Histogramm visualisiert. Wir haben auch gesehen, wie echte Quantencomputer Rauschen und Fehler einführen.

Lernziel

Jetzt, da wir durchgegangen sind, wie man den $\Phi^+$ Bell-Zustand erzeugt, schau, ob du den Code anpassen kannst, um einen der drei anderen Bell-Zustände zu erzeugen. Insbesondere der $\Psi^-$ Zustand wird in einer kommenden Lektion verwendet, also wirst du einen Vorsprung haben, wenn du herausfindest, wie man ihn erstellt.