IBM on kenji.blog

Der ultimative Einstieg in die Quantenprogrammierung mit Qiskit

Fri, 11 Sep 2026 20:00:00 +0900

1. Einführung

Moderne Computer (klassische Computer) haben unser Leben dramatisch verändert und unterstützen mit ihrer hohen Rechenleistung alle Aspekte der Gesellschaft. Es ist jedoch bekannt, dass für bestimmte, spezifische Probleme (z.B. die Primfaktorzerlegung riesiger Zahlen, die Simulation komplexer Molekularstrukturen, Optimierungsprobleme etc.) selbst die modernsten Supercomputer unserer Zeit mehr Zeit benötigen würden, als das Universum alt ist.

Der Quantencomputer (Quantum Computer) birgt das Potenzial, diese „Grenzen klassischer Computer“ zu durchbrechen. Man geht davon aus, dass er durch die Nutzung der faszinierenden Eigenschaften der Quantenmechanik (Superposition und Quantenverschränkung) als Rechenressource in der Lage ist, bestimmte Probleme drastisch zu beschleunigen.

In diesem Artikel machen wir die ersten Schritte in die Welt der Quantenprogrammierung, indem wir das von IBM als Open Source bereitgestellte Quantencomputing-Framework Qiskit verwenden. Dies ist ein sehr detaillierter Einstiegsguide, der von den physikalischen und mathematischen Grundlagen über das Schreiben von Code in Python bis hin zur Ausführung von Quantenschaltungen auf einem Simulator alles sorgfältig erklärt.

2. Physikalische und mathematische Grundlagen des Quantenrechnens

Um die Quantenprogrammierung zu verstehen, müssen Sie zunächst die grundlegenden Konzepte der Quantenmechanik begreifen. Hier erklären wir die drei wichtigen Säulen: Quantenbits, Superposition und Quantenverschränkung.

2.1 Das klassische Bit und das Quantenbit (Qubit)

Die Informationseinheit klassischer Computer ist das „Bit“. Ein Bit nimmt immer genau einen von zwei Zuständen ein: entweder 0 oder 1.

Andererseits wird die kleinste Informationseinheit eines Quantencomputers als Quantenbit (Qubit: Quantum bit) bezeichnet. Ein Qubit kann nicht nur die Zustände 0 und 1 annehmen, sondern ist auch in der Lage, beide Zustände gleichzeitig beizubehalten.

Mathematisch wird der Zustand eines Qubits $|\psi\rangle$ als Linearkombination (Superposition) der Basiszustände $|0\rangle$ und $|1\rangle$ ausgedrückt.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Hierbei sind $\alpha$ und $\beta$ komplexe Zahlen, die die Wahrscheinlichkeitsamplituden dafür darstellen, dass die Zustände $|0\rangle$ bzw. $|1\rangle$ beobachtet werden. Basierend auf den Grundprinzipien der Quantenmechanik muss die Summe der Wahrscheinlichkeiten 1 ergeben, weshalb die folgende Normierungsbedingung erfüllt sein muss:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Das bedeutet, wenn wir dieses Qubit „messen (beobachten)“, ist die Wahrscheinlichkeit, $|0\rangle$ zu erhalten, $|\alpha|^2$, und die Wahrscheinlichkeit, $|1\rangle$ zu erhalten, $|\beta|^2$. Der entscheidende Unterschied zum klassischen Bit besteht darin, dass der Zustand vor der Messung nur probabilistisch bestimmt ist.

graph LR A["Klassisches Bit (Classical Bit)"] --> B["Bestimmter Zustand: 0 oder 1"] C["Quantenbit (Qubit)"] --> D["Superposition: Sowohl 0 als auch 1"] D --> E["Zustand wird durch Messung probabilistisch bestimmt"]

2.2 Superposition (Überlagerung)

Wie bereits erwähnt, wird der Zustand, in dem die Zustände $|0\rangle$ und $|1\rangle$ vermischt sind, als Superposition bezeichnet.

Wenn sich beispielsweise ein einzelnes Qubit in einem Zustand der vollkommen gleichmäßigen Superposition befindet, gilt $\alpha = \frac{1}{\sqrt{2}}$ und $\beta = \frac{1}{\sqrt{2}}$.

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

Wenn dieser Zustand gemessen wird, werden $|0\rangle$ und $|1\rangle$ jeweils mit einer Wahrscheinlichkeit von 50% beobachtet. Wenn zwei Qubits vorhanden sind, können wir eine Superposition der vier Zustände $|00\rangle, |01\rangle, |10\rangle, |11\rangle$ erstellen. Mit $n$ Qubits können wir $2^n$ Zustände gleichzeitig repräsentieren, was eine der Hauptquellen für die parallele Verarbeitungsfähigkeit von Quantencomputern darstellt.

2.3 Quantenverschränkung (Entanglement)

