Quantum Computing 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.

Wie verändern sich Blockchain und Kryptowährungen im Post-Quanten-Zeitalter?

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

1. Einführung: Die Schritte des Post-Quanten-Zeitalters und die Krise der Blockchain

Seit der Erfindung von Bitcoin durch Satoshi Nakamoto im Jahr 2009 hat sich die Blockchain-Technologie als “dezentrales und manipulationssicheres Hauptbuch” zur Grundlage von Finanzsystemen und Anwendungen weltweit entwickelt. Diese robuste Sicherheit wird durch moderne kryptografische Technologien wie die Public-Key-Kryptografie (Public Key Cryptography) und kryptografische Hashfunktionen (Cryptographic Hash Functions) aufrechterhalten.

Diese kryptografischen Technologien garantieren Sicherheit basierend auf mathematischer “Rechenschwierigkeit”, was bedeutet, dass selbst mit klassischen Computern (den PCs oder Supercomputern, die wir heute verwenden) eine Entschlüsselung unmöglich ist, selbst wenn man die Lebensdauer des Universums dafür aufwenden würde.

Diese Prämisse wird jedoch durch die rasche Entwicklung und praktische Anwendung von Quantencomputern (Quantum Computers), der Grenze von Physik und Informatik, grundlegend umgestoßen. Quantencomputer, die quantenmechanische Phänomene wie “Superposition” und “Quantenverschränkung (Entanglement)” nutzen, weisen bei bestimmten mathematischen Problemen eine Rechenleistung auf, die klassische Computer bei weitem übertrifft – die sogenannte “Quantenüberlegenheit (Quantum Supremacy)”.

In diesem Artikel werden wir eingehend und aus einer technischen und mathematischen Perspektive untersuchen, welchen spezifischen Bedrohungen die Blockchain-Technologie durch Quantencomputer ausgesetzt ist. Wir werden die neuesten Entwicklungen der Post-Quanten-Kryptografie (PQC: Post-Quantum Cryptography) als Lösung und die Migrationsszenarien für Krypto-Asset-Netzwerke detailliert erläutern.

2. Grundlagen von Quantencomputern und zwei große Bedrohungen für die Blockchain

Aktuelle Blockchain-Systeme bestehen hauptsächlich aus den folgenden zwei kryptografischen Elementen, die jeweils unterschiedlichen Bedrohungen durch Quantenalgorithmen ausgesetzt sind.

graph TD A["Erstaunliche Rechenleistung von Quantencomputern"] --> B["Shors Algorithmus (Shor's Algorithm)"] A --> C["Grovers Algorithmus (Grover's Algorithm)"] B --> D["Zusammenbruch der Public-Key-Kryptografie (ECDSA/RSA/DSA)"] C --> E["Auswirkungen auf kryptografische Hashfunktionen (SHA-256)"] D --> F["Identifizierung fremder privater Schlüssel und Fälschung von Transaktionen"] E --> G["Überlegenheit beim PoW-Mining und Angriffe auf einige Adressen"] F --> H["Fatale und direkte Bedrohung in der Blockchain"] G --> I["Bedrohung, die durch Anpassung des Algorithmus (z. B. Erweiterung der Schlüssellänge) bewältigt werden kann"] style H fill:#ff9999,stroke:#cc0000,stroke-width:2px; style I fill:#ffff99,stroke:#cccc00,stroke-width:2px;

2.1. Grundlagen der Elliptic Curve Cryptography (ECDSA) und Rechenschwierigkeit

Viele Blockchains wie Bitcoin und Ethereum verwenden den Elliptic Curve Digital Signature Algorithm (ECDSA) als ihren digitalen Signaturalgorithmus. Insbesondere nutzt Bitcoin eine elliptische Kurve mit den Parametern secp256k1.

Die Sicherheit der Elliptic Curve Cryptography beruht auf der Rechenschwierigkeit des Elliptic Curve Discrete Logarithm Problem (ECDLP). Eine elliptische Kurve wird durch eine Gleichung in der folgenden Weierstraß-Normalform definiert.

$$ y^2 \equiv x^3 + ax + b \pmod{p} $$

Bei Bitcoins secp256k1 gilt $a = 0, b = 7$ und $p$ ist eine sehr große Primzahl. Sei $G$ ein Basispunkt auf dieser Kurve und $k$ ein zufällig gewählter privater Schlüssel, der eine riesige 256-Bit-Zahl ist. Dann wird der öffentliche Schlüssel $K$ durch $k$-malige Addition (Skalarmultiplikation) des Basispunktes berechnet.

$$ K = k \times G = \underbrace{G + G + \dots + G}_{k \text{ times}} $$

Die umgekehrte Berechnung des privaten Schlüssels $k$ aus dem veröffentlichten öffentlichen Schlüssel $K$ und dem Basispunkt $G$ (Berechnung des diskreten Logarithmus) mit einem klassischen Computer erfordert selbst mit den besten klassischen Algorithmen wie der Pollard-Rho-Methode eine exponentielle Rechenzeit von $\mathcal{O}(\sqrt{p})$. Bei einem 256-Bit-Schlüssel sind etwa $2^{128}$ Operationen erforderlich, was auf einem Niveau liegt, das selbst bei Milliarden Jahren Betrieb aktueller Supercomputer nicht gelöst werden kann.

2.2. Der Zusammenbruch durch Shors Algorithmus (Shor’s Algorithm)

Dieser Ansatz wurde jedoch 1994 durch Shors Algorithmus, der von Peter Shor veröffentlicht wurde, vollständig zerstört. Shors Algorithmus wurde ursprünglich vorgeschlagen, um das Primfaktorzerlegungsproblem (die Basis der RSA-Kryptografie) in polynomieller Zeit zu lösen, er kann jedoch auch auf das Problem des diskreten Logarithmus und das Problem des diskreten Logarithmus auf elliptischen Kurven angewendet werden.

Der Kern von Shors Algorithmus liegt in der Verwendung der Quanten-Fourier-Transformation (QFT: Quantum Fourier Transform), um die “Periode (Period)” einer Funktion schnell zu finden.

$$ \text{Klassische Berechnungskomplexität} = \mathcal{O}(2^{n/2}) \quad (n\text{ ist die Bitlänge}) $$ $$ \text{Berechnungskomplexität des Quantenalgorithmus} = \mathcal{O}(n^3) $$

Auf diese Weise reduziert Shors Algorithmus die exponentielle Zeit drastisch auf polynomielle Zeit (Polynomial Time). Sobald ein Quantencomputer mit ausreichend logischen Qubits fertiggestellt ist, wird es möglich sein, den privaten Schlüssel $k$ innerhalb von Minuten oder Sekunden aus einem im Netzwerk veröffentlichten öffentlichen Schlüssel $K$ zu identifizieren. Dies würde es einem Angreifer ermöglichen, leicht an den privaten Schlüssel der Wallet einer anderen Person zu gelangen und die vollständige Kontrolle über die Gelder zu übernehmen.

2.2.1 Schritt-für-Schritt-Erklärung der ECDLP-Entschlüsselung durch Shors Algorithmus

Lassen Sie uns den internen Prozess Schritt für Schritt betrachten, wie ein Quantencomputer das Elliptic Curve Discrete Logarithm Problem (ECDLP) löst.

Problemstellung: In $K = k \times G$ sind $G$ und $K$ bekannt, und wir möchten die unbekannte ganze Zahl $k$ (den privaten Schlüssel) finden. Sei die Ordnung der elliptischen Kurve $N$.

Schritt 1: Erzeugung des Superpositionszustands Zunächst werden zwei Quantenregister vorbereitet, und auf jedes wird ein Hadamard-Gatter (Hadamard Gate) angewendet, um einen Superpositionszustand aller möglichen Kombinationen ganzer Zahlen zu erzeugen.

$$ |\psi_1\rangle = \frac{1}{N} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} |x\rangle |y\rangle |0\rangle $$

Schritt 2: Anwendung des Quantenorakels (Auswertung der Funktion) Als nächstes wird unter Verwendung eines Quantenschaltkreises (Orakel), der Punkte auf einer elliptischen Kurve addiert, die Funktion $f(x, y) = x \times G + y \times K$ in einem dritten Register berechnet.

$$ |\psi_2\rangle = \frac{1}{N} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} |x\rangle |y\rangle |x \times G + y \times K\rangle $$

Wichtig hierbei ist, da $K = k \times G$ gilt, kann dies als $f(x, y) = (x + y \cdot k) \times G$ umgeschrieben werden.

Schritt 3: Messung des dritten Registers Wenn das dritte Register gemessen wird, kollabiert es zu einem Punkt $R$ auf der elliptischen Kurve. Dadurch kollabieren das erste und zweite Register in einen Superpositionszustand von Paaren $(x, y)$, die $x + y \cdot k \equiv c \pmod{N}$ ($c$ ist eine Konstante) erfüllen.

$$ |\psi_3\rangle = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1} |c - y \cdot k \pmod{N}\rangle |y\rangle $$

Schritt 4: Anwendung der Quanten-Fourier-Transformation (QFT) Dieser Zustand hat eine Periodizität, die mit der Periode $k$ zusammenhängt. Durch Anwendung der inversen Quanten-Fourier-Transformation (Inverse QFT) auf diesen Zustand wird eine Phaseninterferenz ausgelöst, die die Periodeninformationen in Amplituden umwandelt.

Schritt 5: Messung und klassische Nachbearbeitung Wenn das erste und zweite Register gemessen werden, erhält man mit hoher Wahrscheinlichkeit einen Wert, der Informationen über $k$ enthält. Durch die Anwendung klassischer zahlentheoretischer Algorithmen wie der Kettenbruchentwicklung (Continued Fractions) auf den gemessenen Wert kann der unbekannte private Schlüssel $k$ vollständig identifiziert werden.

Die Anzahl der für diesen gesamten Prozess benötigten Quantengatter beträgt $\mathcal{O}(\log^3 N)$, und der private Schlüssel wird mit einer extremen Geschwindigkeit aufgedeckt, die nicht mit der Suche in $\mathcal{O}(\sqrt{N})$ durch klassische Computer vergleichbar ist.

2.3. Grovers Algorithmus (Grover’s Algorithm) und Auswirkungen auf Hashfunktionen

Eine weitere Bedrohung ist Grovers Algorithmus, der 1996 von Lov Grover vorgeschlagen wurde. Dieser hat große Auswirkungen auf Hashfunktionen (z. B. SHA-256).

In der Blockchain werden Hashfunktionen zur Gewährleistung der Datenintegrität, zur Generierung von Adressen und als Grundlage für das PoW-Mining (Proof of Work) in Bitcoin verwendet. Die Rückrechnung (Urbildberechnung) einer Hashfunktion kann als “Problem der Suche in unstrukturierten Datenbanken” betrachtet werden, bei dem nach einem Eingabewert $x$ gesucht wird, für den $H(x) = y$ für einen bestimmten Ausgabewert $y$ gilt.

Mit einem klassischen Computer sind im Durchschnitt $\frac{N}{2}$ und im schlimmsten Fall $N$ Versuche erforderlich, um die richtige Antwort unter $N$ Möglichkeiten zu finden. Die Berechnungskomplexität beträgt also $\mathcal{O}(N)$. Grovers Algorithmus verwendet jedoch eine Quantentechnologie namens “Amplitudenverstärkung (Amplitude Amplification)”. Durch iteratives Verstärken der Wahrscheinlichkeitsamplitude des Zustands, der die richtige Antwort darstellt, aus allen Möglichkeiten im Superpositionszustand, wird die Suchzeit auf die Quadratwurzel reduziert.

$$ \text{Berechnungskomplexität von Grovers Algorithmus} = \mathcal{O}(\sqrt{N}) $$

Im Fall von SHA-256 ist $N = 2^{256}$, sodass eine klassische Brute-Force-Suche etwa $2^{256}$ Versuche erfordert. Wenn jedoch Grovers Algorithmus verwendet wird, sind nur $\sqrt{2^{256}} = 2^{128}$ Versuche erforderlich. Dies bedeutet, dass eine 256-Bit-Hashfunktion gegenüber Quantencomputern praktisch auf eine Sicherheitsstärke von 128 Bit halbiert wird.

2.3.1. Wird SHA-256 überleben? (Quantum Supremacy in Hashing)

Obwohl sich die Sicherheit halbiert, ist eine “128-Bit-Sicherheit” immer noch extrem stark. $2^{128}$ Operationen sind selbst nach heutigem Stand der Technik eine astronomische Zahl und würden die Lebensdauer des Universums erfordern. Daher ist die Ansicht weit verbreitet, dass “SHA-256 auch gegenüber Quantencomputern eine praktische Sicherheit beibehält”. Wenn es in Zukunft erforderlich sein sollte, die Sicherheitsmarge zu erhöhen, kann die klassische 256-Bit-Sicherheit auch in der Quantenwelt aufrechterhalten werden, indem einfach die Ausgabelänge des Hashs verdoppelt wird (z. B. Migration von SHA-256 zu SHA-512).

Zusammenfassend lässt sich sagen, dass die Quantenbedrohung für Hashfunktionen “gering und handhabbar” ist, während die Bedrohung für Public-Key-Kryptografie (ECDSA) “fatal” ist.

3. Analyse der konkreten Auswirkungen auf aktuelle Krypto-Assets (Bitcoin, Ethereum)

Welchen spezifischen Schwachstellen werden Krypto-Asset-Netzwerke in einer Welt ausgesetzt sein, in der ECDSA durch Quantencomputer entschlüsselt werden kann? Hier werden wir am Beispiel der Funktionsweise von Bitcoin eine detaillierte Analyse aus der Perspektive des “Zeitpunkts der Offenlegung des öffentlichen Schlüssels” durchführen.

3.1. Generierung von Adressen und die “Nicht-Öffentlichkeit” des öffentlichen Schlüssels

Bitcoin-Adressen (P2PKH: Pay-to-Public-Key-Hash und P2WPKH: Pay-to-Witness-Public-Key-Hash) verwenden nicht den öffentlichen Schlüssel selbst, sondern einen mehrfach gehashten öffentlichen Schlüssel.

$$ \text{Bitcoin Address} = \text{Base58Check}(\text{RIPEMD160}(\text{SHA256}(\text{Public Key}))) $$

Wie bereits erwähnt, sind Hashfunktionen resistent gegen Quantenangriffe (Grovers Algorithmus), sodass es selbst für Quantencomputer unmöglich ist, den ursprünglichen “öffentlichen Schlüssel” aus der “Adresse”, die ein Hashwert ist, rückzurechnen. Das bedeutet, dass für “unbenutzte Adressen (solche, von denen noch nie Gelder gesendet wurden)” der öffentliche Schlüssel überhaupt nicht auf der Blockchain offengelegt ist und nur der Hashwert aufgezeichnet wird. Da der öffentliche Schlüssel unbekannt ist, gibt es daher kein Ziel für die Ausführung von Shors Algorithmus, und der private Schlüssel kann nicht identifiziert werden. Es kann gesagt werden, dass Wallets in diesem Zustand quantensicher (Quantum-safe) sind.

3.2. Fatale Schwachstelle beim Senden von Transaktionen (Front-Running-Angriff)

Das Problem tritt auf, wenn der Benutzer Gelder überweist. Beim Übertragen (Senden) einer Transaktion an das Netzwerk muss der Benutzer zusammen mit der digitalen Signatur seinen öffentlichen Schlüssel in die Transaktionsdaten aufnehmen und ihn dem gesamten Netzwerk zur Überprüfung offenlegen.

sequenceDiagram participant User as "Benutzer (Alice)" participant Mempool as "Mempool (Pool für unbestätigte Transaktionen)" participant QuantumAttacker as "Quanten-Angreifer" participant Miner as "Miner (Blockgenerierung)" User->>Mempool: Senden der Transaktion (inklusive öffentlichem Schlüssel + Signatur) Mempool-->>QuantumAttacker: Abfangen des öffentlichen Schlüssels im Netzwerk note right of QuantumAttacker: Ausführung von Shors Algorithmus in Minuten
(Berechnung des privaten Schlüssels aus dem öffentlichen Schlüssel) QuantumAttacker->>QuantumAttacker: Generierung einer neuen Signatur mit Alices privatem Schlüssel QuantumAttacker->>Mempool: Senden (Broadcast) der betrügerischen Überweisung mit höherer Miner-Gebühr Miner->>Miner: Priorisierung der betrügerischen Transaktion mit hoher Gebühr (Gas) für die Aufnahme in den Block Miner-->>User: Aufzeichnung auf der Blockchain (Verlust von Alices Geldern)

Sobald der öffentliche Schlüssel an den Mempool (den Wartebereich für unbestätigte Transaktionen) gesendet wurde, werden diese Daten mit Nodes weltweit geteilt. Wenn ein Angreifer über einen ultraschnellen Quantencomputer verfügt, könnte er mit folgendem Prozess Gelder stehlen:

