Qiskit 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!

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/