Die stärkste und mysteriöseste Eigenschaft im Quantencomputing ist die Quantenverschränkung (Entanglement). Dieses Phänomen, das Einstein als “spukhafte Fernwirkung” bezeichnete, beschreibt die Eigenschaft, dass zwei oder mehr Qubits so stark miteinander verbunden sind, dass die Bestimmung des Zustands des einen Qubits sofort auch den Zustand des anderen bestimmt, ganz gleich, wie weit sie physisch voneinander entfernt sind.

Einer der bekanntesten verschränkten Quantenzustände, der „Bell-Zustand (Bell State)“, der $\Phi^+$-Zustand, wird wie folgt ausgedrückt:

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

In diesem Zustand existieren die Zustände $|01\rangle$ und $|10\rangle$ nicht. Wenn wir also das erste Qubit messen und es sich im Zustand $|0\rangle$ befindet, ist es sicher, dass das zweite Qubit sich ebenfalls im Zustand $|0\rangle$ befindet, noch bevor wir es gemessen haben. Umgekehrt, wenn das erste Qubit $|1\rangle$ ist, wird das zweite definitiv auch $|1\rangle$ sein.

3. Quantenlogikgatter (Quantum Logic Gates)

So wie klassische Computer Logikgatter wie AND, OR und NOT verwenden, um Berechnungen durchzuführen, verwenden Quantencomputer Quantengatter, um den Zustand von Qubits zu manipulieren. Da ein Quantenzustand ein Vektor ist, wird ein Quantengatter als “unitäre Matrix” ausgedrückt, die auf diesen Vektor wirkt.

3.1 Pauli-Gatter (Pauli-X, Y, Z)

Pauli-Gatter sind grundlegende Operationen für ein einzelnes Qubit.

・Pauli-X Gatter (NOT-Gatter) Es entspricht dem klassischen NOT-Gatter. Es invertiert $|0\rangle$ zu $|1\rangle$ und $|1\rangle$ zu $|0\rangle$. (Eine 180-Grad-Drehung um die X-Achse auf der Bloch-Kugel)

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

・Pauli-Y Gatter Führt eine 180-Grad-Drehung um die Y-Achse aus. Es hat den Effekt, sowohl die Phase als auch das Bit zu invertieren.

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Pauli-Z Gatter (Phaseninversionsgatter) Es belässt den Zustand von $|0\rangle$ unverändert und invertiert die Phase (multipliziert mit $-1$) des Zustands $|1\rangle$. (Eine 180-Grad-Drehung um die Z-Achse)

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

3.2 Hadamard-Gatter (Hadamard Gate)

Das Hadamard-Gatter (H-Gatter) ist ein sehr wichtiges Gatter, das einen bestimmten Zustand ($|0\rangle$ oder $|1\rangle$) in einen Superpositionszustand überführt.

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

Die Anwendung des H-Gatters auf $|0\rangle$ führt zu $|+\rangle$, was einem gleichmäßigen Superpositionszustand entspricht.

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 Phasengatter (Phase Gates)

Phasengatter sind eine Verallgemeinerung des Z-Gatters; sie rotieren die Phase des Zustands $|1\rangle$ um einen angegebenen Winkel $\theta$.

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

Typische Beispiele sind das S-Gatter ($\theta = \pi/2$) und das T-Gatter ($\theta = \pi/4$).

3.4 CNOT-Gatter (Controlled-NOT Gate)

Das CNOT-Gatter (CX-Gatter) führt Operationen zwischen zwei Qubits durch und ist unerlässlich für die Erzeugung von Quantenverschränkung. Es besteht aus einem “Kontroll-Bit (Control)” und einem “Ziel-Bit (Target)”.

Nur wenn das Kontrollbit $|1\rangle$ ist, wird das X-Gatter (NOT-Operation) auf das Zielbit angewendet; wenn das Kontrollbit $|0\rangle$ ist, passiert nichts.

$$ CNOT = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

4. Grundlagen und Umgebungseinrichtung von Qiskit

Von hier an werden wir Quantenprogramme mithilfe von Python und Qiskit schreiben.

4.1 Was ist Qiskit?

Qiskit ist ein Open-Source Software Development Kit (SDK) für Quantencomputing, das von IBM Quantum entwickelt wurde. Es ermöglicht die intuitive Erstellung von Quantenschaltungen in Python und deren Ausführung auf lokalen Simulatoren oder über die Cloud auf echten Quantencomputern von IBM.

4.2 Installationsmethode

Um Qiskit zu verwenden, ist eine Python-Umgebung erforderlich. Installieren Sie Qiskit und die zugehörigen Pakete (Simulator und Zeichnungsbibliotheken) mit dem folgenden Befehl:

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 Grundlegender Ablauf der Programmierung

Die Quantenprogrammierung mit Qiskit erfolgt hauptsächlich in den folgenden Schritten:

graph TD A["1. Schaltungsaufbau (Build)"] --> B["2. Kompilieren/Transpilieren (Compile)"] B --> C["3. Ausführung (Execute)"] C --> D["4. Analyse und Visualisierung der Ergebnisse (Analyze)"]