Eine legitime Benutzertransaktion (Alice) aus dem Mempool abfangen und den öffentlichen Schlüssel extrahieren.
Shors Algorithmus ausführen und den privaten Schlüssel aus dem öffentlichen Schlüssel innerhalb von Minuten (bevor der Block bestätigt wird) berechnen.
Den erhaltenen privaten Schlüssel verwenden, um eine gefälschte Transaktion zu erstellen, die Alices Gelder an die Adresse des Angreifers sendet.
Diese gefälschte Transaktion mit einer viel höheren Miner-Gebühr (Fee) als Alices ursprüngliche Transaktion an das Netzwerk senden.

Miner folgen wirtschaftlichen Anreizen und priorisieren Transaktionen mit hohen Gebühren für die Aufnahme in Blöcke. Infolgedessen wird die betrügerische Überweisung des Angreifers zuerst bestätigt (Confirm), und Alices legitime Überweisung wird als “unzureichendes Guthaben (Double Spend)” verworfen. Diese Abfolge von Ereignissen wird als Front-Running-Angriff (Front-running Attack) bezeichnet. In einer Welt, in der Quantencomputer praktisch einsetzbar sind, würde dies zu der erschreckenden Situation führen, dass in dem Moment, in dem jemand auf den Senden-Button drückt, seine Gelder von Hackern gestohlen werden.

3.3. Die Krise wiederverwendeter Adressen und alter Adressen (P2PK)

Ein noch größeres Problem ist, dass bei Adressen, von denen in der Vergangenheit bereits Gelder gesendet wurden (z. B. wenn sie als Wechselgeldadressen wiederverwendet werden), der öffentliche Schlüssel bereits dauerhaft auf der Blockchain aufgezeichnet ist. Bei diesen Adressen besteht jederzeit die Gefahr, dass der private Schlüssel berechnet und das Guthaben gestohlen wird, ohne dass auf das Senden einer Transaktion gewartet werden muss.

Darüber hinaus wurde beim P2PK-Format (Pay-to-Public-Key), das von 2009 bis etwa 2010 vorherrschte und die frühen Mining-Belohnungen von Satoshi Nakamoto (über 1 Million BTC) enthält, der öffentliche Schlüssel selbst direkt als Adresse auf der Blockchain aufgezeichnet, nicht als Hash. Diese massiven Mengen an ruhenden Bitcoins wären das leichteste Ziel für Quantencomputer, und wenn sie alle auf einmal gestohlen und auf den Markt geworfen werden, könnte dies einen massiven Preisverfall auslösen.

4. Migrationsszenarien zur Post-Quanten-Kryptografie (PQC: Post-Quantum Cryptography)

Um eine solche Katastrophe am “Q-Day (dem Tag, an dem die Kryptografie durch Quantencomputer gebrochen wird)” zu vermeiden, planen die kryptografische Wissenschaft und die Blockchain-Community den Übergang zur Post-Quanten-Kryptografie (PQC), die auch von Quantenalgorithmen schwer zu knacken ist. Das US National Institute of Standards and Technology (NIST) führt seit Jahren einen PQC-Standardisierungsprozess durch, und nach mehreren Runden strenger Evaluierung wurden einige vielversprechende kryptografische Methoden als endgültige Standards ausgewählt.

Wir werden die wichtigsten PQC-Algorithmen, die als Alternativen für digitale Blockchain-Signaturen Beachtung finden, zusammen mit ihren mathematischen Mechanismen im Detail erläutern.

4.1. Hash-basierte Signaturen (Hash-Based Signatures)

Hash-basierte Signaturen sind eine kryptografische Methode, deren Sicherheit ausschließlich auf einer sehr einfachen und starken Grundlage beruht: der “Kollisionsresistenz der Hashfunktion”. Da die Sicherheit von Hashfunktionen gegen Quantencomputer bereits nachgewiesen ist (wie oben erwähnt, ist eine Sicherheitsmarge von 128 Bit ausreichend), handelt es sich um einen äußerst zuverlässigen Ansatz. Bemerkenswerte Beispiele sind Lamport-Signaturen (Lamport Signatures), das davon abgeleitete WOTS (Winternitz One-Time Signature) und der NIST-Standardisierungskandidat SPHINCS+ (jetzt als FIPS 205 unter dem Namen SLH-DSA bekannt).

4.1.1. Mathematische Details der Lamport-Signatur (One-Time Signature)

Lassen Sie uns den Mechanismus von Lamport-Signaturen in mathematischerem Detail betrachten. Sei die Hashfunktion $H: \{0, 1\}^* \to \{0, 1\}^{256}$.

【Schlüsselerzeugung】 Alice (die Senderin) verwendet einen echten Zufallszahlengenerator (TRNG), um 256 Paare von privaten Schlüsseln zu generieren.

$$ \text{sk}_{i,0} \in \{0, 1\}^{256}, \quad \text{sk}_{i,1} \in \{0, 1\}^{256} \quad (1 \le i \le 256) $$

Der private Schlüssel $\text{sk}$ besteht somit aus insgesamt 512 256-Bit-Strings (Größe: $512 \times 32 = 16.384$ Byte).

Als nächstes berechnet sie den öffentlichen Schlüssel $\text{pk}$. Jede Komponente des privaten Schlüssels wird individuell gehasht.

$$ \text{pk}_{i,0} = H(\text{sk}_{i,0}), \quad \text{pk}_{i,1} = H(\text{sk}_{i,1}) $$

Der öffentliche Schlüssel ist ebenfalls $16.384$ Byte groß. Dieser wird im Blockchain-Netzwerk veröffentlicht.

【Signaturerstellung】 Um Transaktionsdaten $M$ zu signieren, berechnet Alice zunächst deren Hashwert.

$$ h = H(M) \in \{0, 1\}^{256} $$

Sei das $i$-te Bit des Hashwertes $h$ gleich $h_i \in \{0, 1\}$. Alices Signatur $\sigma$ ist die Menge der privaten Schlüsselkomponenten, die jedem Bit $h_i$ entsprechen.

$$ \sigma = (\text{sk}_{1, h_1}, \text{sk}_{2, h_2}, \dots, \text{sk}_{256, h_{256}}) $$

Mit anderen Worten, wenn das Bit des Nachrichtenhashs 0 ist, wird $\text{sk}_{i,0}$ veröffentlicht, und wenn es 1 ist, wird $\text{sk}_{i,1}$ veröffentlicht. Die Signaturgröße beträgt $256 \times 32 = 8.192$ Byte.

【Signaturprüfung】 Der Miner (Prüfer) verwendet die empfangene Transaktion $M$, die Signatur $\sigma = (s_1, s_2, \dots, s_{256})$ und den öffentlichen Schlüssel $\text{pk}$, um eine Überprüfung durchzuführen. Der Hash der Transaktion $h = H(M)$ wird neu berechnet, und es wird geprüft, ob der Hash jedes $s_i$ mit dem entsprechenden Element $\text{pk}_{i, h_i}$ des öffentlichen Schlüssels übereinstimmt.

$$ H(s_i) \overset{?}{=} \text{pk}_{i, h_i} \quad (\text{für alle } 1 \le i \le 256) $$

Dieser Prozess ist mathematisch extrem einfach, und solange ein Quantencomputer die Funktion $H$ nicht rückrechnen kann, ist es unmöglich, eine Signatur zu fälschen. Da jedoch bei einer Signatur die Hälfte des privaten Schlüssels dem Netzwerk offengelegt wird, führt das Signieren einer anderen Nachricht mit demselben Schlüsselpaar dazu, dass die offengelegten privaten Schlüssel kombiniert werden und dem Angreifer Raum für Fälschungen bieten. Dies führt zu der starken Einschränkung, dass sie nur “einmalig (One-Time)” verwendet werden können. Um dies praktikabel zu machen, wurden Technologien wie XMSS, die einen Merkle-Baum verwenden, um zahlreiche One-Time-Schlüssel in einem Stamm-Public-Key (Root Public Key) zu bündeln, und zustandslose (stateless) Methoden wie SPHINCS+ entwickelt, die jedoch den Nachteil haben, dass die Signaturgrößen mehrere Dutzend Kilobyte erreichen.

4.2. Gitterbasierte Kryptografie (Lattice-Based Cryptography)

Derzeit ist die gitterbasierte Kryptografie als Mainstream der PQC am vielversprechendsten und wurde als Hauptstandard des NIST übernommen (FIPS 204: ML-DSA / ehemals CRYSTALS-Dilithium sowie Falcon usw.).

Die Sicherheit der gitterbasierten Kryptografie beruht auf mathematisch bewiesenen schweren Problemen, wie dem “Kürzesten-Vektor-Problem (SVP: Shortest Vector Problem)” in mehrdimensionalen Gittern oder dem “Learning With Errors-Problem (LWE)”. Es wurden keine Algorithmen gefunden, die Gitterprobleme selbst mit Quantencomputern effizient lösen.

Mathematisches Modell von LWE (Learning With Errors): Die Grundidee des LWE-Problems besteht darin, simultanen linearen Gleichungen absichtlich ein “kleines Rauschen (Fehler)” hinzuzufügen, um das Problem drastisch zu erschweren. Sei der geheime Vektor $\mathbf{s} \in \mathbb{Z}_q^n$. Es gibt eine zufällig ausgewählte große öffentliche Matrix $\mathbf{A} \in \mathbb{Z}_q^{m \times n}$ und einen absichtlich hinzugefügten kleinen Rauschvektor $\mathbf{e} \in \mathbb{Z}_q^m$. Der öffentliche Schlüssel $\mathbf{b}$ wird wie folgt berechnet:

$$ \mathbf{b} = \mathbf{A}\mathbf{s} + \mathbf{e} \pmod{q} $$

Selbst wenn die Matrix $\mathbf{A}$ und der Vektor $\mathbf{b}$ (öffentlicher Schlüssel) öffentlich bekannt sind, ist die Rückrechnung des privaten Schlüssels $\mathbf{s}$ durch das Vorhandensein des Rauschens $\mathbf{e}$ sehr schwierig. Ohne das Rauschen könnte es einfach durch Gaußsche Elimination gelöst werden, aber das Hinzufügen von Rauschen führt zu einer explosiven Vergrößerung des Suchraums in allen Dimensionen, was eine robuste Sicherheit sowohl gegen klassische als auch gegen Quantencomputer bietet. In tatsächlichen Algorithmen, die in Blockchains und ähnlichem verwendet werden (wie Dilithium), wird dies als Ring-LWE (oder Module-LWE) auf einem Polynomring eingesetzt, um die Schlüsselgröße zu reduzieren und Berechnungen zu beschleunigen.

Vorteile: Im Vergleich zu Hash-basierten Signaturen sind der öffentliche Schlüssel und die Signaturgröße relativ klein (wenige Kilobyte), und die Rechengeschwindigkeit für die Signaturerstellung und -überprüfung ist extrem schnell (vergleichbar oder schneller als ECDSA).
Nachteile: Die mathematische Struktur ist komplex und der historische Bewertungszeitraum ist kurz, sodass das Risiko, dass in Zukunft neue Entschlüsselungsalgorithmen entdeckt werden, nicht Null ist.

5. Technische Herausforderungen beim PQC-Übergang in Blockchains

Auch wenn es PQC-Algorithmen (wie Dilithium oder SPHINCS+) gibt, bedeutet das nicht, dass sie ab morgen in Bitcoin oder Ethereum eingeführt werden können. Es gibt mehrere große Herausforderungen, die spezifisch für dezentrale Systeme sind.

5.1. Aufblähen der Signaturgrößen und der Zusammenbruch der Skalierbarkeit

Die größte Hürde bei der Einführung von PQC ist die massive Aufblähung der Datengrößen. Während die aktuelle Signaturgröße von ECDSA etwa 70 Byte beträgt, beträgt die Signaturgröße von Dilithium (ML-DSA) etwa 2.420 bis 4.595 Byte (je nach Sicherheitsniveau) und die Größe des öffentlichen Schlüssels übersteigt 1.300 Byte. Bei Hash-basiertem SPHINCS+ erreicht allein die Signatur mehrere zehntausend Byte.

Wenn Bitcoin PQC bei gleicher Blockgrößenbeschränkung (etwa 4 MB Gewicht einschließlich SegWit) einführen würde, würde die Anzahl der Transaktionen, die in einem Block gespeichert werden können, drastisch sinken. Der Durchsatz des Netzwerks (TPS: Transactions Per Second) würde katastrophal abnehmen, und Transaktionsstaus würden zur Norm werden. Um dies zu beheben, wäre eine deutliche Erhöhung der Blockgröße erforderlich, was jedoch die Speicheranforderungen und Netzwerkbandbreitenanforderungen für Full Nodes erhöhen würde, was es für Einzelpersonen schwierig macht, Nodes zu betreiben, und letztendlich zum Dilemma einer Zentralisierung des Netzwerks führt.

pie title "Vergleich der Signaturdatengrößen in der Blockchain (Konzeptdiagramm)" "ECDSA (ca. 70 Bytes)" : 2 "Dilithium ML-DSA (ca. 2.500 Bytes)" : 58 "SPHINCS+ (ca. 17.000 Bytes)" : 40

(※ Die Datenaufblähung von Transaktionen bei der Einführung von PQC wird zu einem fatalen Engpass für die Skalierbarkeit werden)

5.2. Auswirkungen auf die Ethereum Virtual Machine (EVM) und vorkompilierte Smart Contracts

In Turing-vollständigen Smart-Contract-Plattformen wie Ethereum erfordert die Einführung von PQC ein grundlegendes Upgrade der EVM (Ethereum Virtual Machine). In der aktuellen EVM wird zur Überprüfung von ECDSA-Signaturen ein vorkompilierter Contract (Precompiled Contract) namens ecrecover (Adresse: 0x01) bereitgestellt, der so optimiert ist, dass er Signaturprüfungen mit sehr niedrigen Gasgebühren (3000 Gas) durchführt.

Die Verarbeitungslogik für neue Gitter-basierte Kryptoalgorithmen wie Dilithium oder Falcon beinhaltet jedoch komplexe Polynom- oder Matrixoperationen. Wenn sie nur mit bestehenden EVM-Opcodes (Opcode) implementiert würde, könnte eine einzige Signaturüberprüfung Millionen bis Zehnmillionen von Gas verbrauchen. Dies liegt auf einem Niveau, das das aktuelle Block-Gaslimit (etwa 30 Millionen Gas) mit einer einzigen Transaktion aufbrauchen würde.

Um dies zu vermeiden, ist es notwendig, durch einen Hard Fork (Hard Fork) des Netzwerks einen neuen Precompiled Contract zur PQC-Überprüfung (z.B. Zuweisung von DilithiumVerify zu 0x10) in die EVM selbst aufzunehmen. Dies erfordert einen langfristigen Prozess, bei dem die Core-Entwickler jedes Ethereum-Clients (Geth, Nethermind, Erigon usw.) zusammenarbeiten, um die Logik der Gitterkryptografie-Überprüfung auf Sprachebene in C++, Go, Rust usw. optimiert zu implementieren und Sicherheitsaudits durchzuführen.

5.3. Schwierigkeit der Konsensfindung durch Hard Forks

Um den zugrunde liegenden Signaturalgorithmus zu ändern, ist ein Hard Fork (Hard Fork) erforderlich, der das Protokoll des gesamten Netzwerks aktualisiert. Der Prozess zur Erzielung eines Konsenses ist jedoch in Gemeinschaften wie Bitcoin, die großen Wert auf “Keine Regeländerungen und Dezentralisierung” legen, politisch extrem schwierig. Von dem Moment an, in dem ein BIP (Bitcoin Improvement Proposal) für den Übergang zu PQC vorgeschlagen wird, bis zu seiner Umsetzung werden Jahre der Diskussion und Tests erforderlich sein.

6. Wann kommt der “Q-Day”? Roadmap für die Migration

Wann wird der “Q-Day”, an dem Quantencomputer die 256-Bit Elliptic Curve Cryptography vollständig entschlüsseln, eintreten? Obwohl die Meinungen unter Forschern auseinandergehen, prognostizieren viele Experten, dass groß angelegte Quantencomputer mit Tausenden bis Zehntausenden stabiler logischer Qubits (fehlerkorrigierte Qubits mit Rauschtoleranz) “zwischen Mitte der 2030er und den 2040er Jahren” auf den Markt kommen werden. Je nach Durchbrüchen in der Hardware-Architektur oder der Entdeckung effizienterer Quantenalgorithmen kann jedoch nicht ausgeschlossen werden, dass dieser Zeitpunkt früher eintreten könnte (um 2030).

Die Roadmap, die das Krypto-Asset-Ökosystem einschlagen sollte, bevor es zu spät ist, sieht wie folgt aus.

Phase 1: Hybride Signaturen und Kontoabstraktion (Account Abstraction) (Jetzt bis ca. 2028)

Die derzeitige Blockchain-Community, insbesondere das Ethereum-Entwicklungsteam (Vitalik Buterin usw.), erwägt “hybride Signaturen”, die ECDSA und PQC (Hash-basierte Signaturen oder gitterbasierte Kryptografie) kombinieren. Dies ist ein Ansatz, bei dem einer Transaktion sowohl die bestehende sichere ECDSA-Signatur als auch eine PQC-Signatur hinzugefügt werden, wodurch die Sicherheit erhalten bleibt, selbst wenn eine davon gebrochen wird. Darüber hinaus werden durch die Nutzung der Kontoabstraktion (Account Abstraction, ERC-4337) Bemühungen vorangetrieben, PQC-Signaturen auf Smart-Contract-Wallets auf Opt-in-Basis (nur für Benutzer, die dies wünschen) zu implementieren und zu unterstützen, ohne auf einen Protokoll-Hard-Fork zu warten.