Schaltungsaufbau: Erstellen eines QuantumCircuit-Objekts und Hinzufügen von Gattern.
Kompilieren: Optimierung der Schaltung für das ausführende Backend (echte Maschine oder Simulator).
Ausführung: Senden von Jobs an das Backend und Abrufen der Ergebnisse.
Analyse: Zeichnen von Histogrammen der Messergebnisse usw.

5. Praxis: Aufbau einer Schaltung zur Erzeugung eines Bell-Zustands (Quantenverschränkung)

Lassen Sie uns die “Quantenverschränkung (den Bell-Zustand)”, die wir in der Theorie gelernt haben, nun tatsächlich mit Qiskit erzeugen. Unser Zielzustand ist $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$.

5.1 Schaltungsentwurf

Um einen Bell-Zustand zu erzeugen, gehen wir wie folgt vor:

Bereiten Sie zwei Qubits vor (beide haben als Anfangszustand $|0\rangle$).
Wenden Sie das Hadamard-Gatter (H) auf das erste Qubit an, um es in einen Superpositionszustand zu versetzen.
Wenden Sie das CNOT-Gatter an, wobei das erste Qubit das “Kontrollbit” und das zweite das “Zielbit” ist.
Führen Sie eine Messung (Measure) durch, um die Ergebnisse auszulesen.

5.2 Python/Qiskit Code-Implementierung

Schauen wir uns nun den tatsächlichen Code an.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. Initialisierung der Schaltung
# Erstellen einer Quantenschaltung mit 2 Quantenbits und 2 klassischen Bits
qc = QuantumCircuit(2, 2)

# 2. Anwendung des H-Gates
# Hadamard-Gate auf das Quantenbit 0 (q0) anwenden
qc.h(0)

# 3. Anwendung des CNOT-Gates
# CNOT anwenden mit q0 als Steuerbit und q1 als Zielbit
qc.cx(0, 1)

# 4. Messung
# Quantenbits 0 und 1 messen und in die klassischen Bits 0 und 1 schreiben
qc.measure([0, 1], [0, 1])

# Schaltungsdiagramm zeichnen (mit matplotlib)
# qc.draw('mpl')
print(qc.draw())

Wenn Sie diesen Code ausführen, wird in der Konsole als ASCII-Art das folgende Quantenschaltungsdiagramm angezeigt:

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H stellt das Hadamard-Gatter dar, die Kombination aus ■ und X ist das CNOT-Gatter, und M repräsentiert die Messung.

5.3 Ausführung auf dem Simulator und Interpretation der Ergebnisse

Als Nächstes führen wir diese Schaltung auf IBMs Hochleistungs-Simulator Aer aus und überprüfen die Ergebnisse.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Das Backend des Aer-Simulators abrufen
simulator = Aer.get_backend('qasm_simulator')

# Schaltung für den Simulator transpilieren (optimieren)
compiled_circuit = transpile(qc, simulator)

# Schaltung ausführen (hier 1000 Shots ausführen)
job = simulator.run(compiled_circuit, shots=1000)

# Ergebnisse abrufen
result = job.result()

# Anzahl der Beobachtungen der Zustände (Counts) abrufen
counts = result.get_counts(compiled_circuit)
print("\nMessergebnis:", counts)

# Histogramm plotten
# plot_histogram(counts)
# plt.show()

Interpretation der Ergebnisse

Die Konsolenausgabe sollte in etwa wie folgt aussehen: Messergebnis: {'00': 495, '11': 505} (*Da die Wahrscheinlichkeiten zufällig sind, schwanken die genauen Werte bei jeder Ausführung leicht)

In einer idealen Simulationsumgebung werden als Messergebnisse zu etwa 50% 00 und zu 50% 11 beobachtet, und 01 oder 10 werden gar nicht beobachtet. Dies stimmt exakt mit der theoretischen Vorhersage unseres generierten Bell-Zustands $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ überein. Wenn das erste Qubit 0 ist, ist das zweite notwendigerweise 0; wenn es 1 ist, ist das zweite notwendigerweise 1. Diese „Quantenverschränkung“ wurde somit exakt simuliert.

Wenn Sie dies jedoch auf einer echten Quantencomputer-Hardware (IBM Quantum Hardware) ausführen, können aufgrund der Auswirkungen von Rauschen (Quantendekohärenz und Gatterfehler) geringfügig Zustände wie 01 und 10 beobachtet werden. Wie dieses Rauschen minimiert werden kann (Quantenfehlerkorrektur), ist eine der größten Herausforderungen in der aktuellen Entwicklung von Quantencomputern.

6. Hochskalierung zu fortgeschritteneren Algorithmen

Die Erzeugung eines Bell-Zustands kann man als das „Hello World“ der Quantenprogrammierung bezeichnen. Indem wir darauf aufbauen, können wir leistungsstarke Algorithmen konstruieren, die klassische Computer übertreffen.

6.1 Der Deutsch-Jozsa-Algorithmus (Deutsch-Jozsa Algorithm)

Bei diesem Problem geht es darum zu bestimmen, ob eine gegebene Funktion $f(x)$ eine „konstante Funktion“ (sie gibt immer 0 oder immer 1 aus, unabhängig von der Eingabe) oder eine „balancierte Funktion“ (sie gibt für die Hälfte der Eingaben 0 und für die andere Hälfte 1 aus) ist. Ein klassischer Computer würde im ungünstigsten Fall $2^{n-1} + 1$ Funktionsauswertungen erfordern, aber der Deutsch-Jozsa-Algorithmus kann mithilfe der Quantenparallelität diese Bestimmung mit nur einer einzigen Auswertung vornehmen. Dies veranschaulicht das Grundmuster von Quantenalgorithmen: Einen Superpositionszustand als Eingabe bereitzustellen und Interferenz (Interference) zu nutzen, um unerwünschte Zustände auszulöschen und die gewünschte Antwort zu verstärken.

6.2 Der Grover-Algorithmus (Grover’s Algorithm)

Bei Suchproblemen, in denen eine unsortierte Datenbank mit $N$ Elementen nach spezifischen Daten durchsucht wird, benötigt ein klassischer Algorithmus im Durchschnitt $N/2$ Rechenschritte. Der Grover-Algorithmus hingegen kann die Zieldaten in nur $\sqrt{N}$ Schritten finden. Dieser Algorithmus verwendet eine Blackbox, die als „Orakel (Oracle)“ bezeichnet wird, um die Phase der Ziellösung zu invertieren, und führt dann eine „Amplitudenverstärkung (Amplitude Amplification)“ durch, um die Wahrscheinlichkeit drastisch zu erhöhen, dass die Ziellösung gemessen wird.

graph TD A["Initialisierung (Superposition aller Zustände)"] --> B["Orakel (Invertiert die Phase der richtigen Lösung)"] B --> C["Diffusionsoperator (Amplitudenverstärkung durch Inversion um den Mittelwert)"] C --> D{"Ausreichende Wahrscheinlichkeit erreicht?"} D -- "No" --> B D -- "Yes" --> E["Messung"]

7. Zusammenfassung und zukünftiges Lernen

In diesem Artikel haben wir detailliert die Reise erläutert – angefangen bei den grundlegenden Konzepten des Quantencomputings wie Superposition und Quantenverschränkung, über die Manipulation von Quantenlogikgattern mittels Qiskit, bis hin zum tatsächlichen Aufbau, zur Simulation eines Bell-Zustands und der Interpretation der Ergebnisse.

Da Qiskit in der zugänglichen Programmiersprache Python geschrieben werden kann, ist es ein leistungsstarkes Werkzeug, das es Ihnen ermöglicht, mathematische und physikalische Barrieren zu überwinden und sich auf die Konstruktion von Algorithmen zu konzentrieren. Quantencomputer befinden sich derzeit in der Ära rauschanfälliger Quantengeräte mittlerer Größe (NISQ: Noisy Intermediate-Scale Quantum), aber angewandte Forschungen in vielen Bereichen wie maschinelles Quantenlernen (Quantum Machine Learning), chemische Simulationen (Quantum Chemistry) und Kryptanalyse schreiten weltweit rasant voran.

Nutzen Sie diese Gelegenheit, um verschiedene Quantenschaltungen mit Qiskit selbst zu erstellen und auf realen IBM Quantum-Prozessoren auszuführen. Sie sollten in der Lage sein, das Computer-Paradigma der Zukunft aus erster Hand zu erleben.

Referenzen

Offizielle Qiskit-Dokumentation
Qiskit Textbook - Das empfohlene offizielle Lehrbuch für alle, die tiefer in die mathematischen Hintergründe und Algorithmen eintauchen möchten
IBM Quantum Learning

Willkommen in der Quantenwelt!

Was ist Quantenüberlegenheit? Neueste Trends von Google und IBM

Fri, 11 Sep 2026 18:00:00 +0900

1. Einleitung: Die Morgendämmerung des Quantencomputings und die “Quantenüberlegenheit”

Quantencomputing birgt das Potenzial, komplexe Probleme in realistischer Zeit zu lösen, die für klassische Computer (die PCs und Supercomputer, die wir derzeit täglich nutzen) unlösbar sind, indem es die Quantenmechanik, ein Grundprinzip der Physik, auf die Informationsverarbeitung anwendet. Dieses Feld wurde lange Zeit hauptsächlich theoretisch erforscht, aber in den letzten Jahren hat sich der Wettbewerb um die praktische Anwendung durch rasante Fortschritte bei der Hardware intensiviert.