Phase 2: Nutzung von Zero-Knowledge Proofs (ZK-Rollups) (2025 ~)

Die Trumpfkarte zur Lösung des größten Schwachpunkts von PQC, der “Aufblähung von Signaturdaten”, ist die erwartete Nutzung der Layer-2-Technologie, ZK-Rollups (Zero-Knowledge Proofs). Anstatt riesige PQC-Signaturdaten direkt in Layer 1 (die Mainchain) zu schreiben, werden zahlreiche PQC-Transaktionen auf Layer 2 verifiziert und aggregiert. Dann werden sie mithilfe von ZK-SNARKs oder ZK-STARKs in einen extrem kleinen, einzelnen “Beweis (Proof)” komprimiert und auf Layer 1 aufgezeichnet. Es ist anzumerken, dass bestimmte SNARK-Konstruktionen (wie Groth16) selbst quanten-anfällig sind. Daher ist die Annahme von ZK-STARKs, die sich ausschließlich auf quantenresistente Hashfunktionen stützen, der Schlüssel.

Phase 3: Protokoll-Level Hard Fork (ca. 2030)

Sobald die NIST-Standardisierung für PQC vollständig etabliert ist und branchenübliche Bibliotheken verfügbar und gründlich getestet sind, wird erwartet, dass große Chains wie Bitcoin und Ethereum einen Hard Fork durchführen, um die Standard-Signaturmethode vollständig auf PQC umzustellen. Während dieser Übergangsphase wird es groß angelegte Ankündigungen geben, die die Benutzer auffordern, “ihre Gelder von alten Wallets in neue PQC-kompatible Wallets zu verschieben”.

Wegweisende Projektbeispiele

Einige Blockchain-Projekte haben diese Quantenbedrohung antizipiert und wurden von Anfang an mit dem Anspruch auf Quantenresistenz entwickelt.

QRL (Quantum Resistant Ledger): Eine frühe Blockchain, die XMSS (eXtended Merkle Signature Scheme), eine Hash-basierte PQC, nativ auf Protokollebene implementiert hat.
Algorand / Cellframe: Projektgruppen, die über eine flexible modulare Architektur der Kryptografie-Schicht im Hinblick auf zukünftige PQC-Updates verfügen und aktiv nach der Integration von Gitterkryptografie suchen.

7. Fazit: Die Zukunft von Krypto-Assets und der Schutz unserer Vermögenswerte

Die Ankunft des “Post-Quanten-Zeitalters” hat den Bereich der reinen Science-Fiction überschritten und steht uns bereits als konkretes technisches Problem für reale kryptografische Systeme unmittelbar bevor.

Die beiden Schwerter des Quantencomputings, Shors Algorithmus und Grovers Algorithmus, bedrohen die Grundlage der heutigen Blockchains, nämlich die Public-Key-Kryptografie bzw. Hashfunktionen. Insbesondere die Verwundbarkeit von ECDSA ist fatal, und der Übergang zur Post-Quanten-Kryptografie (PQC) ist eine absolute Notwendigkeit, um das Risiko eines Diebstahls von Geldern durch Front-Running-Angriffe zu vermeiden.

Die Tech-Welt und die Blockchain-Community warten jedoch nicht tatenlos auf den Weltuntergang. Die Auswahl und Standardisierung von PQC-Algorithmen wie der gitterbasierten Kryptografie und Hash-basierten Signaturen schreitet stetig voran, und durch den Einsatz von Zero-Knowledge-Proofs (ZK-STARKs) und Layer-2-Skalierungstechnologien zeichnet sich ein Weg ab, das größte Hindernis der PQC-Einführung, die “Aufblähung der Datengröße”, zu überwinden.

Normale Krypto-Benutzer und Investoren wie wir müssen jetzt nicht in Panik geraten und alle unsere Gelder verkaufen. Es ist jedoch wichtig, ein grundlegendes Verständnis und Bewusstsein für den Selbstschutz wie folgt zu haben:

Vermeiden Sie die Wiederverwendung von Adressen: Vermeiden Sie es strikt, Gelder für lange Zeiträume an “verwendeten Adressen (Adressen, von denen mindestens einmal Gelder gesendet wurden und der öffentliche Schlüssel auf der Blockchain freigelegt ist)” zu speichern. Dies gilt nicht nur aus Gründen des Datenschutzes, sondern auch aus Sicherheitsgründen.
Behalten Sie Technologietrends im Auge: Verfolgen Sie Nachrichten über Diskussionen und Hard Forks im Zusammenhang mit der PQC-Migration auf großen Netzwerken wie Bitcoin-BIPs oder Ethereum-EIPs, damit Sie Ihre Wallets bei Bedarf rechtzeitig migrieren können.

Die Geschichte der Blockchain ist immer eine Geschichte von Upgrades und Widerstandsfähigkeit (Resilience) gegenüber neuen technologischen Bedrohungen. So wie sie Skalierbarkeitsprobleme und Umweltbedenken (wie den Übergang von PoW zu PoS) überwunden hat, wird das gesamte Ökosystem zweifellos nach Lösungen für diese beispiellose Quantenbedrohung suchen und sich anpassen. Wir können auf eine Zukunft hoffen, in der die neue Weisheit der Menschheit in Form von Quantencomputern und die Vertrauenstechnologie dezentraler Ledger nicht durch eine Kollision zusammenbrechen, sondern auf einer höheren Ebene zu einem robusteren System verschmelzen.

Referenzen und weiterführende Links:

National Institute of Standards and Technology (NIST) - Post-Quantum Cryptography Standardization Project
Shor, P. W. (1994). Algorithms for quantum computation: discrete logarithms and factoring.
Grover, L. K. (1996). A fast quantum mechanical algorithm for database search.
Buterin, V. (2024). How to hard-fork to save most users’ funds in a quantum emergency.

Quanten-Annealing und Quantengatter-Modell im Vergleich leicht erklärt

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

Quanten-Annealing und Quantengatter-Modell im Vergleich leicht erklärt

Quantencomputing ist eine Rechentechnologie der nächsten Generation mit dem Potenzial, bestimmte Probleme, für die moderne klassische Computer (einschließlich herkömmlicher Supercomputer) enorm viel Rechenzeit benötigen würden, mithilfe quantenmechanischer Prinzipien (Superposition und Quantenverschränkung) drastisch schneller zu lösen.

Derzeit gibt es für die Realisierung von Quantencomputern im Wesentlichen zwei Mainstream-Paradigmen: “Quanten-Annealing” (Quantum Annealing) und das “Quantengatter-Modell” (Quantum Gate Model). Diese beiden Ansätze unterscheiden sich grundlegend in den zugrunde liegenden physikalischen Prinzipien, den bevorzugten Rechenaufgaben und den Hardware-Herausforderungen bei der Implementierung.

In diesem Artikel werden wir diese beiden Ansätze aus einer sehr detaillierten und technischen Perspektive umfassend vergleichen und erläutern – von den physikalischen Prinzipien und mathematischen Modellen (Ising-Modell, QUBO, unitäre Transformationen usw.) über die aktuellen technischen Grenzen bis hin zu konkreten Anwendungsfällen.

1. Grundlagen des Quantencomputings: Der fundamentale Unterschied zu klassischen Computern

Klassische Computer verarbeiten Informationen als “Bits”, die den Zustand “0” oder “1” annehmen. Quantencomputer hingegen verwenden “Quantenbits (Qubits)”. Durch das quantenmechanische Prinzip der “Superposition” (Überlagerung) können Qubits mit bestimmten Wahrscheinlichkeiten gleichzeitig die Zustände 0 und 1 annehmen.

Darüber hinaus sind durch das Phänomen der “Quantenverschränkung” (Entanglement) die Zustände mehrerer Qubits stark miteinander korreliert, sodass eine Operation an einem Qubit das gesamte System augenblicklich beeinflusst. Dies ermöglicht eine Art parallele Verarbeitung (Quantenparallelität).

Quantenzustände sind jedoch extrem anfällig für externes Rauschen (wie Wärme oder elektromagnetische Strahlung). Das Phänomen der “Dekohärenz” (Decoherence), bei dem der Zustand zusammenbricht und in einen klassischen Zustand zurückfällt, stellt eine große Herausforderung dar. Die unterschiedlichen Herangehensweisen an dieses Rauschproblem führen zu den großen Unterschieden in der Designphilosophie zwischen Annealing und dem Gatter-Modell.

2. Details zum Quanten-Annealing (Quantum Annealing)

Quanten-Annealing ist eine spezialisierte Rechenarchitektur, die hauptsächlich auf die Lösung von “kombinatorischen Optimierungsproblemen” zugeschnitten ist. Sie basiert auf der 1998 von Hidetoshi Nishimori und Tadashi Kadowaki (Tokyo Institute of Technology) vorgeschlagenen Theorie und wurde durch die weltweit erste kommerzielle Umsetzung des kanadischen Unternehmens D-Wave Systems weithin bekannt.

2.1. Physikalischer Mechanismus: Transversalfeld-Ising-Modell und Quantenfluktuation

Das Quanten-Annealing macht sich die Eigenschaft natürlicher physikalischer Systeme zunutze, sich in den Zustand mit der niedrigsten Energie (Grundzustand) einzupendeln.

Beim klassischen Ansatz, dem “Simulated Annealing”, werden thermische Fluktuationen genutzt, um aus lokalen Optima (lokalen Minima) zu entkommen. Das Quanten-Annealing nutzt stattdessen “Quantenfluktuationen” (Quantum Fluctuation) und durchdringt mittels des “Quanten-Tunneleffekts” (Quantum Tunneling) Energiebarrieren, um so effizienter nach dem globalen Optimum (globalen Minimum) zu suchen.

Die zeitliche Entwicklung eines Quanten-Annealing-Systems wird durch den folgenden Hamiltonoperator (ein Operator, der die Gesamtenergie des Systems darstellt) $H(t)$ beschrieben:

$$ H(t) = A(t) H_0 + B(t) H_P $$

Dabei ist $t$ die Zeit, $A(t)$ eine allmählich abnehmende Funktion und $B(t)$ eine allmählich zunehmende Funktion.

$H_0$ (Anfangs-Hamiltonoperator): Stellt das Transversalfeld (Transverse field) dar und erzeugt Quantenfluktuationen. $$ H_0 = - \sum_{i} \sigma_i^x $$ ($\sigma_i^x$ ist die Pauli-X-Matrix und repräsentiert einen Bit-Flip.)
$H_P$ (Problem-Hamiltonoperator): Ein Ising-Modell, das das zu lösende Optimierungsproblem repräsentiert.

Im Anfangszustand ($t=0$) ist $A(0)$ maximal, und das System befindet sich im Grundzustand von $H_0$ (ein Zustand, in dem alle möglichen Zustände gleichmäßig überlagert sind). Im Laufe der Zeit wird das Transversalfeld langsam abgeschwächt, während gleichzeitig die Wechselwirkungen des Problem-Hamiltonoperators verstärkt werden.

2.2. Adiabatisches Quantencomputing (Adiabatic Quantum Computation)

Wichtig bei diesem Prozess ist das “Adiabatentheorem” (Adiabatic Theorem). Nach diesem Theorem bleibt ein System, wenn es “langsam genug” (adiabatisch) verändert wird, stets im Grundzustand des jeweiligen momentanen Hamiltonoperators.

Das bedeutet, dass das System, wenn schließlich $A(t) \to 0$ und $B(t) \to 1$ erreicht ist, den Grundzustand von $H_P$ erreicht hat, d. h. die “exakte Lösung des Optimierungsproblems”.

graph TD A["Hamiltonoperator H_0 (Anfangszustand)"] -->|"Adiabatische Änderung (langsam genug)"| B["Bleibt stets im Grundzustand"] A -->|"Nicht-adiabatische Änderung (zu schnell/thermisches Rauschen)"| C["Übergang in angeregte Zustände (Fehler)"] B --> D["Hamiltonoperator H_P (Globales Optimum)"] C --> E["Gefangen in lokalem Optimum"] D --> F["Auslesen der Lösung"] E --> F

2.3. Mapping von QUBO auf das Ising-Modell

Um reale Probleme auf einem Quanten-Annealer zu lösen, muss das Problem in Form eines QUBO (Quadratic Unconstrained Binary Optimization) formuliert werden.

Die Zielfunktion eines QUBO ist wie folgt definiert:

$$ \min_{x \in \{0,1\}^n} \sum_{i} Q_{ii} x_i + \sum_{i < j} Q_{ij} x_i x_j $$

Hierbei ist $x_i \in \{0, 1\}$ eine binäre Variable und $Q$ eine Gewichtsmatrix.

Da die Hardware (wie D-Wave) mit physikalischen Spins (Spin-Up/Spin-Down) arbeitet, müssen die Variablen in ein Ising-Modell mit $\sigma_i \in \{-1, +1\}$ transformiert werden. Die Transformationsgleichung lautet:

$$ x_i = \frac{1 - \sigma_i}{2} \quad \text{oder} \quad \sigma_i = 1 - 2x_i $$

Setzt man dies in die QUBO-Gleichung ein und vereinfacht, erhält man den Hamiltonoperator $H_P$ des Ising-Modells:

$$ H_P = - \sum_{i

$J_{ij}$: Wechselwirkung zwischen Spins (Kopplungskoeffizient). Entspricht der Kopplungsstärke zwischen physikalischen Qubits.

$h_i$: Lokales Magnetfeld (Bias) für jeden Spin.

2.4. Hardware und Herausforderungen des Quanten-Annealings (Beispiel D-Wave)

Die Quantenprozessoren von D-Wave werden mithilfe von supraleitenden Quanteninterferenz-Einheiten (SQUIDs) realisiert. Die physikalische Kopplung zwischen Qubits hängt von der Hardware-Verkabelung ab und ist nicht vollständig (nicht alle Qubits sind miteinander verbunden). Ausgehend vom ursprünglichen “Chimera-Graphen” über den “Pegasus-Graphen” bis hin zum “Zephyr-Graphen” hat sich die Konnektivität zwar verbessert, bleibt aber eingeschränkt.

Daher ist ein “Minor Embedding” erforderlich, um Probleme mit komplexer Graphenstruktur auf den physikalischen Graphen abzubilden. Dabei wird eine logische Variable durch mehrere physikalische Qubits (Ketten) repräsentiert, was die Anzahl der nutzbaren effektiven Qubits verringert und zu einer Verringerung der Rechengenauigkeit führt.

3. Details zum Quantengatter-Modell (Quantum Gate Model)

Das Quantengatter-Modell ist eine quantenmechanische Erweiterung klassischer Logikgatter (AND, OR, NOT usw.) und ermöglicht “Universelles Quantencomputing” (Universal Quantum Computation). Viele Unternehmen wie IBM, Google, Rigetti und IonQ verfolgen diesen Ansatz.

3.1. Unitäre Transformationen und Zustandsvektor

Beim Quantengatter-Modell wird der Gesamtzustand des Qubit-Systems als “Zustandsvektor” (State Vector) $|\psi\rangle$ dargestellt. Der Zustand eines einzelnen Qubits wird als Linearkombination der Basiszustände $|0\rangle$ und $|1\rangle$ wie folgt beschrieben:

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

Hierbei sind $\alpha$ und $\beta$ komplexe Wahrscheinlichkeitsamplituden, für die $|\alpha|^2 + |\beta|^2 = 1$ gilt. Dieser Zustand wird geometrisch oft als Punkt auf der “Bloch-Kugel” (Bloch Sphere) veranschaulicht.

Rechenschritte im Quantencomputer werden als Anwendung eines unitären Operators (Unitary Operator) $U$ auf den Zustandsvektor beschrieben. Unitäre Matrizen haben die Eigenschaft $U^\dagger U = I$ (das Produkt mit der hermitesch konjugierten Matrix ergibt die Einheitsmatrix) und stellen umkehrbare Operationen dar, die der zeitlichen Entwicklung der Schrödingergleichung in der Quantenmechanik entsprechen:

$$ |\psi_{t+1}\rangle = U_t |\psi_t\rangle $$

3.2. Grundlegende Quantengatter und das Schaltkreismodell

Quantenalgorithmen werden als eine Abfolge von Quantengattern (Quantenschaltkreis) entworfen.

Pauli-Gatter (X, Y, Z): 180-Grad-Rotationen um die jeweiligen Achsen der Bloch-Kugel. Das X-Gatter entspricht dem klassischen NOT-Gatter.
Hadamard-Gatter (H): Überführt $|0\rangle$ in $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$ und erzeugt so einen Superpositionszustand. $$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$
CNOT-Gatter (Controlled-NOT): Ein 2-Qubit-Gatter. Es wendet das X-Gatter nur dann auf das Ziel-Qubit an, wenn das Kontroll-Qubit $|1\rangle$ ist. Dadurch wird Quantenverschränkung (Entanglement) erzeugt.

Jeder Quantenalgorithmus kann näherungsweise durch eine Kombination aus wenigen Einzel-Qubit-Gattern und CNOT-Gattern dargestellt werden (universelles Gatter-Set).

graph LR Q0["Qubit 0: |0>"] --> H1["Hadamard-Gatter (H)"] Q1["Qubit 1: |0>"] --> I1["Identitätsoperation (I)"] H1 --> C1["Kontroll-Qubit (Control)"] I1 --> T1["Ziel-Qubit (Target)"] C1 -. "Verschränkung" .- T1 C1 --> M0["Messung (Measurement)"] T1 --> M1["Messung (Measurement)"] M0 --> Result["Klassisches Ergebnis (0 oder 1)"] M1 --> Result

3.3. Fehlerkorrektur und der Weg von NISQ zu FTQC

Die größte Herausforderung des Quantengatter-Modells ist die “Dekohärenz”, bei der der Quantenzustand durch Rauschen zerstört wird. Je tiefer die Rechenschritte (Gattertiefe), desto mehr Fehler akkumulieren sich.

Für ideale Berechnungen ist eine Quantenfehlerkorrektur (Quantum Error Correction) unerlässlich. Bei Methoden wie dem “Surface Code” werden beispielsweise mehrere physikalische Qubits gebündelt, um ein fehlerfreies “logisches Qubit” (Logical Qubit) zu bilden. Um jedoch ein einziges logisches Qubit zu erzeugen, werden Tausende bis Zehntausende physikalische Qubits benötigt, was zu einem enormen Overhead führt.

Wir befinden uns derzeit in der Ära der NISQ (Noisy Intermediate-Scale Quantum) Geräte, die über Dutzende bis Hunderte von Qubits ohne Fehlerkorrektur verfügen. Die Realisierung von FTQC (Fault-Tolerant Quantum Computing), das vollständige Fehlerkorrektur bietet, erfordert noch viele Durchbrüche.

4. Zusammenfassung des technischen und mathematischen Vergleichs

Vergleich der grundlegenden Unterschiede beider Architekturen:

Vergleichsmerkmal	Quanten-Annealing (Quantum Annealing)	Quantengatter-Modell (Gate Model)
Rechenmodell	Adiabatisches Quantencomputing (Kontinuierliche zeitliche Entwicklung des Hamiltonoperators)	Unitäre Transformation (Diskrete Abfolge von Gatteroperationen)
Geeignete Probleme	Kombinatorische Optimierungsprobleme (QUBO, Ising-Modell)	Universell (Quantenchemiesimulation, Primfaktorzerlegung, Suche usw.)
Ausdruckskraft	Heuristische Optimierung (Näherungslösungen)	Äquivalent zu einer universellen Quantenturingmaschine (theoretisch alle Berechnungen möglich)
Implementierungsbeispiele	D-Wave Systems	IBM, Google, Quantinuum, IonQ usw.
Toleranz gegenüber Rauschen	Relativ robust (da es nahe dem Grundzustand bleibt, ist ein gewisses Maß an thermischem Rauschen tolerierbar)	Sehr anfällig (geringes Rauschen verschiebt die Phase und zerstört das Rechenergebnis)
Skalierbarkeit	Tausende bis Zehntausende Qubits (abhängig von der physikalischen Struktur; logische Qubits schwer umsetzbar)	Hunderte Qubits (für FTQC sind Millionen erforderlich)

Das Quanten-Annealing eignet sich als “zweckspezifischer Coprozessor”, um kombinatorische Optimierungsprobleme zu lösen und so die Grenzen klassischer Computer zu ergänzen. Das Quantengatter-Modell hingegen ist die Quantenversion des “Allzweckrechners” und zielt darauf ab, die Rechenleistung klassischer Computer letztendlich zu übertreffen (Quantenüberlegenheit), jedoch ist der Bau der Hardware extrem schwierig.

5. Aktuelle Grenzen und Herausforderungen

Grenzen des Quanten-Annealings

Eingeschränkte Konnektivität (Connectivity): Durch das zuvor erwähnte Minor Embedding steigt die Anzahl der benötigten physikalischen Qubits mit der Problemgröße exponentiell an.
Präzision der Koeffizienten (Precision): Physikalische Fehler beim Einstellen analoger Parameter wie $J_{ij}$ und $h_i$ auf der Hardware wirken sich direkt auf die Qualität der Lösung aus.
Temperatur und nicht-adiabatische Übergänge: Da die Systemtemperatur nicht am absoluten Nullpunkt liegt, besteht die Wahrscheinlichkeit, dass thermische Anregungen das System vom optimalen Zustand abbringen.

Grenzen des Quantengatter-Modells

Kohärenzzeit (Coherence Time): Die Zeit, in der ein Quantenzustand aufrechterhalten werden kann, liegt nur im Bereich von Mikrosekunden bis Millisekunden, was die Anzahl der in dieser Zeit ausführbaren Gatter (Tiefe des Schaltkreises) stark begrenzt.
Gatter-Fidelität (Gate Fidelity): Die Fehlerrate von 2-Qubit-Gattern (wie CNOT) ist noch nicht niedrig genug (im Allgemeinen etwa 99,x %). Für die Realisierung von FTQC muss diese auf über 99,99 % gesteigert werden.
Quantenvolumen (Quantum Volume): Die Skalierung nicht nur der bloßen Qubit-Anzahl, sondern der effektiven Rechenleistung (Quantenvolumen) unter Berücksichtigung von Vernetzung und Fehlerraten ist derzeit die größte Herausforderung.

6. Konkrete Anwendungsfälle und Algorithmen

Betrachten wir die spezifischen Anwendungsbereiche, in denen jede der beiden Methoden ihre Stärken hat.

6.1. Anwendungsfälle des Quanten-Annealings

Logistik und Routing: Routenoptimierung für Lieferfahrzeuge (Varianten des Problems des Handlungsreisenden). Echtzeit-Routenfindung unter Berücksichtigung von Verkehrsstaus.
Finanzmathematik: Portfoliooptimierung. Finden von Anlagekombinationen, die das Risiko minimieren und gleichzeitig die Rendite maximieren.
Maschinelles Lernen: Feature Selection. Auswahl der Variablenkombinationen aus riesigen Datensätzen, die am meisten zur Vorhersage beitragen.
Fertigungsindustrie: Job-Shop-Scheduling-Probleme in Fabriken (welches Bauteil soll auf welcher Maschine in welcher Reihenfolge am schnellsten bearbeitet werden).

6.2. Anwendungsfälle des Quantengatter-Modells

Quantenchemiesimulation: Hochpräzise Simulation von molekularen Energiezuständen und chemischen Reaktionen.
Primfaktorzerlegung (Shor-Algorithmus): Ein Algorithmus zur Zerlegung riesiger zusammengesetzter Zahlen in Polynomzeit. Wenn dieser praxistauglich wird, könnte er heutige Public-Key-Infrastrukturen wie RSA brechen, weshalb der Übergang zur Post-Quanten-Kryptographie (PQC) dringlich ist.
Datenbanksuche (Grover-Algorithmus): Bei der Suche nach bestimmten Daten in einer unsortierten Datenbank benötigen klassische Computer $O(N)$ Schritte, während der Grover-Algorithmus dies in $O(\sqrt{N})$ Schritten schafft.

6.3. Hybrid-Algorithmen der NISQ-Ära: VQE und QAOA

Um die Einschränkungen der flachen Quantenschaltkreise von NISQ-Geräten zu überwinden, gewinnen “Variationelle Quantenalgorithmen” (Variational Quantum Algorithms) an Bedeutung, die die Vorteile von Quanten- und klassischen Computern kombinieren.

VQE (Variational Quantum Eigensolver): Ein Algorithmus zur Bestimmung der Grundzustandsenergie von Molekülen. Er verwendet einen parametrisierten Quantenschaltkreis (Ansatz), um einen Quantenzustand vorzubereiten, und misst den Energieerwartungswert $\langle \psi(\theta) | H | \psi(\theta) \rangle$. Dieser Erwartungswert wird als Zielfunktion verwendet, um die Parameter $\theta$ mithilfe eines klassischen Optimierungsalgorithmus (wie Gradientenabstieg) zu aktualisieren. Durch Wiederholung bis zur Konvergenz wird der exakte Energiezustand des Moleküls ermittelt.
QAOA (Quantum Approximate Optimization Algorithm): Ein Algorithmus zur Lösung von kombinatorischen Optimierungsproblemen mithilfe des Quantengatter-Modells. Er approximiert die adiabatische zeitliche Entwicklung des Quanten-Annealings durch diskrete Gatteroperationen mittels “Trotterisierung” (Trotterization) und wendet abwechselnd Hamiltonoperatoren an, um eine Näherungslösung zu erhalten. QAOA gilt als vielversprechender Ansatz zur Lösung von Optimierungsproblemen mit dem Gatter-Modell.

graph TD User["Benutzerproblem"] --> Formulation{"Art des Problems"} Formulation -- "Kombinatorische Optimierung" --> QA_Path["Quanten-Annealing / Ising-Maschine"] QA_Path --> QUBO["QUBO-Formulierung"] QUBO --> DWave["Ausführung auf D-Wave"] Formulation -- "Chemieberechnungen / Universelle Berechnungen" --> Gate_Path["Quantengatter-Modell"] Gate_Path --> Circuit["Schaltkreisentwurf (VQE / QAOA)"] Circuit --> IBMGoogle["Ausführung auf IBM / Google Quantenhardware"]

7. Fazit

Obwohl Quanten-Annealing und das Quantengatter-Modell beide auf den faszinierenden Eigenschaften der Quantenmechanik als Rechenressource basieren, unterscheiden sie sich stark in ihrem Ansatz und ihren Zielen.

Das Quanten-Annealing ist eine “spezialisierte heuristische Engine”, die darauf abzielt, frühzeitig praktische Ergebnisse für spezifische reale Probleme wie die kombinatorische Optimierung zu liefern. Zahlreiche Unternehmen führen derzeit bereits Proof-of-Concept-Projekte (PoC) durch.
Das Quantengatter-Modell ist der “universelle Quantencomputer” mit dem Potenzial, Paradigmen der Informatik grundlegend zu verändern – von exakten physikalischen und chemischen Simulationen bis hin zur Entschlüsselung. Die Überwindung der gewaltigen Hürde der Fehlerkorrektur erfordert jedoch langfristige Forschung und Entwicklung.

Es wird erwartet, dass in Zukunft “heterogene (Heterogeneous) Computing”-Umgebungen entstehen, in denen klassische Supercomputer (HPC) den Kern bilden und je nach Aufgabe Annealing-Maschinen für Optimierungen oder gatterbasierte Quantencomputer für quantenchemische Berechnungen hinzugezogen werden.

Quantencomputer befinden sich noch in der Entwicklungsphase, doch sowohl bei der Hardware als auch bei den Algorithmen werden täglich schnelle Fortschritte erzielt. Das Verständnis der Mathematik von Ising-Modellen und der Grundlagen von Quantenschaltkreisen wird eine mächtige Waffe für die bevorstehende Quanten-Native-Ära sein.

Dieser Artikel bietet einen umfassenden Überblick von den grundlegenden Konzepten des Quantencomputings bis hin zu den neuesten Hardwaretrends. Bitte verfolgen Sie auch in Zukunft die neuesten Forschungsentwicklungen.

Schors Algorithmus mit Python simuliert

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

1. Einführung: Die kryptographische Krise durch Quantencomputer

Ein Großteil der Sicherheit in der modernen Internetgesellschaft hängt von Public-Key-Kryptographie (insbesondere RSA-Verschlüsselung) ab. Wenn wir beim Online-Shopping Kreditkarteninformationen senden oder hochsensible Daten austauschen, wird der Inhalt dieser Kommunikation stark durch RSA-Kryptographie geschützt.

Die Sicherheit der RSA-Verschlüsselung beruht auf der mathematischen Tatsache, dass “die Primfaktorzerlegung riesiger ganzer Zahlen für klassische Computer (die PCs und Supercomputer, die wir normalerweise verwenden) extrem schwierig ist”. Der 1994 von Peter Shor vorgestellte “Shor-Algorithmus (Shor’s Algorithm)” stellte diese Prämisse jedoch grundlegend in Frage. Es wurde mathematisch bewiesen, dass der Shor-Algorithmus, wenn er auf einem großen Quantencomputer ausgeführt wird, die Primfaktorzerlegung, für die klassische Computer länger als das Alter des Universums benötigen würden, in nur wenigen Minuten bis Stunden lösen kann.

In diesem Artikel werden wir ausführlich im Detail erklären, wie dieser Shor-Algorithmus eine schnelle Primfaktorzerlegung durchführt, von seinem mathematischen Mechanismus bis hin zu einer konkreten Simulationsimplementierung mit Python und dem Quanten-Computing-Framework Qiskit.

2. Dramatische Änderung der Komplexität: Von exponentieller zu polynomieller Zeit

Warum ist die Primfaktorzerlegung so schwierig? Selbst mit dem “Zahlkörpersieb (General Number Field Sieve, GNFS)”, das als bester Primfaktorzerlegungsalgorithmus für klassische Computer bekannt ist, ist die zeitliche Komplexität subexponentiell.

Die Zeitkomplexität zur Primfaktorzerlegung einer zusammengesetzten Zahl mit $N$ Ziffern bei Verwendung klassischer Methoden ist wie folgt:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Daher würde allein durch die Verlängerung der Schlüssellänge (z. B. auf 2048 Bit oder 4096 Bit) die Entschlüsselung auf einem klassischen Computer eine unrealistische Zeit wie Jahrtausende oder Zehntausende von Jahren in Anspruch nehmen.

Wenn jedoch der Shor-Algorithmus auf einem Quantencomputer verwendet wird, reduziert sich die zeitliche Komplexität dramatisch auf polynomielle Zeit in Bezug auf die Anzahl der Eingabebits $\log N$.

$$ O((\log N)^3) $$

Dies bedeutet, dass sich bei einer Verdoppelung der Bitzahl die Rechenzeit für einen klassischen Computer astronomisch erhöht, während sie für einen Quantencomputer höchstens um das Achtfache steigt. Diese Reduzierung der Komplexitätsklasse von exponentieller auf polynomielle Zeit (Aufnahme in die BQP-Klasse) ist die wahre Genialität von Shors Algorithmus.

graph TD A["Erhöhung der Eingabegröße (Anzahl der Bits) N"] --> B{"Wahl des Algorithmus"} B -->|Klassisch: Zahlkörpersieb| C["Subexponentielle Erhöhung O(exp(...))"] B -->|Quanten: Shors Algorithmus| D["Polynomielle Zeit O((log N)^3)"] C --> E["Jahrtausende bis Milliarden von Jahren (unentschlüsselbar)"] D --> F["Wenige Minuten bis Stunden (Entschlüsselung in realistischer Zeit)"]

3. Gesamtbild des Algorithmus und mathematischer Hintergrund

Beim Shor-Algorithmus wird nicht alles auf einem Quantencomputer ausgeführt. Er basiert auf der Zusammenarbeit zwischen Vorverarbeitung/Nachbearbeitung durch klassische Computer und dem Kernteil (Periodenfindungsalgorithmus) durch Quantencomputer.

Der Gesamtablauf des Algorithmus ist wie folgt:

graph TD A["Eingabe: Zusammengesetzte Zahl N, die faktorisiert werden soll"] --> B["Wähle Zufallszahl a, sodass a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["Gibt den trivialen Faktor gcd(a, N) aus und beendet"] C -- "No" --> E["Finde Periode r von f(x) = a^x mod N mit Quantenalgorithmus"] E --> F{"Ist r gerade und a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["Berechne Faktoren p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Ausgabe: p, q"]

Reduktion der Primfaktorzerlegung auf das Periodenfindungsproblem

Shors geniale Idee bestand darin, das “Primfaktorzerlegungsproblem” in das “Periodenfindungsproblem (Order Finding Problem)” umzuwandeln.

Betrachten wir die ganze Zahl $N$ (die zu faktorisierende Zahl) und eine teilerfremde ganze Zahl $a$ ($1 < a < N$). Wir definieren die folgende modulare Exponentialfunktion:

$$ f(x) = a^x \bmod N $$

Diese Funktion hat eine bestimmte Periode $r$. Das heißt, für jedes $x$ gilt $f(x+r) = f(x)$. Insbesondere wenn $x=0$, nennt man die kleinste positive ganze Zahl $r$, die

$$ a^r \equiv 1 \pmod N $$

erfüllt, die “Ordnung von $a$ modulo $N$ (Order)”. Wenn wir diese Periode $r$ finden können, können wir die Primfaktoren wie folgt ableiten.

Wenn wir die Formel umstellen, erhalten wir:

$$ a^r - 1 \equiv 0 \pmod N $$

Wenn $r$ gerade ist, kann dies mit der binomischen Formel (Differenz von Quadraten) faktorisiert werden.

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Dies bedeutet, dass $N$ einen gemeinsamen Teiler mit entweder $(a^{r/2} - 1)$ oder $(a^{r/2} + 1)$ hat (unter der Bedingung, dass $a^{r/2} \not\equiv -1 \pmod N$). Durch Anwendung des euklidischen Algorithmus zur Berechnung von

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

können wir die nichttrivialen Primfaktoren $p, q$ von $N$ finden. Diese Berechnungen (Berechnung des größten gemeinsamen Teilers und Generierung von Zufallszahlen) können von klassischen Computern sehr schnell durchgeführt werden. Das Problem beschränkt sich also auf die Frage, wie man die Periode $r$ schnell finden kann. Auf klassischen Computern erfordert das Finden dieser Periode $r$ selbst exponentielle Zeit. Hier kommt der Quantencomputer ins Spiel.

4. Quantenalgorithmus-Teil: Wie die Periodenfindung funktioniert

Die Subroutine zum Finden der Periode $r$ mithilfe eines Quantencomputers besteht aus den folgenden 4 Schritten:

graph LR subgraph "Übergänge der Quantenzustände" S1["|0⟩|0⟩ (Initialisierung)"] --> S2["H-Gate: Superposition Σ|x⟩|0⟩"] S2 --> S3["Orakel U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Periodenextraktion durch Interferenz"] S4 --> S5["Messung: Erhalt des Näherungswertes y"] end

Schritt 1: Initialisierung und Superposition der Quantenregister

Zunächst bereiten wir zwei Quantenregister vor. Das erste Register dient zur Eingabe des Zustands und das zweite zur Speicherung der Ergebnisse der Funktionsberechnung. Der Anfangszustand ist überall $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Wir wenden ein Hadamard-Gatter (Hadamard Gate) auf alle Qubits im ersten Register an, um einen Zustand gleicher Wahrscheinlichkeits-Superposition für alle möglichen Eingaben $x$ (von $0$ bis $Q-1$, mit $Q=2^n$) zu erzeugen.

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

Dadurch kann der Quantencomputer mit einer einzigen Operation Zustände für alle $Q$ Eingaben gleichzeitig speichern. Dies ist die mächtige Quelle der Quantenparallelität.

Schritt 2: Anwendung der Orakelfunktion (Modulare Exponentiation)

Als Nächstes verwenden wir die Quantenschaltung $U_f$, um die Funktion $f(x) = a^x \bmod N$ zu berechnen und das Ergebnis im zweiten Register zu speichern.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

Zu diesem Zeitpunkt befinden sich das erste und zweite Register in einem Zustand der Quantenverschränkung (Entanglement). Wenn wir (hypothetisch) das zweite Register beobachten und einen bestimmten Wert $k = a^{x_0} \bmod N$ erhalten, kollabiert der Zustand des ersten Registers in eine Superposition derjenigen $x$, die diesen Wert $k$ ergeben. Da die Funktion die Periode $r$ hat, sind die verbleibenden Zustände im Abstand $r$, wie $x_0, x_0+r, x_0+2r, \dots$.

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Wir wollen jedoch nicht $x_0$ wissen, sondern die Periode $r$ selbst. Es ist unmöglich, $r$ direkt aus diesem Zustand zu beobachten. Daher verwenden wir die Quanten-Fouriertransformation.

Schritt 3: Phaseninterferenz durch Quanten-Fouriertransformation (QFT)

Wir wenden die Quanten-Fouriertransformation (Quantum Fourier Transform, QFT) auf das erste Register an. Die QFT ist die Quantenversion der klassischen diskreten Fouriertransformation und transformiert die Amplituden von Zustandsvektoren. Die Wirkung der QFT auf den Basiszustand $|x\rangle$ ist wie folgt definiert:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Wobei $\omega = e^{2\pi i / Q}$.

Wenn die QFT angewendet wird, interferieren die Amplituden der Zustände. Ohne auf mathematische Details einzugehen: Wenn QFT auf einen Zustand mit Periode $r$ angewendet wird, verursachen die Wellen nur dann eine konstruktive Interferenz (Constructive Interference), wenn $y$ extrem nahe an einem ganzzahligen Vielfachen von $Q/r$ liegt. Für andere Zustände heben sich die Wahrscheinlichkeitsamplituden aufgrund von destruktiver Interferenz (Destructive Interference) gegenseitig auf und nähern sich Null.

Schritt 4: Messung und Kettenbruchentwicklung

Schließlich messen wir das erste Register. Der durch die Messung erhaltene Wert $y$ erfüllt mit hoher Wahrscheinlichkeit folgende Bedingung:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ ist eine unbekannte ganze Zahl mit $0 \le c < r$)

Durch Anwendung der Kettenbruchentwicklung (Continued Fraction Expansion), einem klassischen Algorithmus, auf die erhaltene rationale Zahl $y/Q$ berechnen wir den Näherungsbruch $c/r$ und extrahieren die Periode $r$ aus dem Nenner.

5. Simulationsimplementierung mit Python und Qiskit

Da Theorie allein schwer greifbar ist, simulieren wir Shors Algorithmus tatsächlich mit Python und Qiskit, dem Quanten-Computing-Framework von IBM.

Hier implementieren wir das klassischste und bekannteste Beispiel-Szenario: “Faktorisierung von $N=15$ unter Verwendung von $a=7$”.

Vorbereitung der Ausführungsumgebung

Bitte installieren Sie Qiskit im Voraus.

1

pip install qiskit qiskit-aer numpy

Übersicht über den Python-Implementierungscode

Der folgende Code ist ein Implementierungsbeispiel von Shors Algorithmus, der auf $N=15, a=7$ spezialisiert ist. Da der Aufbau einer universellen modularen Exponentiationsschaltung auf aktuellen Simulatoren zu rechenintensiv ist, sind die Gatteroperationen für den spezifischen Fall von $a=7$ hartcodiert.

 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
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Funktion zum Aufbau der inversen Quanten-Fouriertransformation (QFT†)
def qft_dagger(n):
 """Generiert eine inverse Quanten-Fouriertransformationsschaltung für n Qubits"""
 qc = QuantumCircuit(n)
 # SWAP-Gatter zur Umkehrung der Reihenfolge
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Anwendung von kontrollierten Phasengattern und H-Gattern
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Funktion zum Aufbau der kontrollierten modularen Exponentiation für 7^x mod 15
def c_amod15(a, power):
 """Generiert ein kontrolliertes U-Gatter für ein spezifisches a und eine Potenz (nur für N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Hartcodierte Logik für 7^x mod 15, wenn a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Aufbau der Haupt-Quantenschaltung
def shor_circuit(a, n_count):
 # n_count: Anzahl der Bits im Kontrollregister
 # Das Zielregister hat 4 Bits, um 0 bis 15 darzustellen
 qc = QuantumCircuit(n_count + 4, n_count)

 # Initialisierung des 1. Registers (Kontrollregister) (Erzeugung der Superposition)
 for q in range(n_count):
 qc.h(q)

 # Initialisierung des 2. Registers (Zielregister) auf |1> (0001)
 qc.x(3 + n_count)

 # Anwendung der kontrollierten modularen Exponentiation (Orakel)
 for q in range(n_count):
 # Anwendung der 2^q-ten Potenz-Operation
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Anwendung der inversen Quanten-Fouriertransformation auf das 1. Register
 qc.append(qft_dagger(n_count), range(n_count))

 # Messung des 1. Registers
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Ausführungsbereich ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Verwendung von 8 Qubits für das Kontrollregister (Q=256)

 print(f"Sucheinstellungen: N={N}, a={a}, Anzahl Kontroll-Qubits={n_count}")

 # Generierung der Schaltung
 qc = shor_circuit(a, n_count)

 # Ausführung im Simulator
 sim = AerSimulator()
 # In der neuesten Version von Qiskit wird transpile empfohlen
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nMessergebnis (Bitfolge: Anzahl der Beobachtungen):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} Mal")

 # Klassische Nachbearbeitung: Identifizierung der Periode r durch Kettenbruchentwicklung
 print("\n--- Berechnung der Periode und Primfaktorzerlegung ---")
 phases = []
 for output in counts:
 # Umwandlung der Bitfolge in eine Dezimalzahl
 decimal = int(output, 2)
 # Phase = Messwert / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Erhalt des Näherungsbruchs durch Kettenbruchentwicklung. Die Obergrenze des Nenners ist N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Beobachteter Wert: {decimal:3d} | Phase: {phase:.4f} | Kettenbruch: {frac} | Geschätzte Periode r = {r}")

 # Überprüfen, ob Periode r gerade ist und ein gültiges Ergebnis liefert
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Erfolgreich! Die Primfaktoren von {N} sind {guess1} und {guess2}.")
 else:
 print(f" => Nur triviale Faktoren. Noch einmal versuchen.")
 else:
 print(f" => Fehlgeschlagen, da die Periode ungerade ist.")

Code-Erklärung und Analyse der Ausführungsergebnisse

Wenn Sie den obigen Code ausführen, erhalten Sie mit hoher Wahrscheinlichkeit bestimmte Peaks (Beobachtungswerte) als Messergebnis des Kontrollregisters. Für n_count=8 ($Q=256$) treten bei einem idealen Quantencomputer (oder Simulator) Werte wie 0, 64, 128, 192 mit überwältigender Wahrscheinlichkeit auf.

Teilt man diese durch $Q=256$, erhält man die Phasen $y/Q$ als $0.0$, $0.25$, $0.5$, bzw. $0.75$. Wendet man auf diese Phasen die Kettenbruchentwicklung an:

$0.25 \to 1/4$ (Geschätzte Periode $r=4$)
$0.50 \to 1/2$ (Geschätzte Periode $r=2$)
$0.75 \to 3/4$ (Geschätzte Periode $r=4$)

Mit der hier erhaltenen Periode $r=4$ berechnen wir die Primfaktoren. Da $a=7, r=4$, gilt: $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Wir haben erfolgreich die Primfaktorzerlegung $15 = 3 \times 5$ durchgeführt.

[!TIP] Wenn der Messwert $y=128$ (Phase $0.5$) erhalten wird, ist der Nenner $2$, und wir erhalten einen Teiler anstelle der wahren Periode $r=4$. In solchen Fällen können wir die wahre Periode finden, indem wir den Algorithmus mehrmals ausführen oder Vielfache der erhaltenen $r$ untersuchen.

6. Herausforderungen für die praktische Anwendung und die Grenzen der NISQ-Ära

Obwohl es einfach war, $N=15$ auf einem Simulator zu faktorisieren, gibt es für reale Quantencomputer noch viele Hürden, um RSA-2048 (eine 617-stellige Dezimalzahl), wie es in der realen Welt verwendet wird, zu faktorisieren.

Die Ära, in der wir derzeit leben, wird als NISQ-Ära (Noisy Intermediate-Scale Quantum: verrauschtes, mittelgroßes Quanten-Computing) bezeichnet. Qubits sind extrem anfällig für Umgebungsrauschen und unterliegen während der Berechnungen der “Dekohärenz”, wodurch ihre Zustände zerstört werden.

Um tiefe Schaltungen (mit vielen Gattern) wie Shors Algorithmus fehlerfrei auszuführen, ist eine Quantenfehlerkorrektur (Quantum Error Correction) unerlässlich, um das Rauschen zu korrigieren. Um ein rauschfreies “logisches Qubit” zu erzeugen, müssen Tausende von “physischen Qubits” mit Verfahren wie dem Surface Code codiert werden.

Um eine 2048-Bit-RSA-Verschlüsselung zu knacken, werden Tausende von perfekten logischen Qubits benötigt. Schätzungen zufolge ist dafür ein fehlertoleranter Quantencomputer mit Millionen bis zig Millionen physischen Qubits erforderlich. Da selbst die modernsten heutigen Quantenprozessoren nur über einige Hundert bis Tausend physische Qubits verfügen, werden die Verschlüsselungen der Welt nicht unmittelbar morgen geknackt.

[!WARNING] Es gibt jedoch ein Bedrohungsmodell namens “Store Now, Decrypt Later (Jetzt speichern, später entschlüsseln)”. Angreifer könnten große Mengen der aktuell verschlüsselten vertraulichen Kommunikation in verschlüsselter Form speichern und die Strategie verfolgen, alles zu entschlüsseln, sobald in 10 bis 20 Jahren ein leistungsstarker Quantencomputer gebaut ist.

7. Übergang zur Post-Quanten-Kryptographie (PQC)

In Vorbereitung auf die Ankunft eines solchen “Q-Day (der Tag, an dem Quantencomputer Verschlüsselungen knacken)” standardisieren Kryptographen weltweit, allen voran das amerikanische National Institute of Standards and Technology (NIST), die Post-Quanten-Kryptographie (Post-Quantum Cryptography, PQC).

PQC basiert auf neuen mathematischen Problemen (Gitterprobleme, multivariate Polynome, hashbasiert usw.), von denen mathematisch angenommen wird, dass sie selbst mit Shors Algorithmus (oder Grovers Algorithmus) nicht effizient lösbar sind. Algorithmen wie “CRYSTALS-Kyber” und “CRYSTALS-Dilithium” wurden bereits als Standard ausgewählt und schrittweise in Apples iMessage und verschiedene Webbrowser-Kommunikationsprotokolle eingeführt.

Für Ingenieure, die IT-Infrastrukturen verwalten, wird der Einbau von “Crypto-Agility (Krypto-Agilität: das Design zum schnellen Wechseln von Verschlüsselungsmethoden)” von bestehenden RSA- oder elliptischen Kurven zu PQC eine wichtige zukünftige Aufgabe sein.

8. Fazit

In diesem Artikel haben wir eine umfassende Erklärung im Umfang von etwa 10.000 Zeichen geliefert, beginnend mit dem theoretischen mathematischen Hintergrund des Shor-Algorithmus, über den Mechanismus der Periodenextraktion mittels der Quanten-Fouriertransformation, bis hin zu spezifischem Simulationscode mit Python und Qiskit.

Die Tatsache, dass die physikalischen Gesetze der mikroskopischen Welt der Quantenmechanik die Grundlagen der Komplexitätstheorie und der Kryptographietheorie, die die Grundlagen der makroskopischen Informationswissenschaft bilden, komplett umstürzen können, ist einer der aufregendsten Paradigmenwechsel in der Geschichte der Wissenschaft. Es bleibt spannend, die anhaltende technologische Entwicklung der Quantencomputer und die Abwehrschlacht durch neue Verschlüsselungstechnologien weiter zu beobachten.

Wir ermutigen Sie, den hier vorgestellten Python-Code in Ihrer eigenen Umgebung auszuführen und die “Magie der Berechnung” zu erleben, die durch die Superposition und Interferenz von Quantenzuständen entsteht.

Referenzen

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【Grafik PQC】Vergleich der wichtigsten Algorithmen für die Post-Quanten-Kryptographie

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

1. Einleitung: Die “Krise der Kryptographie” durch Quantencomputer

In der modernen Internetgesellschaft ist die Public-Key-Kryptographie eine unverzichtbare Infrastruktur zum Schutz der Vertraulichkeit von Kommunikation und der Datenintegrität. Die derzeit weit verbreiteten RSA- und Elliptische-Kurven-Kryptographie (ECC) stützen sich für ihre Sicherheit auf mathematische Hürden, nämlich die “Schwierigkeit der Primfaktorzerlegung riesiger zusammengesetzter Zahlen” und die “Schwierigkeit des diskreten Logarithmusproblems auf elliptischen Kurven”. Es wurde bewiesen, dass klassische Computer (die Computer, die wir heute benutzen, einschließlich Supercomputern) länger als das Alter des Universums bräuchten, um diese mathematischen Probleme zu lösen, was die Grundlage für ihre Sicherheit darstellte.

Diese robuste Annahme wird jedoch durch Fortschritte in der Theorie und praktischen Anwendung von Quantencomputern grundlegend auf den Kopf gestellt. Der “Shor-Algorithmus”, der 1994 von dem Kryptographen Peter Shor vorgestellt wurde, bewies theoretisch, dass sowohl das Primfaktorzerlegungsproblem als auch das Problem des diskreten Logarithmus in “polynomieller Zeit” entschlüsselt werden können, wenn er auf einem ausreichend leistungsfähigen, fehlertoleranten universellen Quantencomputer (CRQC: Cryptographically Relevant Quantum Computer) ausgeführt wird. Das bedeutet, dass alle derzeit verwendeten Public-Key-Kryptographien unwirksam werden.

graph TD A["Großer Quantencomputer (CRQC)"] -->|Ausführung| B["Shor-Algorithmus"] B -->|Entschlüsselung in polynomieller Zeit| C["Primfaktorzerlegungsproblem (RSA)"] B -->|Entschlüsselung in polynomieller Zeit| D["Diskretes Logarithmusproblem (ECC / ECDSA)"] C --> E["Abhören verschlüsselter Kommunikation, Datenmanipulation, Spoofing"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

Es ist sehr gefährlich zu denken: “Die vollständige Fertigstellung von Quantencomputern liegt noch Jahrzehnte in der Zukunft, also ist es kein Problem”. Denn eine Angriffsmethode namens Store Now, Decrypt Later (SNDL) stellt bereits eine reale Bedrohung dar. Bei diesem Angriff speichern böswillige Staaten oder Hackerorganisationen große Mengen der derzeit verschlüsselten Kommunikationsdaten (wie TLS-Traffic) und entschlüsseln sie alle in dem Moment, in dem in Zukunft ein leistungsstarker Quantencomputer verfügbar wird. Staatsgeheimnisse, Infrastrukturinformationen und medizinische Daten, die über lange Zeiträume geschützt werden müssen, sind dieser Bedrohung bereits ausgesetzt.

Für symmetrische Schlüsselkryptographie (wie AES) und Hash-Funktionen (wie SHA-256) existiert zudem der 1996 entdeckte Grover-Algorithmus. Dieser reduziert den Rechenaufwand für Brute-Force-Angriffe auf die Quadratwurzel. Mit anderen Worten, das Sicherheitsniveau von AES-128 wird effektiv auf 2 hoch 64 halbiert. Im Quantenzeitalter wird daher die Verwendung längerer Schlüssel und Hash-Längen wie AES-256 und SHA-384 empfohlen.

Um dieser beispiellosen Kryptographie-Krise zu begegnen, wurde die Post-Quanten-Kryptographie (Post-Quantum Cryptography: PQC) entwickelt, die auf neuen mathematischen Problemen basiert, welche auch mit Quantencomputern schwer zu lösen sind. Basierend auf den Ergebnissen des vom National Institute of Standards and Technology (NIST) der USA geleiteten PQC-Standardisierungsprozesses erläutert dieser Artikel detailliert die wichtigsten PQC-Algorithmen, von ihren mathematischen Hintergründen über ihre Mechanismen bis hin zu Architekturvergleichen.

2. Der PQC-Standardisierungsprozess von NIST: Gesamtbild und Geschichte

Der Übergang zu neuen Kryptographietechnologien, der die Neugestaltung von Protokollen, Systemaktualisierungen und den Austausch von Hardware umfasst, dauert Jahre bis Jahrzehnte. Daher haben Kryptographen auf der ganzen Welt frühzeitig die Erforschung von PQC vorangetrieben. Eine zentrale Rolle hat dabei das US-amerikanische NIST (National Institute of Standards and Technology) gespielt. Im Jahr 2016 rief NIST den PQC-Standardisierungsprozess aus und nahm Vorschläge für völlig neue kryptographische Algorithmen aus der weltweiten Kryptographie-Community entgegen.

Gegenstand der Standardisierung waren die folgenden zwei Hauptkategorien:

Public-Key-Kryptographie / Schlüsselkapselungsmechanismen (KEM: Key Encapsulation Mechanism): Ein Mechanismus zum sicheren Teilen (Verteilen) von symmetrischen Schlüsseln für die Verschlüsselung von Kommunikationskanälen, z. B. in TLS-Verbindungen.
Digitale Signaturen (Digital Signatures): Ein Mechanismus für Software-Updates und digitale Zertifikate, um zu beweisen, dass Daten nicht manipuliert wurden und kein Spoofing des Absenders vorliegt (Authentizität).

Nach etwa sechs Jahren intensiver Evaluation, Analyse und kryptanalytischem Wettbewerb (Runde 1 bis Runde 3) sowie einer zusätzlichen Evaluierung (Runde 4) für einige Algorithmen, wurden im Jahr 2024 die folgenden Algorithmen offiziell als Federal Information Processing Standards (FIPS) veröffentlicht und somit als künftige weltweite Standards festgelegt:

FIPS 203 (ML-KEM): KEM basierend auf CRYSTALS-Kyber
FIPS 204 (ML-DSA): Digitale Signatur basierend auf CRYSTALS-Dilithium
FIPS 205 (SLH-DSA): Zustandlose Hash-basierte Signatur basierend auf SPHINCS+
(In zukünftiger Planung) FN-DSA: Digitale Signatur basierend auf FALCON

Die ausgewählten Algorithmen stützen sich auf jeweils unterschiedliche mathematische “Schwierigkeitsprobleme”, sodass eine Vielfalt (Crypto Agility) gewährleistet ist. Sollte in Zukunft eine fatale Schwachstelle in einem Algorithmus entdeckt werden, wird so verhindert, dass das gesamte System zusammenbricht. Im Standardisierungsprozess nahm die gitterbasierte Kryptographie (Lattice-based cryptography) aufgrund ihrer Leistung die Hauptrolle ein, jedoch wurden hashbasierte und codebasierte Kryptographien als starke Backups übernommen.

3. Klassifizierung der wichtigsten mathematischen Ansätze in PQC

PQC-Algorithmen lassen sich nach den mathematischen Problemen, die ihre Sicherheit begründen, in die folgenden fünf Hauptkategorien einteilen. In diesem Artikel gehen wir speziell auf die ersten drei näher ein.

Gitterbasierte Kryptographie (Lattice-based Cryptography): Basiert auf dem Problem des kürzesten Vektors (Shortest Vector Problem, SVP), dem Problem des nächsten Vektors (Closest Vector Problem, CVP) in mehrdimensionalen Gitterräumen sowie dem davon abgeleiteten LWE-Problem. Dies ist das Herzstück der NIST-Standardisierung; Kyber, Dilithium und FALCON gehören dazu. Es bietet die beste Balance aus Verarbeitungsgeschwindigkeit, Public-Key-Größe und Chiffretextgröße und eignet sich daher für allgemeine Anwendungen.
Hash-basierte Kryptographie (Hash-based Cryptography): Stützt sich für ihre Sicherheit ausschließlich auf die “Kollisionsresistenz” und die “Einweg-Eigenschaft” von kryptographischen Hash-Funktionen (wie SHA-2 und SHAKE). Sie ist nur auf digitale Signaturen (wie SPHINCS+) anwendbar, bietet jedoch die stärksten Sicherheitsbeweise und zeichnet sich durch extrem hohe Resistenz gegen unbekannte mathematische Angriffe aus.
Code-basierte Kryptographie (Code-based Cryptography): Basiert auf der Theorie der Fehlerkorrekturcodes und stützt sich auf die Schwierigkeit des Syndrom-Decodierungsproblems (Syndrome Decoding Problem). Ein typisches Beispiel ist das in den 1970er Jahren vorgeschlagene Classic McEliece, das eine lange Geschichte und bewährte Sicherheit aufweist, aber den Nachteil extrem großer Public-Key-Größen im Megabyte-Bereich hat.
Multivariate polynomische Kryptographie (Multivariate Polynomial Cryptography): Basiert auf der Schwierigkeit, Lösungen für Systeme von multivariaten quadratischen Gleichungen über endlichen Körpern zu finden (MQ-Problem). Sie wurde hauptsächlich für digitale Signaturen (wie Rainbow) vorgeschlagen, jedoch wurde während der finalen NIST-Runde eine leistungsstarke Angriffsmethode entdeckt, die es ermöglichte, sie auf einem einzigen PC in wenigen Tagen zu knacken, weshalb viele dieser Algorithmen aus der Standardisierung herausfielen.
Isogenie-basierte Kryptographie (Isogeny-based Cryptography): Basiert auf dem Problem der Wegfindung auf Isogenie-Graphen elliptischer Kurven. Sie hatte sehr kleine Schlüsselgrößen und galt als legitimer Nachfolger von ECC. Der finale Kandidat “SIKE” wurde jedoch 2022 mithilfe klassischer Mathematik (z.B. Castryck-Decru-Angriff) auf einem normalen PC in nur wenigen Stunden vollständig geknackt, was ein dramatisches Ende darstellte und die Schwierigkeit und Gefahr des PQC-Designs symbolisiert.

4. Die Tiefen der Gitterkryptographie: LWE-Problem und die mathematischen Grundlagen von Module-LWE

Die Gitterkryptographie, die derzeit als vielversprechendster Ansatz gilt und im Zentrum der Standardisierung steht. Die Grundlage ihrer Sicherheit ist das LWE-Problem (Learning with Errors: Lernen mit Fehlern). Es wurde 2005 von Oded Regev vorgestellt, eine bahnbrechende Leistung, für die er den Gödel-Preis erhielt. Ohne das Verständnis des LWE-Problems kann man die moderne PQC nicht diskutieren.

4.1. Was ist das LWE-Problem (Learning with Errors)?

Betrachten wir zunächst ein einfaches lineares Gleichungssystem. Angenommen, es gibt unter einem Modul $q$ eine bekannte zufällige Matrix $A$ und einen unbekannten geheimen Vektor $\vec{s}$, und ihr Produkt $\vec{b}$ sei gegeben.

$$ \vec{b} = A\vec{s} \pmod q $$

In diesem Fall ist es einfach, das unbekannte $\vec{s}$ aus den öffentlichen Informationen $A$ und $\vec{b}$ zu ermitteln. Mit dem klassischen “Gaußschen Eliminationsverfahren” kann $\vec{s}$ leicht in polynomieller Zeit berechnet werden.

Wenn wir dieser Gleichung jedoch einen “kleinen absichtlichen Fehler (Rauschen)” hinzufügen, steigt der Schwierigkeitsgrad des Problems dramatisch an. Das ist das LWE-Problem.

Wir bereiten einen unbekannten geheimen Vektor $\vec{s} \in \mathbb{Z}_q^n$ und eine zufällig gewählte Matrix $A \in \mathbb{Z}_q^{m \times n}$ vor. Darüber hinaus bereiten wir einen Fehlervektor $\vec{e} \in \mathbb{Z}_q^m$ vor, dessen Werte nach einer Normal- oder Binomialverteilung ausgewählt wurden und “ausreichend klein” sind, und berechnen $\vec{b}$ wie folgt:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Das Search-LWE-Problem besteht darin, “die geheimen Informationen $\vec{s}$ aus den öffentlichen Informationen $(A, \vec{b})$ zu ermitteln”. Durch die Anwesenheit dieses Fehlers $\vec{e}$ werden algebraische Lösungsmethoden wie die Gaußsche Elimination scheitern, da der Fehler $\vec{e}$ durch die Addition und Subtraktion von Gleichungen schneeballartig anwächst, bis er schließlich von zufälligen Werten nicht mehr zu unterscheiden ist.

Das Großartige am LWE-Problem ist, dass es einen starken theoretischen Beweis (Reduktion) gibt: Sofern kein Quantenalgorithmus existiert, der “Worst-Case-Probleme auf Gittern” wie GapSVP (Entscheidungsproblem des kürzesten Vektors) oder SIVP (Problem der kürzesten unabhängigen Vektoren) lösen kann, kann das LWE-Problem auch im Durchschnittsfall (Average-case) nicht gelöst werden. Das bedeutet, dass selbst zufällig generierte kryptographische Schlüssel eine robuste, durch theoretische Obergrenzen untermauerte Sicherheit garantieren.

4.2. Dramatische Effizienzsteigerung durch Ring-LWE und Module-LWE

Das gewöhnliche LWE-Problem (Standard-LWE) hat eine sehr klare Sicherheitsbasis, ist jedoch unpraktisch, da die Größe der Matrix $A$ extrem anwächst und Schlüsselgrößen im Megabyte-Bereich entstehen. Daher wurde ein Ansatz vorgeschlagen, Polynomringe (Polynomial Rings) zu nutzen, um eine algebraische Struktur einzuführen.

Beim Ring-LWE-Problem werden anstelle einfacher Vektoren oder Matrizen Elemente (Polynome) eines bestimmten Polynomrings $R_q$ verwendet. Die in den NIST-Standards am häufigsten verwendeten sind Kreisteilungs-Polynomringe wie:

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Hier ist $n$ eine Potenz von 2 (z. B. 256) und $q$ eine geeignete Primzahl. Auf diesem Ring werden Elemente $a, s, e \in R_q$ verwendet, um $b = a \cdot s + e \pmod q$ zu berechnen. Da ein einziges Polynom $a$ über $n$ Koeffizienten verfügt, können Daten erheblich komprimiert werden. Darüber hinaus ermöglicht die Verwendung der NTT (Number Theoretic Transform: Zahlentheoretische Transformation), einer Endliche-Körper-Version der schnellen Fourier-Transformation (FFT), extrem schnelle Polynommultiplikationen in $O(n \log n)$ Rechenschritten.

Bei Ring-LWE bestand jedoch die Sorge, dass “aufgrund der speziellen algebraischen Ringstruktur unbekannte Schwachstellen existieren könnten”. Ein weiteres technisches Problem war, dass bei der Änderung des Sicherheitsniveaus (z.B. äquivalent zu AES-128, 192, 256) der Polynomgrad $n$ selbst geändert werden musste, wodurch die gesamte Implementierung, wie etwa der NTT-Algorithmus, umgeschrieben werden musste.

Deshalb haben die standardisierten Algorithmen Kyber und Dilithium das Module-LWE (M-LWE) Problem übernommen. Module-LWE ist ein Kompromiss, der genau in der Mitte zwischen dem strukturlosen Standard-LWE und dem zu stark strukturierten Ring-LWE liegt, indem es $k \times k$ Matrizen (Module) verwendet, deren Komponenten Elemente des Polynomrings $R_q$ sind:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Der größte Vorteil von Module-LWE ist, dass das Sicherheitsniveau leicht skaliert werden kann, indem lediglich die Matrixdimension $k$ geändert wird, während der Polynomgrad $n$ ($n=256$ in den NIST-Standards) konstant bleibt. Zum Beispiel wird bei Kyber die Dimension $k$ wie folgt angepasst:

Kyber512 (Level 1): $k = 2$ (entspricht AES-128)
Kyber768 (Level 3): $k = 3$ (entspricht AES-192)
Kyber1024 (Level 5): $k = 4$ (entspricht AES-256)

Dies machte es möglich, den zugrunde liegenden NTT-Code und Hardware-Schaltungen für Polynomoperationen über alle Sicherheitsstufen hinweg zu 100% wiederzuverwenden, was die Sicherheit und Effizienz der Implementierung drastisch verbesserte.

5. CRYSTALS-Kyber (ML-KEM): Der Schlüsselkapselungsmechanismus der nächsten Generation

CRYSTALS-Kyber, offiziell als FIPS 203 (ML-KEM) standardisiert, ist ein Schlüsselkapselungsmechanismus (KEM), der auf dem oben erwähnten Module-LWE-Problem basiert. Er wird de facto der künftige weltweite Standard für das sichere Teilen von Sitzungsschlüsseln in Protokollen wie TLS 1.3 und SSH sein.

5.1. Architektur des KEM (Key Encapsulation Mechanism)

In der PQC-Ära wird anstelle des direkten Ansatzes von RSA, bei dem “der Client einen symmetrischen Schlüssel erstellt, ihn mit dem öffentlichen Schlüssel des Servers verschlüsselt und sendet”, das Kapselungs-Framework KEM zum Standard.

sequenceDiagram participant Client as "Client (Alice)" participant Server as "Server (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Erzeugt privaten (sk) und öffentlichen Schlüssel (pk)" Client->>Server: "Sendet öffentlichen Schlüssel (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Erzeugt zufälligen symmetrischen Schlüssel (K)" Server->>Server: "Kapselt K mit pk, erstellt Chiffretext (c)" Server->>Client: "Sendet Chiffretext (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Entschlüsselt Chiffretext (c) mit privatem Schlüssel (sk)" Client->>Client: "Entkapselt und extrahiert den symmetrischen Schlüssel (K)" Note over Client, Server: "Start der verschlüsselten Kommunikation (z. B. AES) mit dem geteilten Schlüssel (K)"

5.2. Der interne Algorithmus von Kyber und die Fujisaki-Okamoto-Transformation

Das Design von Kyber ist sehr raffiniert. Zunächst wird ein Public-Key-Kryptosystem (Kyber.CPAPKE) konstruiert, das nur gegen CPA (Chosen-Plaintext Attacks) sicher ist. Durch die Anwendung einer kryptographisch sehr mächtigen Methode namens Fujisaki-Okamoto-Transformation (Fujisaki-Okamoto Transform) wird dieses System zu einem vollständigen KEM aufgerüstet, das auch gegen CCA (Adaptive Chosen-Ciphertext Attacks) sicher ist.

Der zentrale Verschlüsselungs- und Entschlüsselungsmechanismus von CPAPKE funktioniert wie folgt:

Schlüsselerzeugung (Key Generation):
- Eine Matrix $A \in R_q^{k \times k}$ im NTT-Bereich wird aus einem zufälligen Seed generiert. Der Modul $q$ ist $3329$.
- Der geheime Vektor $\vec{s}$ und der Fehlervektor $\vec{e}$ mit kleinen Koeffizienten werden aus einer zentrierten Binomialverteilung (CBD) abgetastet.
- Es wird $\vec{t} = A\vec{s} + \vec{e}$ berechnet. Der öffentliche Schlüssel ist $(A, \vec{t})$, der private Schlüssel ist $\vec{s}$. (In der Praxis wird $A$ als Seed veröffentlicht, um Bandbreite zu sparen).
Verschlüsselung (Encryption):
- Die zu teilende 32-Byte-Nachricht (Schlüsselmaterial) $m$ wird in ein Polynom kodiert.
- Ein neuer zufälliger Vektor $\vec{r}$ und kleine Fehler $\vec{e_1}, e_2$ werden generiert.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- Der Chiffretext ist $(\vec{u}, v)$.
Entschlüsselung (Decryption):
- Der Empfänger berechnet $v - \vec{s}^T\vec{u}$.
- Wenn wir diese Gleichung ausklappen, erhalten wir: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- Setzen wir hier $\vec{t} = A\vec{s} + \vec{e}$ ein, heben sich die Hauptterme $\vec{s}^TA^T\vec{r}$ auf.
- Übrig bleibt $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- Da die Terme in den Klammern “Produkte und Summen kleiner Fehler” sind, bleibt das Ganze ein ausreichend kleiner Wert (Rauschen). Daher kann durch Schwellenwertbestimmung, ob jeder Koeffizient näher an $0$ oder $q/2$ liegt, das Bit der ursprünglichen Nachricht $m$ (0 oder 1) völlig fehlerfrei wiederhergestellt werden.

Die größte Stärke von Kyber liegt in seiner enormen Verarbeitungsgeschwindigkeit und der moderaten Schlüsselgröße. Bei Kyber768 beträgt die Public-Key-Größe 1.184 Bytes und die Chiffretextgröße 1.088 Bytes. Auch wenn dies im Vergleich zu RSA-3072 (Schlüsselgröße ca. 384 Bytes) größer ist, passt es ohne Paketfragmentierung in die MTU (Maximum Transmission Unit) moderner Internetkommunikation und hat kaum negative Auswirkungen auf die Netzwerklatenz.

6. CRYSTALS-Dilithium (ML-DSA): Gitterbasierte universelle digitale Signatur

Bei der Standardisierung digitaler Signaturen konkurrierten Algorithmen mit unterschiedlichen Designphilosophien innerhalb desselben gitterbasierten Ansatzes. Unter diesen wurde CRYSTALS-Dilithium als universelle digitale Signatur FIPS 204 (ML-DSA) ausgewählt.

6.1. Das “Fiat-Shamir with Aborts”-Paradigma

Dilithium ist, wie Kyber, ein digitales Signaturschema, das auf Module-LWE (und dem Module-SIS-Problem) basiert. Die Grundlage seines Designs ist das extrem wichtige Paradigma der “Fiat-Shamir-Transformation mit Abbrüchen (Fiat-Shamir with Aborts)”.

Die Fiat-Shamir-Transformation an sich ist eine Standardmethode zur Umwandlung interaktiver Zero-Knowledge-Beweisprotokolle in nicht-interaktive digitale Signaturen. Der Beweiser (Signierende) erzeugt ein Commitment $y$, berechnet $w = Ay$ und leitet es durch eine Hash-Funktion, um eine zufällige Challenge $c$ zu erhalten, und berechnet die Antwort $z = y + cs$.

Wenn dies jedoch einfach in der Gitterkryptographie angewendet wird, verzerrt sich die Verteilung der Antwort $z$ abhängig vom Wert des privaten Schlüssels $s$. Dies führte zu dem fatalen Problem, dass ein Angreifer, der viele Signaturen beobachtet, nach und nach Informationen über den privaten Schlüssel $s$ erlangen konnte (ein mathematisches Leck, das Seitenkanalangriffen ähnelt).

Das Dilithium-Designteam (Lyubashevsky et al.) führte eine Methode namens “Rejection Sampling (Verwerfungsmethode)” ein. Dabei wird der gesamte Signaturprozess abgebrochen (Abort), wenn die Koeffizienten des berechneten Ergebnisses $z$ nicht in einen voreingestellten sicheren Schwellenwertbereich fallen, und die Berechnung mit einer neuen Zufallszahl $y$ von vorn begonnen.

Dadurch folgt die letztendlich ausgegebene Signatur $z$ einer vollkommen gleichmäßigen Verteilung, die völlig unabhängig vom privaten Schlüssel ist, wodurch Informationslecks mathematisch vollständig verhindert werden konnten.

6.2. Vorteile von Dilithium und einfache Implementierung

Ein großer Designvorteil von Dilithium besteht darin, dass es im Signaturerzeugungsprozess überhaupt kein komplexes “Sampling aus Gauß-Verteilungen” oder “Fließkommaoperationen” verwendet. Da es nur mit Sampling aus einer Gleichverteilung, einfachen ganzzahligen Modulo-Operationen, NTT und Hash-Funktionen (SHAKE) implementiert werden kann, ist es in einer Vielzahl von Umgebungen – vom eingebetteten Mikrocontroller bis zum Cloud-Server – einfach sicher und in konstanter Zeit (Constant-time) zu implementieren. Dies macht es sehr widerstandsfähig gegen physische Seitenkanalangriffe wie Timing-Angriffe.

7. FALCON (FN-DSA): Die ultimativ kompakte Gittersignatur

Das NIST hat als eine weitere gitterbasierte Signatur mit anderen Eigenschaften als Dilithium FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) als Standardisierungskandidaten ausgewählt (derzeit als FN-DSA im Entwurfsstadium).

7.1. NTRU-Gitter und Gauß-Sampling

Das Hauptmerkmal von FALCON ist, dass es nicht das LWE-Problem, sondern das seit 1996 existierende und historische NTRU-Gitter (N-th degree Truncated polynomial Ring Units) verwendet. Darüber hinaus nutzt es das “Hash-and-Sign”-Paradigma, das auf dem GPV-Framework (Gentry-Peikert-Vaikuntanathan) basiert.

Bei Hash-and-Sign wird der Hash-Wert der Nachricht als Zielpunkt im Raum betrachtet und der diesem Punkt am nächsten liegende Gitterpunkt (eine ungefähre Lösung des Problems des nächsten Vektors) als Signatur gefunden. Hierfür müssen Punkte nach einer diskreten Gauß-Verteilung abgetastet werden, wofür die “kurze Basis guter Qualität”, der private Schlüssel, verwendet wird.

FALCON beschleunigt diese rechenintensive Aufgabe drastisch durch eine Technik namens “Fast Fourier Orthogonalization (FFO)”.

7.2. Vor- und Nachteile von FALCON

Der überwältigende Vorteil von FALCON ist, dass seine Signaturgröße und Public-Key-Größe extrem klein (kompakt) sind. Während die Signaturgröße von Dilithium3 etwa 3.309 Bytes beträgt, liegt sie bei FALCON-512 bei nur ca. 666 Bytes. Auch der öffentliche Schlüssel ist mit 897 Bytes sehr klein, was es zum Retter in Umgebungen mit extrem eingeschränkter Bandbreite, für IoT-Geräte oder bestimmte Netzwerkprotokolle macht.

Allerdings gibt es einen gravierenden Nachteil. Da die Signaturerzeugung zwangsläufig komplexes diskretes Gauß-Sampling mit Fließkommaoperationen (64-Bit IEEE 754) erfordert, ist eine Constant-Time-Implementierung zur Vermeidung von Timing-Leaks äußerst schwierig, und der Code bläht sich auf. Aus diesem Grund positioniert sich FALCON im Gegensatz zur allgemeinen Nutzung (Dilithium) als leistungsstarker, spezialisierter Algorithmus für spezifische Anwendungen.

graph LR A["Anforderungen an digitale Signaturen"] --> B{"Was ist die oberste Priorität?"} B -->|"Einfachheit der Implementierung, Vielseitigkeit, leichte Constant-Time-Implementierung"| C["Dilithium (ML-DSA)"] B -->|"Minimierung der Bandbreite, kompakte Datengröße"| D["FALCON (FN-DSA)"] C --> E["Allgemeine TLS-Zertifikate, elektronische Signaturen für Software"] D --> F["Protokolle mit strengen Paketgrößenlimits, spezielle Umgebungen"]

8. SPHINCS+ (SLH-DSA): Hash-basierte Signatur mit der stärksten Sicherheit

Für den Worst-Case, dass die Sicherheit der Gitterkryptographie in Zukunft durch den Durchbruch eines genialen Mathematikers gebrochen wird, hat NIST FIPS 205 (SLH-DSA), sprich SPHINCS+, als Standard mit einem völlig anderen Ansatz als die Gitterkryptographie festgelegt.

SPHINCS+ wird als hash-basierte Signatur klassifiziert. Die Basis seiner Sicherheit stützt sich nur auf einen einzigen Punkt: “Die verwendete kryptographische Hash-Funktion (wie SHA-2 oder SHAKE256) muss kollisionsresistent und eine Einwegfunktion sein”. Da es nicht von mathematischen Problemen mit spezifischen algebraischen Strukturen wie LWE oder Primfaktorzerlegung abhängt, bietet es eine extrem robuste Sicherheit (die konservativste Sicherheit). Egal, wie mächtige Quantenalgorithmen in Zukunft erscheinen mögen, es kann abgewehrt werden, indem man einfach die Ausgabelänge der Hash-Funktion erhöht.

8.1. Zustandslose Architektur mit WOTS+ und FORS

Die Geschichte der hash-basierten Signaturen reicht weit in die 1970er Jahre zu Lamport-Signaturen und Winternitz-Einmal-Signaturen (WOTS) zurück. Dabei handelte es sich um Wegwerfschlüssel, mit denen “nur einmal sicher signiert” werden konnte. Um diese mehrfach verwendbar zu machen, wurden Algorithmen wie XMSS (eXtended Merkle Signature Scheme) oder LMS entwickelt, die einen Merkle-Baum kombinieren, um unzählige Einmalschlüssel mit einem einzigen Root-Hash zu verwalten.

XMSS und LMS wiesen jedoch den großen Nachteil auf, dass sie “zustandsbehaftet (stateful)” waren. Bei jeder Signatur musste der Index-Status (“der wievielte Einmalschlüssel wurde verwendet”) strikt im nichtflüchtigen Speicher mitgeschrieben werden. Wenn der Zustand z. B. durch das Wiederherstellen eines VM-Snapshots zurückgesetzt wird und derselbe Einmalschlüssel ein zweites Mal verwendet wird, ist der private Schlüssel sofort kompromittiert und das System bricht zusammen.

SPHINCS+ ist eine “zustandslose (stateless)” hash-basierte Signatur, die dieses lästige Zustandsmanagement gelöst hat. Seine Kerntechnologie besteht aus folgender Kombination:

WOTS+ (Winternitz One-Time Signature Plus): Eine grundlegende Einmal-Signatur.
FORS (Forest of Random Subsets): Eine Few-Time-Signature-Technologie. Sie gewährleistet die Sicherheit, auch wenn derselbe Schlüssel ein paar Mal wiederverwendet wird.
Hyper-Tree (Riesige Baumstruktur): Eine gigantische Struktur, bei der Merkle-Bäume mehrschichtig übereinandergelegt werden.

Bei der Signierung mit SPHINCS+ wird, anstatt Zustände zu verwalten, mittels Pseudozufallszahlen zufällig einer der unzähligen FORS-Schlüssel an der Basis des Hyper-Trees ausgewählt. Da die Anzahl der Blätter am Baum astronomisch hoch ist, wird die Wahrscheinlichkeit (Kollision), denselben Schlüssel zufällig zweimal zu wählen, verschwindend gering, was letztlich zur Zustandslosigkeit führt.

Die einzige und größte Schwäche von SPHINCS+ ist die extrem große Signaturgröße. Je nach Parametern erreicht die Signaturgröße 17 bis 49 Kilobytes, und die Signaturerzeugung ist im Vergleich zur Gitterkryptographie überwältigend langsam. Daher wird sie eher nicht für das alltägliche Webbrowsing eingesetzt, sondern für Anwendungen wie Software-Update-Signaturen oder Root-Zertifikate (CA), bei denen nicht häufig signiert wird, aber langfristige absolute Sicherheit zwingend erforderlich ist.

9. Code-basierte Kryptographie: Der gute alte Riese Classic McEliece

Ein wichtiger Ansatz, der als Finalist in Runde 4 des NIST-Standardisierungsprozesses weiterhin evaluiert wird, ist Classic McEliece, das auf code-basierter Kryptographie beruht.

Dieser Algorithmus wurde 1978 von Robert McEliece vorgeschlagen und ist neben RSA einer der ältesten in der Geschichte der Public-Key-Kryptographie. Er verwendet algebraisch-geometrische Codes, sogenannte “Goppa-Codes”. Dabei wird eine Nachricht durch absichtliches Hinzufügen von Fehlern (Rauschvektoren) verschlüsselt. Nur wer die Paritätsprüfmatrix des Goppa-Codes als privaten Schlüssel besitzt, kann die starke Fehlerkorrekturfähigkeit nutzen, um die Fehler zu entfernen und die ursprüngliche Nachricht zu entschlüsseln. Dies basiert auf dem “Syndrom-Decodierungsproblem (Syndrome Decoding Problem)”.

$$ \vec{c} = \vec{m} G + \vec{e} $$

(Wobei $G$ die verschlüsselte Generatormatrix als öffentlicher Schlüssel und $\vec{e}$ der Fehlervektor vom Gewicht $t$ ist)

Das Erstaunliche an Classic McEliece ist seine überwältigende Erfolgsbilanz: Obwohl es seit seinem Entwurf vor über 40 Jahren intensiver kryptanalytischer Forschung von Kryptographen auf der ganzen Welt ausgesetzt war, wurde nie eine grundlegende Schwachstelle entdeckt. Unter allen PQC-Ansätzen besitzt es die “durch die Zeit am besten bewiesene, robuste Sicherheit”.

Darüber hinaus hat es den Vorteil, dass die Chiffretextgröße sehr klein ist (nur etwa 100 bis 200 Bytes). Es hat jedoch den fatalen Nachteil, dass die Public-Key-Größe in den Megabyte-Bereich (MB) reicht. Selbst auf der niedrigsten Sicherheitsstufe (entsprechend AES-128) ist der öffentliche Schlüssel ca. 250 KB groß, auf höheren Stufen übersteigt er 1 MB.

Aus diesem Grund eignet es sich überhaupt nicht für Anwendungsfälle wie den TLS-Handshake, bei denen der öffentliche Schlüssel bei jeder Kommunikation über das Netzwerk gesendet wird. In speziellen Anwendungsfällen jedoch, bei denen der öffentliche Schlüssel im Voraus im System platziert werden kann, wie etwa beim Schlüsselaustausch für VPNs, bei in Firmware hartkodierten öffentlichen Schlüsseln oder bei Satellitenkommunikation, wird er aufgrund seiner starken Sicherheit weiterhin als äußerst vielversprechende Option betrachtet.

10. Leistungsvergleich und Kompromisse der einzelnen PQC-Algorithmen

Die Leistungsmerkmale der bisher diskutierten Hauptalgorithmen bei gängigen Sicherheitsniveaus (NIST Level 2 bis 3, entsprechend AES-128 bis 192) sind in der folgenden Tabelle zusammengefasst.

Algorithmus (Standardname)	Kategorie	Mathematische Grundlage	Public-Key-Größe	Private-Key-Größe	Chiffretext-/Signaturgröße	Verarbeitungsgeschwindigkeit	Hauptmerkmale und Anwendungen
Kyber768 (ML-KEM)	KEM	Module-LWE	1.184 Bytes	2.400 Bytes	1.088 Bytes	Sehr schnell	Beste Balance aus Schlüsselgröße und Geschwindigkeit. Universeller KEM-Standard für z. B. TLS 1.3.
Dilithium3 (ML-DSA)	Signatur	Module-LWE	1.952 Bytes	4.032 Bytes	3.309 Bytes	Erzeugung & Verifizierung schnell	Einfache Implementierung. Universeller Standard für digitale Signaturen.
FALCON-512 (FN-DSA)	Signatur	NTRU-Gitter	897 Bytes	1.281 Bytes	666 Bytes	Erzeugung eher langsam, Verifizierung ultraschnell	Minimale Signaturgröße. Erfordert jedoch Fließkommaoperationen. Für Embedded & IoT.
SPHINCS+ (SLH-DSA)	Signatur	Hash-Funktion	32 Bytes	64 Bytes	ca. 17.000 Bytes	Erzeugung sehr langsam	Mathematisches Ausfallrisiko fast null. Hochsicherheitsanwendungen wie Root-Zertifikate.
Classic McEliece	KEM	Goppa-Code	ca. 1,04 MB	13.568 Bytes	188 Bytes	Kapselung ist schnell	40 Jahre bewiesene Sicherheit. Riesiger öffentlicher Schlüssel. Für Umgebungen mit Hartkodierung.

Kompromisse verstehen

In der Welt der PQC gibt es keinen einzigen magischen Algorithmus mit den Eigenschaften “kleine Größe, hohe Geschwindigkeit und perfekte mathematische Garantie”.

Internet-Standards (Kyber / Dilithium): Bieten die beste Leistungsbalance und eignen sich am besten als Drop-In-Ersatz für heutiges RSA/ECC.
Ultimativer Konservativismus (SPHINCS+): Wird gewählt, wenn man auf Kosten von Datengröße und Verarbeitungsgeschwindigkeit eine absolute Versicherung gegen zukünftige mathematische Durchbrüche haben möchte.
Für spezielle Umgebungen (FALCON / Classic McEliece): Spezialwaffen, die je nach Umgebungsbeschränkungen ausgewählt werden, z. B. bei extrem geringer Bandbreite oder der Möglichkeit der Vorabverteilung.

11. Herausforderungen bei der praktischen Anwendung und die praktische Lösung der “hybriden Kryptographie”

Mit dem Abschluss der NIST-Standardisierung und der offiziellen Veröffentlichung der FIPS-Standards hat die PQC-Migration (PQC Migration) der IT-Infrastruktur weltweit ernsthaft begonnen. Googles Chrome-Browser, Apples iMessage (PQ3-Protokoll) und Netzwerkanbieter wie Cloudflare haben die PQC-Unterstützung bereits in ihre Protokolle implementiert und mit dem praktischen Einsatz begonnen.

Ein abrupter und vollständiger Wechsel zu neuen kryptographischen Algorithmen ist jedoch mit sehr hohen Risiken verbunden. Angenommen, ein brillanter Mathematiker entdeckt in einigen Jahren eine fatale Angriffsmethode auf Gitterkryptographien wie Kyber (einen mathematischen Fehler, der auch mit klassischen Computern gelöst werden könnte), dann würde das gesamte davon abhängige System in einem Augenblick schutzlos sein.

Der realistische und empfohlene Ansatz, um dieses Unsicherheitsrisiko zu mindern, ist die “hybride Kryptographie (Hybrid Cryptography)”.

In der hybriden Kryptographie werden sowohl bestehende klassische Kryptographien mit jahrelanger Erfolgsgeschichte (z.B. elliptische Kurven wie X25519) als auch neue PQC (z.B. Kyber768) gleichzeitig für den Schlüsselaustausch verwendet. Jeder Algorithmus generiert unabhängig voneinander symmetrische Schlüsselkomponenten. Schließlich werden beide Komponenten mithilfe einer sicheren Schlüsselableitungsfunktion (Key Derivation Function, KDF) gemischt, um das endgültige Master-Secret zu generieren.

graph TD A["Client"] -->|① Sendet öffentlichen Schlüssel von X25519 + öffentlichen Schlüssel von Kyber| B["Server"] B -->|② Antwortet mit geteiltem Schlüssel von X25519 + gekapseltem Chiffretext von Kyber| A A --> C{"Ableitung des Master-Secrets (KDF)"} B --> C C -->|Eingabe: (X25519 gemeinsamer Schlüssel) || (Kyber gemeinsamer Schlüssel)| D["Sicherer Kommunikationsschlüssel (AES-256 / ChaCha20)"] D -->|"Widerstandsfähig gegen Quantenbedrohungen UND klassische Schwachstellen"| E["Sichere hybride verschlüsselte Kommunikation (TLS 1.3)"]

Dadurch entsteht eine robuste zweischichtige Sicherheit: “Selbst wenn Quantencomputer realisiert und ECC geknackt werden, schützt Kyber die Kommunikation”, und umgekehrt “Sollte ein unbekannter mathematischer Fehler in Kyber gefunden werden, schützt ECC die Kommunikation”. Ein prominentes Beispiel ist der IETF-Standardisierungsentwurf X25519MLKEM768 (früher X25519Kyber768). Die heutige Kommunikation zwischen Webbrowsern und modernsten Servern nutzt genau diese hybride Methode.

Darüber hinaus wird im Systemdesign das Konzept der Crypto Agility (Kryptographische Agilität) zu einer zwingenden Anforderung für die zukünftige Systementwicklung. Dies bedeutet, eine Architektur aufzubauen, “die nicht übermäßig von einem bestimmten kryptographischen Algorithmus abhängt und schnell auf einen anderen Algorithmus umstellen kann (z.B. von Kyber auf McEliece, von Dilithium auf SPHINCS+), sollte ein Algorithmus scheitern”.

12. Fazit: Ein neuer Horizont der Kryptographie

Die Menschheitstraum-Technologie des Quantencomputers ist ironischerweise zur größten Bedrohung geworden, um unsere lange als vertrauenswürdig erachteten mathematischen Verteidigungslinien wie “Primfaktorzerlegung” und das “diskrete Logarithmusproblem” zu durchbrechen. Dennoch haben Kryptographen auf der ganzen Welt nicht aufgegeben. Stattdessen haben sie komplexere und tiefgründigere mehrdimensionale mathematische Gebiete wie Gittertheorie, Hash-Funktions-Bäume und Fehlerkorrekturcodes erschlossen, um mit der Post-Quanten-Kryptographie (PQC) ein neues Bollwerk zu errichten.

Der Abschluss der NIST-Standardisierung mit FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) und FIPS 205 (SLH-DSA) ist nicht das Ziel. Es ist nur der erste Schritt einer epischen PQC-Migration, die noch Jahrzehnte dauern wird. Für Softwareentwickler und Systemarchitekten wird es die große technische Herausforderung der Zukunft sein, herauszufinden, wie man die “Zunahme der Schlüsselgrößen” und “Veränderungen bei den Berechnungskosten”, die diese neuen Algorithmen mit sich bringen, optimal an Netzwerkprotokolle und Systeme anpasst.

Der Kampf zwischen Quantencomputern und Kryptographie ist ein spannendes Feld, in dem die menschliche Erforschung der Mathematik und die technologische Evolution am intensivsten aufeinandertreffen. Ich hoffe, dieser Artikel hat Ihnen ein tieferes Verständnis der wunderschönen mathematischen Theorie hinter der PQC sowie der erstaunlichen Mechanismen der einzelnen Algorithmen, die die Zukunft der Cybersicherheit prägen werden, vermittelt.

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

Der Tag, an dem Quantencomputer praktisch werden: Der aktuelle Stand im Jahr 2026

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

1. Einführung: Wie weit sind Quantencomputer im Jahr 2026 gekommen?

Im Jahr 2026 hat das Quantencomputing einen entscheidenden Wandel vom einstigen „theoretischen Traum“ zur „ingenieurstechnischen Realität“ vollzogen. Da die Grenzen der bis vor wenigen Jahren noch vorherrschenden NISQ (Noisy Intermediate-Scale Quantum)-Geräte deutlich wurden, haben Forschungseinrichtungen und Tech-Giganten weltweit das Ruder in Richtung der Realisierung des „fehlertoleranten Quantencomputings (FTQC: Fault-Tolerant Quantum Computing)“ herumgerissen.

In diesem Artikel werden wir den aktuellen Stand von Quantencomputern eingehend beleuchten und dabei die neuesten Durchbrüche des Jahres 2026 miteinbeziehen. Insbesondere werden wir die Quantenfehlerkorrektur (Oberflächencode), den Unterschied zwischen physischen und logischen Qubits, Fortschritte beim topologischen Quantencomputing sowie die neuesten Entwicklungen bei supraleitenden und Ionenfallen-Ansätzen im Detail erläutern.

2. Grundlagen von Quantenzuständen und Fidelität (Fidelity)

Das Qubit, die grundlegende Einheit eines Quantencomputers, kann sich im Gegensatz zu einem klassischen Bit (0 oder 1) in einem Überlagerungszustand (Superposition) von 0 und 1 befinden. Der Zustand eines einzelnen Qubits wird als Vektor in einem Hilbertraum wie folgt dargestellt:

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

Hierbei sind $\alpha$ und $\beta$ komplexe Wahrscheinlichkeitsamplituden, die die folgende Normalisierungsbedingung erfüllen:

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

Eine extrem wichtige Kennzahl zur Messung der Leistung von Quantenberechnungen ist die Fidelität (Fidelity). Die Fidelität $F$ zwischen einem idealen Quantenzustand $|\psi\rangle$ und einer durch Rauschen degradierten, zu einem gemischten Zustand gewordenen tatsächlichen Dichtematrix $\rho$ ist wie folgt definiert:

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

Heutzutage, im Jahr 2026, hat die Fidelität von 2-Qubit-Gattern (z. B. CNOT- oder CZ-Gattern) bei supraleitenden Systemen stabil die Hürde von 99,99 % (die sogenannten „vier Neunen“) überschritten. Dies liegt deutlich über dem Schwellenwert für die Fehlerkorrektur mit Oberflächencodes (ca. 99 %) und ist einer der größten Durchbrüche auf dem Weg zur praktischen Anwendung.

3. Die Grenzen der NISQ-Ära und der Paradigmenwechsel zu FTQC

Von den späten 2010er bis in die frühen 2020er Jahre hinein war die Ära von NISQ (Noisy Intermediate-Scale Quantum), also von Geräten mit zehn bis hunderten von Qubits ohne Fehlerkorrektur. NISQ hatte jedoch klare Grenzen.

Mit zunehmender Schaltkreistiefe (Depth) häufen sich Fehler exponentiell an, was es unmöglich macht, aussagekräftige Berechnungsergebnisse zu erzielen. Die Gesamterfolgswahrscheinlichkeit $P_{success}$ bei einer Schaltkreistiefe $D$ nimmt in Bezug auf die Fidelität eines einzelnen Gatters $f$ und die Anzahl der Gatter $N$ wie folgt ab:

$$ P_{success} \approx f^N $$

Wenn man 1000 Gatter mit $f = 0,99$ anwendet, ergibt sich $0,99^{1000} \approx 4,3 \times 10^{-5}$, und das Ergebnis geht fast vollständig in zufälligem Rauschen unter. Daher konzentrieren sich die Ressourcen im Jahr 2026 weniger auf die direkte Skalierung von NISQ-Algorithmen (wie VQE oder QAOA), sondern auf die Erzeugung von logischen Qubits (Logical Qubits).

4. Quantenfehlerkorrektur und logische Qubits: Die vorderste Front des Oberflächencodes

Die Quantenfehlerkorrektur (QEC: Quantum Error Correction) ist eine Technologie, bei der mehrere „physische Qubits“ kodiert werden, um ein einzelnes „logisches Qubit“ zu erzeugen und Fehler zu erkennen und zu korrigieren. Derzeit gilt der Oberflächencode (Surface Code) als am vielversprechendsten.

4.1 Struktur des Oberflächencodes (Surface Code)

Beim Oberflächencode werden die Qubits in einem zweidimensionalen Gitter angeordnet. Daten-Qubits (die die eigentlichen Informationen speichern) und Mess-Qubits (für die Syndrommessung) sind schachbrettartig angeordnet.

graph TD A["Daten-Qubit (D1)"] --- B["Mess-Qubit (M1)"] B --- C["Daten-Qubit (D2)"] C --- D["Mess-Qubit (M2)"] D --- E["Daten-Qubit (D3)"] B --- F["Daten-Qubit (D4)"] D --- G["Daten-Qubit (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

Mithilfe der Stabilisator-Operatoren $S_x$ und $S_z$ werden Bitflips (X-Fehler) und Phasenflips (Z-Fehler) kontinuierlich überwacht.

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

Ein entscheidender Fortschritt im Jahr 2026 war das vollständige Durchbrechen des „Break-Even-Punkts (Break-even point)“. Das bedeutet, dass das durch die Fehlerkorrektur beseitigte Rauschen größer wurde als das zusätzliche Rauschen, das durch die für die Fehlerkorrektur erforderlichen Schaltkreise entsteht, sodass die Lebensdauer von logischen Qubits die von physischen Qubits um viele Größenordnungen übertrifft.

4.2 Der Zyklus der Quantenfehlerkorrektur

Die Fehlerkorrektur fungiert als kontinuierliche Feedbackschleife.

sequenceDiagram participant D as "Daten-Qubits" participant M as "Ancilla-/Mess-Qubits" participant C as "Klassischer Controller" loop "Syndrom-Extraktionszyklus (ca. 1 Mikrosekunde)" D->>M: "Verschränken (CNOT/CZ)" M->>C: "Zustand messen (Syndrom)" C->>C: "Syndrom decodieren (z. B. Minimum Weight Perfect Matching)" C-->>D: "Pauli-Korrektur anwenden (falls erforderlich)" end

Mittlerweile hat sich die Technologie etabliert, diesen klassischen Dekodierungsprozess (Syndromanalyse) mit FPGAs oder dedizierten ASICs im Nanosekundenbereich durchzuführen, wodurch die Fehlerkorrektur in Echtzeit das Stadium der praktischen Anwendung erreicht hat.

5. Die Evolution der Hardware-Architektur (Ausgabe 2026)

Die Quantenhardware im Jahr 2026 entwickelt sich hauptsächlich entlang dreier Achsen: „Supraleitender Ansatz“, „Ionenfallen-Ansatz“ und „Topologischer Ansatz“.

5.1 Integration von supraleitenden Qubits

Der supraleitende Ansatz ist ein Bereich, der von IBM und Google angeführt wird, wobei Transmon-Qubits (Transmon) mit Josephson-Kontakten vorherrschen. Im Jahr 2026 wurden Mega-Chips realisiert, die Tausende bis Zehntausende von physischen Qubits auf einem einzigen Chip integrieren.

Besonders hervorzuheben ist die Etablierung von quantenmechanischen Verbindungen zwischen Modulen (Quantum Interconnects). Die Quantenteleportation zwischen Chips mithilfe von Mikrowellenphotonen wurde auf kommerziellem Niveau implementiert, wodurch die Größenbeschränkungen eines einzelnen Mischkryostaten (Verdünnungskühlschranks) umgangen werden können.

5.2 Zweidimensionale Skalierung von Ionenfallen und optische Interconnects

Beim Ionenfallen-Ansatz (vorangetrieben unter anderem von Quantinuum und IonQ) werden die internen Energiezustände von im Vakuum schwebenden Ionen als Qubits genutzt. Im Vergleich zum supraleitenden Ansatz haben sie den Vorteil extrem langer T1/T2-Kohärenzzeiten und ermöglichen eine All-to-All-Konnektivität (All-to-All Connectivity).

Der Durchbruch des Jahres 2026 ist die zweidimensionale Ausrichtung der QCCD-Architektur (Quantum Charge Coupled Device) und die Hochgeschwindigkeits-Verschränkungserzeugung zwischen mehreren Fallen mithilfe von photonischen Interconnects. Dadurch wurden die Schwächen der Ionenfallen, nämlich „langsame Gatter-Geschwindigkeit“ und „mangelnde Skalierbarkeit“, dramatisch verbessert.

5.3 Topologisches Quantencomputing: Kontrolle von Anyonen

Das topologische Quantencomputing, das lange Zeit als rein theoretisch galt, hat im Jahr 2026 endlich die Phase der experimentellen Demonstration erreicht. Dieser Ansatz, der unter anderem von Microsoft vorangetrieben wird, nutzt nicht-abelsche Anyonen (Non-Abelian Anyons), die als „Majorana-Nullmoden (Majorana Zero Modes)“ bezeichnet werden.

Quantengatter werden durch eine Operation namens „Braiding (Flechten)“ ausgeführt, bei der die Positionen der Anyon-Teilchen vertauscht werden.

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

Hierbei ist $B_{ij}$ der Braiding-Operator. Da beim topologischen Ansatz die Speicherung von Informationen nicht vom lokalen Zustand der Teilchen abhängt, sondern von der Topologie der gesamten „Knoten“, ist er von Natur aus widerstandsfähig gegen Umgebungsrauschen (Fehlertoleranz auf Hardware-Ebene). Im Jahr 2026 wurde weltweit zum ersten Mal die Erzeugung topologischer logischer Qubits mit hoher Fidelität bestätigt, was große Aufmerksamkeit als starke Abkürzung zu FTQC erregte.

6. Roadmap und Ausblick auf die praktische Anwendung

Damit Quantencomputer ihre Quantenüberlegenheit (Quantum Advantage), mit der sie klassische Computer (Supercomputer) in Bereichen wie „chemische Berechnungen“, „Materialwissenschaften“ und „Finanzmodellierung“ übertreffen, wirklich entfalten können, sind Tausende von logischen Qubits erforderlich.

gantt title "Quantencomputing-Roadmap (Überarbeitet 2026)" dateFormat YYYY axisFormat %Y section "NISQ-Ära" "Verrauschte Qubits (<1000)" :done, 2018, 2024 section "Frühes FTQC" "Demonstration des Break-Even-Punkts" :done, 2024, 2026 "Hunderte von logischen Qubits" :active, 2026, 2028 section "Vollwertiges FTQC" "1000+ logische Qubits (Komm. Anwendung)" : 2028, 2030 "Universeller fehlertoleranter Quantencomputer" : 2030, 2035

6.1 Aktuelle Herausforderungen und die Zukunft

Die größte Herausforderung im Jahr 2026 ist die Kühlkapazität der riesigen Kryostate (Verdünnungskühlschränke) zur Aufrechterhaltung der extrem niedrigen Temperaturen sowie die Verkabelung (I/O-Flaschenhals), die die Steuergeräte bei Raumtemperatur mit den Quantenchips bei tiefen Temperaturen verbindet. Um dem zu begegnen, schreitet die Entwicklung von CMOS-Controller-Chips (Cryo-CMOS), die in kryogenen Umgebungen funktionieren, rasant voran.

Fazit

Das Jahr 2026 wird in die Geschichte der Quantencomputer als „das erste Jahr der Skalierung logischer Qubits“ eingehen. Dank der Demonstration von Fehlerkorrekturalgorithmen, der Modularisierung der Hardware und der rasanten Fortschritte beim topologischen Ansatz ist der „Tag der praktischen Anwendung“ keine ferne Zukunft mehr, sondern kann als konkreter Meilenstein für die nächsten Jahre angesehen werden. Für Entwickler von Quantenalgorithmen und Unternehmen ist jetzt genau der richtige Zeitpunkt, um ernsthaft in quantennative Problemlösungen zu investieren.

Dieser Artikel basiert auf den neuesten Forschungsarbeiten und Branchentrends im Bereich des Quantencomputings mit Stand 2026.