Eines der Schlüsselworte, das dabei die meiste Aufmerksamkeit erregt hat, ist “Quantenüberlegenheit” (Quantum Supremacy). Dies bezeichnet den Moment, in dem ein Quantencomputer bei einer bestimmten Berechnungsaufgabe eine Rechenleistung zeigt, die die eines klassischen Computers überwältigt. Dieser Artikel beginnt mit der genauen Definition der Quantenüberlegenheit, erläutert die Details des Experiments von Googles “Sycamore”-Prozessor, der 2019 bekannt gab, als Erster weltweit diesen Meilenstein erreicht zu haben, die Gegenargumente und den eigenen Ansatz von IBM daraufhin und geht schließlich technisch und mathematisch auf die “Quantenfehlerkorrektur” (Quantum Error Correction: QEC) und das “fehlertolerante Quantencomputing” (Fault-Tolerant Quantum Computing: FTQC) ein, welche die größten Hürden für eine echte praktische Anwendung darstellen.

2. Theoretischer Hintergrund: Grundlagen der Quantenberechnung und Komplexitätsklassen

Um die Quantenüberlegenheit zu verstehen, muss man zunächst die mathematischen Grundlagen der Quantenberechnung und ihre Stellung in der rechnerischen Komplexitätstheorie verstehen.

Qubits und Superposition

Während die kleinste Informationseinheit in einem klassischen Computer das Bit (0 oder 1) ist, verwenden Quantencomputer Quantenbits (Qubits). Der Zustand $|\psi\rangle$ eines Qubits wird als komplexe Linearkombination der Basiszustände $|0\rangle$ und $|1\rangle$ dargestellt.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Hierbei sind $\alpha, \beta \in \mathbb{C}$ und erfüllen die Normierungsbedingung $|\alpha|^2 + |\beta|^2 = 1$. Diese Eigenschaft wird als “Superposition” (Überlagerung) bezeichnet.

Verschränkung (Entanglement) und Tensorprodukt

Wenn mehrere Qubits vorhanden sind, wird der Zustand des gesamten Systems durch das Tensorprodukt der Zustandsräume der einzelnen Qubits dargestellt. Ein System aus $n$ Qubits ist ein Vektor im $2^n$-dimensionalen Hilbertraum $\mathcal{H}^{\otimes n}$.

$$ |\Psi\rangle = \sum_{x \in \{0, 1\}^n} c_x |x\rangle $$

Hierbei ist $\sum |c_x|^2 = 1$. Der Zustand, in dem Qubits nicht unabhängig sind, sondern der Zustand des einen von dem des anderen abhängt, wird als “Quantenverschränkung” (Quantum Entanglement) bezeichnet. Dadurch hat ein Quantencomputer das Potenzial, einen exponentiell großen Zustandsraum gleichzeitig zu verarbeiten.

Komplexitätstheoretische Definition der Quantenüberlegenheit

In der rechnerischen Komplexitätstheorie wird die Klasse der Probleme, die von einem klassischen Computer effizient (in polynomieller Zeit) gelöst werden können, als BPP (Bounded-error Probabilistic Polynomial time) bezeichnet. Andererseits ist die Klasse der Probleme, die von einem Quantencomputer effizient gelöst werden können, BQP (Bounded-error Quantum Polynomial time).

Der Nachweis der Quantenüberlegenheit bedeutet, “eine spezifische Aufgabe, die in BQP, aber nicht in BPP enthalten ist (oder bei der die Wahrscheinlichkeit dafür extrem hoch ist), auf tatsächlicher Quantenhardware auszuführen und klassische Supercomputer in Bezug auf Zeit und Ressourcen bei der Simulation zu übertreffen”. Man kann dies als historischen Versuch bezeichnen, die erweiterte Church-Turing-These (“Jedes physikalisch realisierbare Berechnungsmodell kann durch eine probabilistische Turingmaschine in polynomieller Zeit simuliert werden”) durch physikalische Experimente zu widerlegen.

3. 2019: Demonstration der Quantenüberlegenheit durch Google

Im Oktober 2019 gab das Google Quantum AI-Team in der Fachzeitschrift “Nature” bekannt, dass sie mit dem 53-Qubit-Supraleiter-Prozessor “Sycamore” die Quantenüberlegenheit erreicht hätten.

Architektur des Sycamore-Prozessors

Der Sycamore-Prozessor besteht aus 54 supraleitenden Transmon-Qubits, die in einem zweidimensionalen Gitter angeordnet sind (im Experiment wurden 53 verwendet, da eines defekt war). Zwischen benachbarten Qubits sind variable Koppler (Tunable Couplers) angeordnet, um schnelle und hochpräzise 2-Qubit-Gatter (einen Hybrid aus iSWAP-Gatter und kontrolliertem Z-Gatter) zu realisieren.

graph TD A["Quantenalgorithmus-Eingabe"] --> B["Sycamore-Prozessor (53 Qubits)"] B --> C["Zufällige Quantengatter anwenden"] C --> D["Quantenzustände messen (Bitstrings)"] D --> E["Kreuzentropie-Benchmarking (XEB)"] E --> F["Quantenüberlegenheit verifizieren"]

Zufälliges Quantenschaltkreis-Sampling (Random Circuit Sampling: RCS)

Die von Google gewählte Aufgabe war das “zufällige Quantenschaltkreis-Sampling”. Dabei werden zufällig ausgewählte 1-Qubit-Gatter und 2-Qubit-Gatter über mehrere Zyklen (Tiefe $m$) angewendet, der Endzustand wird gemessen, und aus der resultierenden Wahrscheinlichkeitsverteilung der Bitstrings wird ein Sampling durchgeführt.

Die Wahrscheinlichkeit eines Bitstrings $x$, der von einem idealen (rauschfreien) zufälligen Quantenschaltkreis ausgegeben wird, ist keine Gleichverteilung, sondern zeigt ein Interferenzmuster-ähnliches Muster, das als Porter-Thomas-Verteilung bezeichnet wird. Um aus dieser Verteilung mit einem klassischen Computer abzutasten, ist eine Simulation des gesamten Zustandsvektors erforderlich, und der Rechenaufwand steigt exponentiell mit der Anzahl der Qubits $n$ und der Schaltkreistiefe $m$.

Bewertung der Genauigkeit (Fidelity): Lineares Kreuzentropie-Benchmarking (XEB)

Um zu beweisen, dass die experimentellen Ergebnisse nicht nur Rauschen waren, sondern tatsächlich das Ergebnis einer Quantenberechnung, verwendete Google das lineare Kreuzentropie-Benchmarking (Linear Cross-Entropy Benchmarking: XEB). Die ideale Wahrscheinlichkeit $P(x_i)$ des Schaltkreises für die im Experiment erhaltenen Bitstrings $x_i$ wird auf einem klassischen Computer berechnet, und die Genauigkeit (Fidelity) $\mathcal{F}_{\text{XEB}}$ wird mit der folgenden Formel ermittelt:

$$ \mathcal{F}_{\text{XEB}} = 2^n \langle P(x_i) \rangle_{i} - 1 $$

Wenn $\mathcal{F}_{\text{XEB}}$ 0 ist, bedeutet dies vollständiges Rauschen, bei 1 einen idealen Quantenprozessor ohne Rauschen. Der Sycamore-Prozessor erreichte bei einem Schaltkreis der Tiefe 20 ein $\mathcal{F}_{\text{XEB}} \approx 0.002$ (0,2%). Dies scheint auf den ersten Blick gering, ist aber ein statistisch signifikanter Wert über null und stellte einen erstaunlichen Erfolg dar, bei dem ein Zustandsraum von $2^{53} \approx 9 \times 10^{15}$ kontrolliert wurde.

Die Gesamtfehlerrate wurde näherungsweise als Produkt einzelner Gatterfehler, Messfehler usw. modelliert.

$$ \mathcal{F} \approx (1 - e_1)^{N_1}(1 - e_2)^{N_2} \cdots \approx \prod_{g \in 1Q} (1 - e_g) \prod_{g \in 2Q} (1 - e_g) \prod_{q} (1 - e_{RO}) $$

（※ $e_g$ ist der Gatterfehler, $e_{RO}$ ist der Messfehler）

Google behauptete, dass die Simulation dieses Schaltkreises auf einem klassischen Supercomputer (Summit) etwa 10.000 Jahre dauern würde. Im Gegensatz dazu schloss Sycamore das Sampling in nur 200 Sekunden ab.

4. Gegenargument von IBM: Von der “Überlegenheit” zur “Nützlichkeit” (Utility)

Die Ankündigung von Google schockierte die Welt, aber IBM, Entwickler des weltweit größten Supercomputers “Summit” und selbst treibende Kraft in der Quantencomputerentwicklung, veröffentlichte umgehend ein Paper, das dieser Behauptung widersprach.

Verbesserung der klassischen Simulation durch Tensornetzwerk-Kontraktion

Der Kern von IBMs Gegenargument war, dass “die Algorithmen und die Ressourcenoptimierung auf Seiten des klassischen Computers unzureichend sind”. Google stützte seine Schätzung von 10.000 Jahren auf einen Zustandsvektor-Simulator, der die Zeitentwicklung der Schrödinger-Gleichung direkt berechnet. IBM wies jedoch darauf hin, dass die Simulationszeit durch eine Methode namens “Tensornetzwerk” (Tensor Network) drastisch verkürzt werden könnte.

In einem Tensornetzwerk werden die Gatteroperationen des Quantenschaltkreises als Operationen auf mehrdimensionalen Arrays (Tensoren) dargestellt und die Reihenfolge der “Kontraktion” (Contraction) des Netzwerks optimiert. Wenn man zudem den riesigen Speicherplatz von Summit in Höhe von 250 PB (Hierarchisierung von Festplatte und Speicher) voll ausnutzt, so IBM, könne man den gesamten Zustandsvektor im Speicher halten und eine präzisere Simulation in nur “zweieinhalb Tagen” durchführen.

Quantum Advantage und Quantum Utility

Durch diese Debatte verlagerte sich der Trend in der gesamten Branche von dem Beharren darauf, “eine künstliche Aufgabe auszuführen, die klassisch unmöglich ist (Supremacy)”, hin zum Nachweis, “bei nützlichen Problemen der realen Welt einen substanziellen Vorteil gegenüber klassischen Ansätzen zu zeigen (Quantum Advantage)” und weiter zu der Phase, in der “Quantencomputer als neues Werkzeug für wissenschaftliche Entdeckungen fungieren (Quantum Utility)”.

IBM selbst vermeidet den Begriff “Überlegenheit” und schlägt Indikatoren wie das “Quantenvolumen” (Quantum Volume) und “CLOPS (Circuit Layer Operations Per Second)” als umfassende Leistungskennzahlen für Quantenprozessoren vor, wobei eine Entwicklung verfolgt wird, die das Gleichgewicht zwischen der Größe und der Qualität der Hardware betont.

timeline title "Die Evolution der Quantenmeilensteine" 2019 : "Google Sycamore (53Q)" : "Ankündigung der Quantenüberlegenheit" 2019 : "IBM Gegenargument" : "Simulation mit Summit Supercomputer in 2,5 Tagen" 2021 : "IBM Eagle (127Q)" : "Durchbruch der 100-Qubit-Barriere" 2022 : "IBM Osprey (433Q)" : "Fortschritte bei der Prozessorgröße" 2023 : "Google Surface Code" : "Skalierung der Fehlerkorrektur (d=3 auf d=5)" 2023 : "IBM Quantum Utility" : "Simulation eines komplexen Spinmodells auf 127Q" 2024 : "Darüber hinaus" : "Ära der logischen Qubits und Fehlerminderung"

5. Die nächste Grenze: Fehlerminderung (Error Mitigation) und Quantenfehlerkorrektur (QEC)

Heutige Quantencomputer werden als “NISQ” (Noisy Intermediate-Scale Quantum) bezeichnet und sind anfällig für Rauschen (Fehler aufgrund von Wechselwirkungen mit der äußeren Umgebung oder unvollständiger Kontrolle), sodass bei langen Berechnungen die Ergebnisse im Rauschen untergehen. Ansätze zur Überwindung dieses Problems lassen sich grob in “Fehlerminderung” (Error Mitigation) und “Quantenfehlerkorrektur” (Quantum Error Correction) unterteilen.

Fehlerminderung (Error Mitigation)

Fehlerminderung ist eine Methode, bei der die Auswirkungen von Rauschen durch klassische Nachbearbeitung aus den Erwartungswerten der Berechnungsergebnisse entfernt werden, ohne die Quantenhardware zu verändern. Im Jahr 2023 demonstrierte IBM durch die Kombination des 127-Qubit-“Eagle”-Prozessors mit Fehlerminderungstechniken wie der “Zero-Noise Extrapolation” (ZNE) eine Präzision bei der Zeitentwicklungs-Simulation komplexer Ising-Modelle, die modernste approximative Tensornetzwerk-Methoden übertraf, und bewies damit die “Quantum Utility” (Quantennützlichkeit).

Quantenfehlerkorrektur (QEC) und logische Qubits

Um jedoch letztendlich beliebig komplexe Algorithmen (z. B. Shors Faktorisierungsalgorithmus oder komplexe quantenchemische Berechnungen) auszuführen, reicht Fehlerminderung allein nicht aus; eine “Quantenfehlerkorrektur” (QEC), die Fehler dynamisch erkennt und korrigiert, ist unerlässlich.

Der Mainstream-Ansatz für QEC ist der “Oberflächencode” (Surface Code). Hierbei werden mehrere physikalische Qubits (Daten-Qubits) in einem zweidimensionalen Gitter angeordnet, und dazwischen werden Mess-Qubits (Ancilla-Qubits) platziert, um kontinuierlich Paritätsprüfungen, sogenannte “Stabilisatoren” (Stabilizers), durchzuführen.

graph LR Q1["Daten-Qubit (Data)"] --- M1["X-Stabilisator messen (Ancilla)"] Q2["Daten-Qubit (Data)"] --- M1 Q3["Daten-Qubit (Data)"] --- M2["Z-Stabilisator messen (Ancilla)"] Q4["Daten-Qubit (Data)"] --- M2 M1 --> EC["Fehlersyndrom-Dekodierung (Klassisch)"] M2 --> EC EC --> LQ["Statusaktualisierung des logischen Qubits"]

Schwellenwertsatz (Threshold Theorem) und Distanz $d$

In der Quantenfehlerkorrektur gibt es den “Schwellenwertsatz”. Wenn die Fehlerrate $p$ der physikalischen Qubits unter einem bestimmten Schwellenwert $p_{th}$ (beim Oberflächencode etwa um die 1%) liegt, kann die logische Fehlerrate $p_L$ exponentiell gesenkt werden, indem die Code-Distanz $d$ vergrößert wird (indem mehr physikalische Qubits einem logischen Qubit zugewiesen werden).

Eine Näherungsgleichung für die logische Fehlerrate wird wie folgt dargestellt:

$$ p_L \approx \Lambda \left( \frac{p}{p_{th}} \right)^{\frac{d+1}{2}} $$

Hierbei ist $\Lambda$ eine Konstante. Solange $p < p_{th}$ ist, wird $p_L$ umso kleiner, je größer $d$ wird. Wenn jedoch $p > p_{th}$ ist, sammelt sich umso mehr Rauschen an, je mehr physikalische Qubits hinzugefügt werden, und die logische Fehlerrate verschlechtert sich.

Googles Meilenstein 2023: Demonstration der Fehlerreduktion durch Vergrößerung der Distanz

Im Februar 2023 veröffentlichte Google ein bahnbrechendes Paper in “Nature”. Mit dem Sycamore-Prozessor der dritten Generation demonstrierten sie weltweit zum ersten Mal, dass bei einer Erweiterung der Distanz des Oberflächencodes von $d=3$ (unter Verwendung von 17 physikalischen Qubits) auf $d=5$ (unter Verwendung von 49 physikalischen Qubits) die logische Fehlerrate leicht von 3,028% auf 2,914% sank.

Dies bedeutet den Eintritt in den Bereich $p < p_{th}$ und zeigt, dass der wichtigste Proof of Concept (Prinzipnachweis) auf dem Weg zum FTQC abgeschlossen wurde: Die Leistung verbessert sich, je mehr physikalische Qubits hinzugefügt werden.

6. Roadmap und Ausblick auf FTQC (Fehlertolerantes Quantencomputing)

Google und IBM liefern sich einen harten Entwicklungswettbewerb in Richtung ihres ultimativen Ziels, dem FTQC (Fault-Tolerant Quantum Computing), wenn auch mit unterschiedlichen Architekturen und Ansätzen.

Der Ansatz von IBM: Modularisierung und Heavy-Hex-Gitter

IBM konzentriert sich darauf, die Prozessorgröße zu skalieren und gleichzeitig die Fehlerraten drastisch zu senken. Während sie mit “Eagle (127Q)”, “Osprey (433Q)” und “Condor (1121Q)” die Grenzen einzelner Chips ausreizen, kündigten sie eine modulare Architektur namens “Quantum System Two” an. Für die Kopplungstopologie der Qubits verwenden sie zudem ein “Heavy-Hex-Gitter”, das unnötiges Übersprechen (Crosstalk) reduziert und die Stabilität erhöht. IBMs Strategie ist ein hybrider Ansatz, der kurzfristig Nützlichkeit durch fortschrittliche Fehlerminderung anstrebt und schrittweise QEC einführt.

Der Ansatz von Google: Qualitätsverbesserung logischer Qubits

Die Strategie von Google legt weniger Wert auf eine rasante Erhöhung der Anzahl physikalischer Qubits, sondern konzentriert sich darauf, die Fehlerrate eines einzigen logischen Qubits bis zum Äußersten zu minimieren (z. B. auf $10^{-6}$). Darauf aufbauend streben sie die Etablierung von Technologien zum Transfer von Quantenzuständen zwischen Modulen (Quantum Interconnects) an, um ein groß angelegtes System zu schaffen, das Tausende bis Zehntausende physikalische Qubits parallel betreibt.

Die fehlertolerante Implementierung von Protokollen für Nicht-Clifford-Gatter, wie etwa die Destillation magischer Zustände (Magic State Distillation), stellt ebenfalls eine große zukünftige technische Hürde dar. Es wird geschätzt, dass für die Ausführung eines praktischen Shor-Algorithmus zum Knacken einer 2048-Bit-RSA-Verschlüsselung Tausende logischer Qubits mit einer Fehlerrate von unter $10^{-8}$ erforderlich sind, was in Millionen bis zig Millionen physikalischer Qubits resultiert. Der Weg dorthin ist noch lang.

7. Fazit

Die “Quantenüberlegenheit” war ein wichtiger Meilenstein in der Geschichte des Quantencomputers, der das theoretische Potenzial von Computern physikalisch bewies. Die Demonstration von Google im Jahr 2019 und die konstruktiven Gegenargumente von IBM haben die gesamte Branche von bloßen theoretischen Beweisen in eine Ära echten Engineerings geführt, in der die tatsächliche Nützlichkeit (Utility) und schließlich das fehlertolerante Quantencomputing (FTQC) angestrebt werden.

Wir erleben derzeit die Übergangsphase von stark verrauschten NISQ-Geräten hin zu logischen Qubit-Geräten, die mit Fehlerkorrektur ausgestattet sind. In den nächsten Jahren bis hin zu einem Jahrzehnt werden mit dieser Evolution der Quantenhardware neue Entdeckungen in den Materialwissenschaften, Revolutionen in der Medikamentenentwicklung und Durchbrüche bei Optimierungsproblemen Realität werden.

Die künftigen Entwicklungen von Google, IBM und Forschern auf der ganzen Welt, welche die Informatik der Zukunft prägen werden, bleiben weiterhin höchst spannend.