Kodierte Qubits

Die Vision eines fehlertoleranten, skalierbaren Quantencomputers ist ohne kodierte Qubits kaum denkbar. Sie bilden das Rückgrat moderner Quantentechnologien, indem sie physikalische Qubits zu robusteren logischen Informationseinheiten bündeln. Ihre Relevanz ergibt sich aus einem fundamentalen Dilemma der Quanteninformatik: Quanteninformation ist empfindlich, zerbrechlich – und zugleich der Schlüssel zur Lösung komplexester Probleme, die klassische Rechner überfordern. In diesem Spannungsfeld setzen kodierte Qubits an.

Kodierte Qubits ermöglichen nicht nur eine systematische Fehlerkorrektur, sondern stellen auch einen Paradigmenwechsel dar: weg von bloßem Qubit-Zählen hin zur strukturell geschützten Informationsverarbeitung. Diese Einleitung legt das begriffliche und physikalische Fundament, um die darauffolgenden Abschnitte zu verstehen.

Was sind Qubits – und warum ist ihre Kodierung entscheidend?

Ein Qubit (kurz für „quantum bit“) ist das Quantenäquivalent zum klassischen Bit, jedoch mit entscheidenden Unterschieden. Während klassische Bits nur zwei diskrete Zustände besitzen – 0 oder 1 –, kann sich ein Qubit in einer Superposition dieser Zustände befinden:

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

Dabei sind \alpha und \beta komplexe Wahrscheinlichkeitsamplituden mit der Normierungsbedingung:

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

Diese Superposition erlaubt es Quantencomputern, parallele Rechenwege zu beschreiten – ein wesentlicher Grund für ihren potenziellen Vorteil gegenüber klassischen Systemen.

Doch die physikalische Realität von Qubits ist fragil. Supraleitende Schaltkreise, Ionenfallen oder Photonen zeigen quantenmechanisches Verhalten, sind aber durch Umwelteinflüsse, thermische Fluktuationen und Rauschen bedroht. Jeder Fehler – ein kleiner Drift in der Phase oder ein ungewollter Zustandswechsel – kann zu massiven Berechnungsverzerrungen führen.

Hier kommt die Kodierung ins Spiel: Sie transformiert einen einzelnen logischen Qubit-Zustand in eine kontrollierte Kombination mehrerer physikalischer Qubits. Durch geeignete Kodierungsmethoden, etwa in Form von Quantenfehlerkorrekturcodes, lassen sich Fehler erkennen, isolieren und beheben – ohne die fragile Quanteninformation direkt zu messen.

Kodierte Qubits sind also kein optionales Add-on, sondern eine fundamentale Notwendigkeit in realen Quantensystemen.

Der Zusammenhang zwischen Dekohärenz, Fehlerkorrektur und Kodierung

Dekohärenz ist der natürliche Feind der Quanteninformation. Sobald ein Qubit mit seiner Umgebung in Kontakt tritt – sei es durch elektromagnetische Störungen, Streuprozesse oder thermische Kopplung –, verliert es seine quantenmechanische Kohärenz. Der Zustand |\psi\rangle kollabiert zu einem klassischen Mischzustand – und wertvolle Information geht verloren.

Dieser Prozess lässt sich nicht vollständig vermeiden, aber durch gezielte Kodierung kontrollierbar machen. Dabei ist das Ziel nicht, Fehler vollständig zu eliminieren – das ist physikalisch unmöglich –, sondern sie so früh wie möglich zu identifizieren und durch Redundanzstrukturen korrigierbar zu machen.

Fehlerkorrektur funktioniert in der Quantenwelt jedoch grundlegend anders als in klassischen Systemen. Eine direkte Messung eines Qubits zerstört dessen Superposition. Stattdessen nutzt man Syndrommessungen, die nur indirekt auf Fehler schließen lassen, ohne den Qubit-Zustand selbst zu beeinflussen.

Ein kodierter Qubit-Zustand wird daher durch eine Vielzahl physikalischer Qubits dargestellt. Fehler betreffen nur einige davon – und können durch Vergleich mit definierten Stabilitätsbedingungen (Stabilisatoren) entdeckt und kompensiert werden. Ein einfaches Beispiel dafür ist der Drei-Qubit-Bit-Flip-Code, in dem logisches |0\rangle durch |000\rangle und |1\rangle durch |111\rangle kodiert wird. Ein einzelner Bit-Flip-Fehler kann hier eindeutig erkannt und zurückgeführt werden.

Die Kodierung ist damit nicht nur ein Mittel zum Zweck, sondern ein aktiver Teil der Quantenarchitektur.

Relevanz kodierter Qubits für die Zukunft der Quantencomputer

Die Skalierung von Quantencomputern in Richtung praktikabler Anwendungen – etwa in der Moleküldynamik, Materialforschung oder Kryptographie – hängt unmittelbar von der Stabilität ihrer Qubits ab. Aktuelle Systeme arbeiten mit physikalischen Qubits, die eine sehr begrenzte Kohärenzzeit und hohe Fehlerraten besitzen. Selbst modernste Plattformen wie Google Sycamore oder IBM Eagle haben eine Fehlerwahrscheinlichkeit von ca. 1 Fehler pro 100 bis 1000 Gatteroperationen.

Für viele relevante Quantenalgorithmen, wie die Faktorisierung großer Zahlen mittels Shor-Algorithmus oder die Simulation von Vielteilchensystemen, wäre eine solche Fehlerdichte katastrophal. Die benötigte Tiefe der Quanten-Schaltkreise übersteigt die zulässige Fehlerschwelle bei Weitem.

Kodierte Qubits schaffen hier die Brücke zur sogenannten fehlertoleranten Quantenverarbeitung (Fault-Tolerant Quantum Computing, FTQC). In dieser Architektur wird jede logische Operation so ausgeführt, dass einzelne Fehler während der Berechnung erkannt und sofort korrigiert werden können – ohne Informationsverlust. Die Grundidee: Man benötigt eine genügend niedrige physikalische Fehlerwahrscheinlichkeit p, damit durch Kodierung und Fehlerkorrektur die logische Fehlerwahrscheinlichkeit p_{\text{logical}} exponentiell reduziert werden kann.

Die Schwelle, unterhalb derer FTQC möglich wird, liegt typischerweise bei etwa 10^{-3} bis 10^{-2} – je nach gewähltem Fehlerkorrekturcode.

Kurz gesagt: Ohne kodierte Qubits bleiben Quantencomputer ein instabiles, akademisches Konstrukt. Mit ihnen jedoch eröffnen sich Pfade zu echten wissenschaftlichen Durchbrüchen und industrieller Anwendung. Sie sind das Fundament für den Übergang von der gegenwärtigen NISQ-Ära (Noisy Intermediate-Scale Quantum) zur Ära fehlertoleranter, skalierbarer Quantenmaschinen.

Grundlagen: Von physikalischen zu logischen Qubits

Kodierte Qubits entstehen nicht im Vakuum – sie bauen auf der physikalischen Realisierung von Qubits auf und erweitern diese durch strukturelle Kodierung. Der Schritt von physikalischen zu logischen Qubits markiert eine zentrale evolutionäre Etappe im Quantencomputing: von der reinen Quantenkontrolle zur skalierbaren, robusten Informationsverarbeitung. Dieses Kapitel beleuchtet die Natur physikalischer Qubits, definiert den Begriff des logischen Qubits und erläutert, warum Fehlerkorrektur im Zentrum dieser Entwicklung steht.

Physikalische Qubits: Die fundamentalen Baueinheiten

Physikalische Qubits sind die real existierenden Träger quantenmechanischer Zustände – also die „Hardware-Ebene“ eines Quantencomputers. Ihre Aufgabe ist es, einen zweidimensionalen Hilbertraum zu realisieren, in dem sich die Superposition von |0\rangle und |1\rangle darstellen und manipulieren lässt. Verschiedene physikalische Plattformen haben sich hierfür etabliert:

Supraleitende Qubits

Diese basieren auf Josephson-Kontakten, die bei tiefen Temperaturen quantisierte Energieniveaus in supraleitenden Schaltkreisen erlauben. Beispiele: Transmon-, Flux- und Xmon-Qubits.

Ionenfallen

Einzelne geladene Atome werden in elektromagnetischen Feldern eingefangen. Ihre elektronischen oder hyperfeinen Zustände dienen als Qubit-Basis. Sie bieten außergewöhnlich lange Kohärenzzeiten.

Photonenbasierte Qubits

Polarisation, Pfad oder Zeit-Bin-Zustände von Photonen kodieren Quanteninformation. Diese Systeme eignen sich besonders für Quantenkommunikation.

Festkörperbasierte Qubits

Darunter fallen Spin-Qubits in Quantenpunkten, NV-Zentren in Diamanten und Donator-Qubits in Silizium. Sie versprechen eine Integration mit existierender Halbleitertechnologie.

Unabhängig vom physikalischen Trägermedium gelten ähnliche Herausforderungen:

• Rauschanfälligkeit
• Begrenzte Kohärenzzeit
• Unvollkommene Gate-Fidelitäten

Die Fehlerraten physikalischer Qubits bewegen sich typischerweise im Bereich von 10^{-2} bis 10^{-4} – zu hoch für längere, komplexe Quantenberechnungen.

Logische Qubits: Abstraktion und Schutz durch Kodierung

Ein logischer Qubit entsteht durch Kodierung mehrerer physikalischer Qubits. Ziel ist es, einen logischen Zustand |\psi_L\rangle robust gegenüber den typischen Fehlermechanismen zu machen. Die Grundidee besteht darin, einen logischen zweidimensionalen Hilbertraum in einen höherdimensionalen Raum zu „embedden“, etwa so:

|\psi_L\rangle = \alpha |0_L\rangle + \beta |1_L\rangle

Dabei sind |0_L\rangle und |1_L\rangle keine einzelnen Zustände, sondern bestimmte Superpositionen aus vielen physikalischen Qubits. Typischerweise liegt die Anzahl benötigter physikalischer Qubits pro logischem Qubit im Bereich von 7 (Steane-Code) bis über 100 (Surface Code mit mehreren Korrekturstufen).

Strukturvorteile logischer Qubits

• Fehlertoleranz: Einzelne Fehler können erkannt und korrigiert werden.
• Erweiterbarkeit: Logische Qubits lassen sich in größere Netzwerke integrieren.
• Modularisierung: In modularen Architekturen lassen sich logische Qubits transportieren und koppeln.

Beispiele kodierter Zustände

Ein einfaches Beispiel ist der Drei-Qubit-Code zum Schutz vor Bit-Flip-Fehlern:

|0_L\rangle = |000\rangle,\quad |1_L\rangle = |111\rangle

Ein Bit-Flip auf einem Qubit, etwa |000\rangle \rightarrow |010\rangle, lässt sich durch Mehrheitsabstimmung korrigieren.

Diese einfache Idee wird in moderner Kodierung durch ausgeklügelte Schemata erweitert – mit dem Ziel, alle möglichen Fehlerarten (nicht nur Bit-Flip, sondern auch Phase-Flip und deren Kombinationen) zu kontrollieren.

Quantenfehlerkorrektur: Warum kodierte Qubits notwendig sind

Fehlerkorrektur ist in der klassischen Informatik ein bewährtes Verfahren – Paritätsbits, CRC-Prüfsummen oder Hamming-Codes sind Beispiele. Doch im Quantenkontext ist sie besonders herausfordernd, da:

• Zustände nicht direkt messbar sind, ohne sie zu zerstören
• Fehler kontinuierlich und probabilistisch auftreten
• Superposition und Verschränkung erhalten bleiben müssen

Die Quantenfehlerkorrektur (Quantum Error Correction, QEC) wurde in den 1990er Jahren revolutioniert, als Peter Shor und Andrew Steane erste funktionsfähige Codes präsentierten. Das Shor-Schema etwa nutzt 9 Qubits, um ein logisches Qubit zu kodieren, und kann sowohl Bit- als auch Phase-Flips erkennen und korrigieren.

Zentrale Elemente sind:

Fehler-Syndrome

Messbare Größen, die anzeigen, ob ein Fehler vorliegt, ohne den logischen Zustand zu beeinflussen.

Stabilisatorformalismus

Ein mathematischer Rahmen, um kodierte Zustände und ihre Symmetrien durch sogenannte Stabilisatoroperatoren zu charakterisieren.

Ein Beispiel: Wenn der Stabilisator S = Z_1 Z_2 für einen kodierten Zustand |\psi\rangle gilt, dann muss:

S|\psi\rangle = |\psi\rangle

Ein Fehler, der diese Gleichung verletzt, kann so erkannt werden, ohne den Zustand selbst zu messen.

Fehlerkorrigierende Schwelle

Für jeden QEC-Code existiert eine Fehlerschwelle p_{\text{th}}. Wenn die physikalische Fehlerwahrscheinlichkeit p < p_{\text{th}} liegt, kann durch Kodierung ein exponentieller Vorteil erzielt werden:

p_{\text{logical}} \propto \left( \frac{p}{p_{\text{th}}} \right)^{(d+1)/2}

Dabei ist d die Distanz des Codes – also die minimale Anzahl physikalischer Fehler, die nötig sind, um einen logischen Fehler zu erzeugen.

Praktischer Nutzen

• Verlängerung der nutzbaren Kohärenzzeit
• Fehlertolerante Ausführung quantenlogischer Operationen (Logical Gates)
• Skalierung zu großen Quantenschaltkreisen mit kontrollierter Fehlerrate

Kodierte Qubits und ihre Fehlerkorrekturmechanismen sind damit nicht nur nützlich, sondern absolut unverzichtbar auf dem Weg zu praktisch einsetzbaren Quantencomputern.

Prinzipien der Quantenfehlerkorrektur

Die Fähigkeit eines Quantencomputers, korrekte Ergebnisse zu liefern, hängt direkt davon ab, wie effektiv er seine empfindlichen Qubits vor Störungen schützt. Die Quantenfehlerkorrektur stellt daher eine unverzichtbare Säule der modernen Quantentechnologie dar. Sie basiert auf dem Grundgedanken, dass Fehler zwar unvermeidlich sind – aber dennoch erkannt und rückgängig gemacht werden können, solange sie strukturiert auftreten. Dieses Kapitel stellt die Grundlagen dieser Methodik dar.

Fehlerarten im Quantenkontext: Bit-Flip, Phase-Flip, Dekohärenz

Im klassischen digitalen Kontext gibt es im Wesentlichen einen einzigen Fehler: das Bit-Flip – ein Wechsel von 0 zu 1 oder umgekehrt. In der Quantenwelt dagegen sind Fehler vielschichtiger. Ein Qubit kann nicht nur den Zustand wechseln, sondern auch seine Phase verlieren oder in Superpositionen entarten, die nicht mehr eindeutig kontrollierbar sind. Drei elementare Fehlermechanismen dominieren:

Bit-Flip-Fehler (X-Fehler)

Dies entspricht einem klassischen Fehler, bei dem |0\rangle \rightarrow |1\rangle oder |1\rangle \rightarrow |0\rangle. Mathematisch wird dies durch die Pauli-X-Operation beschrieben:

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

Ein auf |\psi\rangle = \alpha|0\rangle + \beta|1\rangle angewandter Bit-Flip ergibt:

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

Phase-Flip-Fehler (Z-Fehler)

Hier bleibt die Besetzung gleich, aber die relative Phase ändert sich. Der Zustand |\psi\rangle = \alpha|0\rangle + \beta|1\rangle wird zu:

Z|\psi\rangle = \alpha|0\rangle - \beta|1\rangle

mit dem Operator:

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

Phase-Flips sind spezifisch für die Quantenwelt und in klassischen Systemen unbekannt.

Kombinierte Fehler & Dekohärenz (Y-Fehler)

Eine Kombination aus Bit-Flip und Phase-Flip nennt man Y-Fehler, mit dem Operator:

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

Diese entstehen etwa durch spontane Emission oder inhomogene Kopplung an die Umgebung.

Dekohärenz

Ein durch die Umwelt verursachter stochastischer Prozess, bei dem die Superposition zerstört wird. Formal modelliert durch ein gemischtes Zustandsmodell, etwa mittels Dichteoperatoren \rho. Der reine Zustand |\psi\rangle entwickelt sich zu einem klassischen Mischzustand:

\rho = \sum_i p_i |\psi_i\rangle \langle \psi_i|

Die Quantenfehlerkorrektur muss alle diese Fehlerarten kompensieren können – nicht nur einzelne Bit- oder Phase-Flips.

Die drei Säulen der Fehlerkorrektur: Erkennung, Syndrom-Messung, Wiederherstellung

Quantenfehlerkorrektur basiert auf einem dreistufigen Mechanismus, der systematisch entwickelt wurde, um die oben beschriebenen Fehler zu neutralisieren:

Fehlererkennung

Ohne direkte Messung des Qubit-Zustands muss festgestellt werden, ob ein Fehler aufgetreten ist. Dazu wird Redundanz verwendet: Ein logischer Zustand wird über mehrere physikalische Qubits verteilt, sodass Abweichungen durch Vergleich identifiziert werden können.

Syndrom-Messung

Die eigentliche Kunst liegt in der Syndrommessung: Es werden spezielle Operatoren (Stabilisatoren) auf das kodierte System angewendet, deren Eigenwerte \pm1 anzeigen, ob ein Fehler stattgefunden hat. Dabei wird nicht der logische Zustand gemessen, sondern nur dessen Konsistenz geprüft.

Ein Beispiel für einen Stabilisator:

S = Z_1 Z_2

Wenn S|\psi\rangle = -|\psi\rangle, hat ein Fehler zwischen Qubit 1 und 2 stattgefunden.

Wiederherstellung

Ist das Fehler-Syndrom bekannt, kann ein gezielter Korrekturoperator angewendet werden, um den ursprünglichen Zustand wiederherzustellen. Die Wiederherstellung erfolgt mit minimalem Eingriff, sodass die Quanteninformation nicht zusätzlich gestört wird.

Zusammengefasst:

Diese drei Säulen bilden das Fundament jedes fehlerkorrigierenden Codes.

Das [[9,1,3]]-Shor-Kodierungsschema als historischer Ausgangspunkt

Der erste funktionierende Quantenfehlerkorrekturcode wurde 1995 von Peter Shor vorgestellt – ein monumentaler Durchbruch, der die Tür zum skalierbaren Quantencomputing aufstieß.

Struktur des Shor-Codes

Der Shor-Code verwendet 9 physikalische Qubits, um 1 logischen Qubit darzustellen. Die Bezeichnung [[9,1,3]] bedeutet:

• 9 physikalische Qubits
• 1 logisches Qubit
• Fehlerdistanz 3 (d.h. bis zu einem Fehler korrigierbar)

Der Code kombiniert zwei Schutzschichten:

• Phase-Flip-Schutz: über drei Blöcke von jeweils drei Qubits
• Bit-Flip-Schutz: innerhalb der Blöcke durch dreifache Redundanz

Logische Zustände im Shor-Code

|0_L\rangle = \frac{1}{2\sqrt{2}} \left( |000\rangle + |111\rangle \right)^{\otimes 3}

|1_L\rangle = \frac{1}{2\sqrt{2}} \left( |000\rangle - |111\rangle \right)^{\otimes 3}

Diese Superpositionen erlauben sowohl die Erkennung von Bit- als auch von Phase-Flips durch geeignete Kombination von Stabilisatormessungen.

Bedeutung und Grenzen

Der Shor-Code demonstrierte erstmals, dass eine vollständige Fehlerkorrektur im Quantenregime prinzipiell möglich ist. Er war nicht als praktischer Code gedacht, sondern als Beweis für die Machbarkeit.

Sein Overhead ist beträchtlich – neun Qubits pro logischem Qubit – und seine praktische Implementierung ist komplex. Dennoch diente er als Blaupause für nachfolgende, effizientere Kodierungsschemata wie den Steane-Code und Surface Codes.

Kodierungsstrategien für Qubits

Die Entwicklung von Kodierungsstrategien zur Fehlerkorrektur in Quantencomputern ist eng verbunden mit dem Ziel, Qubits trotz ständiger Dekohärenzprozesse langfristig kontrollierbar zu machen. Während der Shor-Code den historischen Grundstein legte, haben sich seither zahlreiche leistungsfähigere Konzepte etabliert. Dieses Kapitel stellt drei zentrale Strategien vor, die heute in Forschung und Praxis dominieren.

Stabilizer Codes: Ein systematischer Zugang

Stabilizer Codes bilden die mathematische Grundlage zahlreicher moderner Quantenfehlerkorrekturverfahren. Sie ermöglichen eine systematische Konstruktion kodierter Qubits über Gruppenoperationen aus den Pauli-Matrizen.

Grundidee

Ein Stabilizer-Code definiert eine Menge von Operatoren {S_i}, genannt Stabilisatoren, die gemeinsam den erlaubten Raum für die kodierten Zustände festlegen. Ein Zustand |\psi\rangle ist genau dann gültig, wenn er von allen Stabilisatoren unverändert bleibt:

S_i |\psi\rangle = |\psi\rangle \quad \forall i

Die Gruppe \mathcal{S} der Stabilisatoren ist eine abelsche Untergruppe der n-Qubit-Pauli-Gruppe \mathcal{P}_n, wobei jedes S_i ein Produkt aus X-, Y- oder Z-Operatoren auf unterschiedlichen Qubits ist.

Beispiel: Der 5-Qubit-Code ([[5,1,3]])

Der kleinste perfekte Quantenfehlerkorrekturcode nutzt 5 Qubits, um ein logisches Qubit zu kodieren. Er kann jede einzelne Pauli-Fehleroperation auf einem der fünf Qubits erkennen und korrigieren.

Die vier unabhängigen Stabilisatoren {S_1, S_2, S_3, S_4} definieren einen zweidimensionalen Unterraum – genau die Dimension eines logischen Qubits.

Vorteile

• Klar definierter mathematischer Formalismus
• Effiziente Implementierung für viele Codes
• Fehlerdiagnose über Messung von Stabilisatoren

Einschränkungen

• Praktische Konstruktion nicht immer einfach
• Rechenintensiv bei wachsender Anzahl physikalischer Qubits

Stabilizer Codes bilden das Rückgrat komplexerer Kodierungsansätze wie den CSS- und Surface Codes.

CSS-Codes: Calderbank-Shor-Steane-Strukturen

Die CSS-Codes (benannt nach Calderbank, Shor und Steane) sind eine Klasse von Stabilizer-Codes mit spezieller Struktur, die auf klassischen Fehlerkorrekturcodes basiert. Sie kombinieren zwei lineare klassische Codes – einen für Bit-Flips, den anderen für Phase-Flips.

Mathematischer Aufbau

Ein CSS-Code basiert auf zwei binären linearen Codes C_1 und C_2 mit:

C_2 \subset C_1

Dabei korrigiert C_1 Bit-Fehler und C_2^\perp Phase-Fehler. Die Dimension des resultierenden Codes ergibt sich als:

k = \dim(C_1) - \dim(C_2)

Ein bekanntes Beispiel ist der Steane-Code ([[7,1,3]]), der auf dem klassischen [7,4,3]-Hamming-Code basiert.

Vorteile

• Klare Trennung von Bit- und Phase-Fehlern
• Gute Kompatibilität mit klassischen Kodierungstheorien
• Günstige Bedingungen für einige logische Gatteroperationen

Praktische Anwendung

CSS-Codes sind insbesondere für erste Hardware-Demonstrationen nützlich, da ihre Syndrome effizient messbar und ihre Kodierung gut verstanden ist. Sie bieten außerdem einen strukturierten Weg zu fehlertoleranten logischen Operationen, etwa durch sogenannte transversal ausführbare Gatter (siehe Abschnitt 9).

Topologische Codes: Schutz durch geometrische Robustheit

Topologische Codes nutzen nicht nur algebraische, sondern auch geometrische Strukturen zur Fehlerunterdrückung. Die Quanteninformation wird in globalen topologischen Eigenschaften kodiert, die gegenüber lokalen Störungen immun sind.

Surface Code: Der prominenteste Vertreter

Der Surface Code basiert auf einem zweidimensionalen Gitter von Qubits, die in Wechselwirkung zueinander stehen. Die Stabilisatoren sind lokal definierte Operatoren, die über Plaquettes (Zellen) und Kanten operieren:

• X-Stabilisatoren: Produkte von X-Operatoren an „Stern“-Konfigurationen
• Z-Stabilisatoren: Produkte von Z-Operatoren an „Plaquette“-Flächen

Ein Beispiel:

A_s = \prod_{i \in \text{Stern}(s)} X_i, \quad B_p = \prod_{i \in \text{Plaquette}(p)} Z_i

Die logischen Zustände ergeben sich aus nicht-kontraktiblen Schleifen auf der Oberfläche – etwa entlang der Ränder des Gitters.

Topologischer Schutz

Fehler, die nur lokal auftreten (z. B. einzelne Qubit-Flips), können den globalen Zustand nicht beeinflussen, solange sie keine topologisch nichttriviale Struktur erzeugen.

Dieser Schutz ist physikalisch motiviert und besonders effektiv in Systemen, die ohnehin gitterartige Strukturen aufweisen – wie supraleitende Qubits auf Chips.

Vorteile

• Hohe Fehlertoleranz bei praktischen Fehlerschwellen (~1%)
• Gute Skalierbarkeit
• Lokale Wechselwirkungen und Messungen – ideal für aktuelle Hardware

Herausforderungen

• Erfordert viele physikalische Qubits pro logischem Qubit (100+)
• Komplexe Fehlerdiagnose bei großflächigen Gittern

Trotz dieser Herausforderungen gilt der Surface Code heute als führende Architektur für fehlertolerante Quantencomputer – etwa bei Google, IBM und anderen Spitzenprojekten.

Surface Codes: Die führende Architektur kodierter Qubits

In der Landschaft der Quantenfehlerkorrektur ragen Surface Codes als praktikabelstes und skalierbarstes Verfahren heraus. Ihre topologische Natur, die lokale Interaktion zwischen Qubits und ihre Fehlertoleranzschwelle von über einem Prozent machen sie zur Architektur der Wahl für viele industrielle Entwicklungen – insbesondere bei supraleitenden Quantenprozessoren. Surface Codes sind die Grundlage für den Übergang von NISQ-Systemen zu fehlertoleranten Quantencomputern.

Struktur und Logik hinter Surface Codes

Surface Codes sind topologische Stabilisatorcodes, die auf einem zweidimensionalen Gitter physikalischer Qubits aufgebaut sind. Jedes Qubit ist einem Gitterpunkt zugeordnet, wobei das Gitter in zwei Arten von Operatoren unterteilt ist:

Plaquettes und Sterne

Die zwei Grundbausteine der Surface-Code-Struktur sind:

• Plaquette-Operatoren (Z-Stabilisatoren): Bestehen aus dem Produkt von Z-Operatoren an den vier Ecken eines Quadrats. B_p = Z_1 Z_2 Z_3 Z_4
• Stern-Operatoren (X-Stabilisatoren): Bestehen aus dem Produkt von X-Operatoren an den vier Kanten, die sich an einem gemeinsamen Punkt treffen. A_s = X_1 X_2 X_3 X_4

Diese Stabilisatoren messen, ob sich der Zustand im erlaubten Unterraum befindet. Ein Fehler verändert das Syndrom eines oder mehrerer dieser Operatoren.

Logische Qubits

Logische Qubits werden durch nicht-kontraktible Linien auf dem Gitter kodiert. Dies bedeutet: Ein logisches Bit ist eine globale Eigenschaft der Oberfläche und verändert sich nur, wenn ein Fehler entlang einer durchgehenden Linie (z. B. von Rand zu Rand) auftritt.

Ein logischer Z-Operator ist z. B. eine Kette von Z-Operatoren entlang einer horizontalen Linie:

Z_L = Z_1 Z_2 \dots Z_d

Ein Bit-Flip-Fehler auf einem einzelnen Qubit stört diese Linie nicht – solange sie nicht vollständig durchquert wird.

Code-Distanz

Die Code-Distanz d des Surface Codes entspricht der minimalen Anzahl physikalischer Fehler, die nötig sind, um einen logischen Fehler zu erzeugen. Je größer d, desto robuster ist der logische Qubit.

Die Gesamtanzahl physikalischer Qubits wächst dabei quadratisch:

n \approx (2d-1)^2

Vorteile für Skalierbarkeit und Fehlertoleranz

Surface Codes bieten eine Vielzahl praktischer Vorteile, die sie zum dominanten Architekturmodell machen:

Hohe Fehlertoleranz

Der Surface Code toleriert physikalische Fehler bis zu einer Schwelle von etwa:

p_{\text{th}} \approx 1%

Dies bedeutet: Solange die Fehlerrate pro Operation unter dieser Schwelle liegt, kann durch Vergrößerung des Codes die logische Fehlerrate exponentiell reduziert werden:

p_L \sim \left( \frac{p}{p_{\text{th}}} \right)^{(d+1)/2}

Lokale Interaktion

Alle notwendigen Operationen (Syndrom-Messung, Fehlerkorrektur) erfordern nur lokale Wechselwirkungen zwischen benachbarten Qubits. Das erleichtert die physikalische Implementierung, besonders in Chips mit begrenzten Verbindungsreichweiten.

Geometrische Einfachheit

Das zweidimensionale Layout ist gut mit lithographisch herstellbaren Qubit-Chips kompatibel – wie sie z. B. von Google, IBM oder Rigetti eingesetzt werden.

Modulbasierte Erweiterbarkeit

Größere Quantencomputer lassen sich modular aus kleineren Gittereinheiten zusammensetzen. Dadurch ist Fehlertoleranz skalierbar, ohne die gesamte Architektur neu gestalten zu müssen.

Anforderungen an physikalische Qubit-Ressourcen

Trotz aller Vorteile ist die Surface-Code-Architektur sehr ressourcenintensiv – besonders im Hinblick auf physikalische Qubits pro logischem Qubit.

Qubit-Anzahl

Um einen logischen Qubit mit Code-Distanz d zu realisieren, benötigt man etwa:

n \approx (2d-1)^2 \approx 4d^2

Ein häufig genanntes Beispiel:

• Code-Distanz d = 21 → etwa 1700 physikalische Qubits
• ergibt eine logische Fehlerwahrscheinlichkeit p_L \sim 10^{-9}, geeignet für stabile Berechnungen

Gatteroperationen und Synchronisation

Zusätzlich zur Qubit-Anzahl stellt auch die Kontrollpräzision eine Herausforderung dar:

• Jeder Fehler-Syndrom-Messzyklus benötigt mehrere Einzelgatter.
• Diese müssen synchronisiert und wiederholt werden – typischerweise 10.000+ Zyklen pro Algorithmus.

Kühlung und Fehlersignale

Die Surface-Code-Plattform ist meist mit supraleitenden Qubits verbunden, die eine Kühlung auf ca. 10–15 mK erfordern. Die dabei erzeugten Fehlersyndrome müssen extrem schnell ausgelesen und verarbeitet werden – was leistungsfähige Quantenklassik-Hybridsysteme voraussetzt.

Zusammenfassend: Surface Codes kombinieren physikalische Realisierbarkeit mit hoher Fehlertoleranz. Trotz erheblicher Ressourcenanforderungen sind sie heute das praktikabelste Werkzeug für skalierbare Quanteninformationsverarbeitung – und das Kernstück der Strategien führender Technologiekonzerne und akademischer Quanteninitiativen.

Hardware und kodierte Qubits

Kodierte Qubits sind keine rein abstrakte Konstruktion – sie müssen physikalisch realisiert, kontrolliert und ausgelesen werden. Je nach Plattform ergeben sich dabei spezifische Herausforderungen und Chancen. Manche Architekturen – wie supraleitende Schaltkreise – setzen auf externe Kodierung durch Surface Codes, andere – wie topologische Qubits – tragen den Fehlerkorrekturmechanismus bereits in ihrer physikalischen Natur. Dieses Kapitel zeigt die Vielfalt realer Quantenhardware und ihre Fähigkeit, kodierte Qubits darzustellen.

Supraleitende Qubits und ihre Kodierungsfähigkeiten

Supraleitende Qubits gelten derzeit als führende Plattform in der industriellen Quantenentwicklung – nicht zuletzt wegen ihrer guten Skalierbarkeit und Integration in Chip-basierte Systeme.

Transmon- und Xmon-Qubits

Die am weitesten verbreiteten Varianten sind sogenannte Transmon-Qubits, die auf Josephson-Junctions basieren und in Mikrowellenresonatoren eingebettet sind. Eine Variante davon, die Xmon-Architektur, wurde u. a. von Google in „Sycamore“ verwendet. Sie bietet:

• Relativ niedrige Gate-Zeiten (~20–40 ns)
• Kohärenzzeiten bis zu 200 µs
• Lokale Kopplungsmechanismen für Surface-Code-Gitter

Kodierung mittels Surface Codes

Die Surface-Code-Architektur passt ideal zur Geometrie supraleitender Chips:

• Plaquette- und Sternstabilisatoren können durch lokale Gatter realisiert werden.
• Hochfrequente Syndrome-Messungen sind mit kryogener Verstärkungstechnologie möglich.
• Mehrere Unternehmen, darunter Google, IBM, Rigetti und IQM, verfolgen diese Strategie.

Ein Beispiel: Für ein logisches Qubit mit d = 13 benötigt Google etwa 441 physikalische Qubits.

Limitierende Faktoren

• Kryogene Infrastruktur mit extremen Kühlanforderungen (ca. 10 mK)
• Cross-Talk zwischen benachbarten Qubits
• Fehlerhafte Leseköpfe als Engpass für Syndrome

Trotzdem bleibt die supraleitende Plattform die zurzeit am weitesten fortgeschrittene für großskalige kodierte Qubits.

Trapped Ions und modulare Fehlerkorrektur

Ionenfallen (Trapped Ions) bieten einen alternativen Zugang zu Quantencomputing – mit völlig anderer Technologie, aber exzellenter Kohärenz.

Physikalische Prinzipien

Einzelne geladene Ionen (z. B. \text{Yb}^+, \text{Ca}^+) werden in elektromagnetischen Feldern gehalten. Ihre inneren Zustände dienen als Qubits, kontrolliert durch Laserimpulse. Typische Merkmale:

• Kohärenzzeiten von mehreren Sekunden bis Minuten
• Hohe Gate-Fidelitäten > 99.9 %
• All-to-all Kopplung innerhalb eines Ionenstrangs

Kodierte Qubits in Ionenfallen

Fehlerkorrektur kann auf verschiedene Arten implementiert werden:

• Bacon-Shor- und Steane-Codes für kleine Systeme
• Modulare Architekturen, bei denen Ionenstränge als Submodule fungieren
• Verbindungsstrukturen durch photonische Schnittstellen (Quantum Interconnects)

Beispiel: Das Unternehmen Quantinuum hat Demonstrationen mit [[7,1,3]]-Codes und logischen Gattern mit hoher Zuverlässigkeit durchgeführt.

Stärken und Herausforderungen

Stärken:

• Sehr geringe Fehler
• Hochpräzise Einzelqubit-Kontrolle
• Intrinsisch gute Gate-Fidelity

Herausforderungen:

• Geringere Operationen pro Sekunde (langsamere Gate-Zyklen)
• Schwierige Skalierung bei steigender Qubit-Zahl
• Laserkontrolle und Mikromotion als potenzielle Fehlerquellen

Topologische Qubits: Kodierung als intrinsisches Merkmal

Ein besonders faszinierender Ansatz sind topologische Qubits, bei denen die Quanteninformation physikalisch in nichtlokalen, topologischen Eigenschaften gespeichert wird – statt durch explizite Kodierung.

Anyonen und nicht-Abelsche Statistik

Topologische Qubits basieren auf der Existenz von nicht-Abelschen Anyonen – quasiteilchenartige Zustände, die bei Vertauschung (Braiding) nicht nur eine Phase, sondern einen neuen Quantenzustand erzeugen.

Ein Beispiel: Majorana-Zustände in topologischen Supraleitern, die als Kandidaten für fehlerresistente Qubits gelten. Zwei Majorana-Moden bilden ein Qubit, das nur durch Nichtlokales beeinflusst werden kann.

Vorteile

• Intrinsische Fehlertoleranz: Nur globale Manipulationen (z. B. Braiding) verändern Zustände.
• Passiver Schutz: Schutz ist durch Physik, nicht durch aktive Fehlerkorrektur gegeben.

Herausforderungen

• Noch keine experimentelle Demonstration stabiler topologischer Qubits
• Materialwissenschaftlich extrem schwierig (z. B. topologische Supraleiter auf Halbleitern)

Das Unternehmen Microsoft (Station Q) verfolgt mit Nachdruck diesen Ansatz – bisher mit experimenteller Evidenz, aber noch ohne funktionsfähigen Qubit-Prototyp.

Kodierte Qubits in Photonen- und Siliziumplattformen

Neben supraleitenden und ionenbasierten Architekturen existieren zwei aufstrebende Plattformen mit eigenständigem Potenzial:

Photonische Qubits

Photonen sind exzellente Träger von Quanteninformation – besonders für Kommunikation. Für kodierte Qubits kommen Cluster States, Boson Sampling und Linear Optical Quantum Computing (LOQC) zum Einsatz.

• Vorteil: Dekohärenzarm
• Nachteil: Keine natürlichen Wechselwirkungen → Logikgatter schwer zu implementieren

Neue Konzepte wie Bosonische Codes (z. B. Gottesman-Kitaev-Preskill-Code) bieten eine Möglichkeit zur Fehlerkorrektur durch kontinuierlich variable Zustände in Resonatoren.

Siliziumbasierte Qubits

Diese nutzen Elektronenspin oder Donator-Qubits (z. B. Phosphor in Si), eingebettet in herkömmliche CMOS-Technologie.

• Vorteil: Kompatibilität mit bestehender Halbleiterindustrie
• Kodierung: Stabilizer- und LDPC-Codes sind in Entwicklung

Führende Forschungsinstitutionen: UNSW Sydney, Intel, QuTech Delft

Die Hardware-Plattform entscheidet maßgeblich über die Art, Komplexität und Effektivität der implementierten kodierten Qubits. Während supraleitende Qubits derzeit den Vorsprung haben, öffnen neue Plattformen Wege zu hybriden und spezialisierteren Architekturen – jede mit ihrem eigenen Beitrag zur Realisierung fehlertoleranter Quanteninformation.

Kodierte Qubits in der Praxis: Implementierung und Kontrolle

Die Theorie kodierter Qubits ist komplex – ihre praktische Umsetzung ist noch anspruchsvoller. Zwischen abstrakter Kodierung und konkreter Hardwarekontrolle liegen zahlreiche technische Herausforderungen: präzise Steuerimpulse, fehlerfreie Messungen, schnelle Auswertung von Syndromen und nahtlose Integration in Steuerarchitekturen. Dieser Abschnitt beleuchtet die zentralen Aspekte der praktischen Implementierung und Kontrolle kodierter Qubits.

Physikalische Anforderungen an Kontrolle und Messung

Jede Fehlerkorrekturstrategie steht und fällt mit der Fähigkeit, den Zustand eines kodierten Systems präzise zu manipulieren und auszulesen, ohne dabei die Quanteninformation zu zerstören.

Einzel- und Mehrqubit-Gatter

Für effektive Kontrolle kodierter Qubits müssen logische Operationen auf viele physikalische Qubits gleichzeitig angewendet werden. Diese bestehen aus Sequenzen von:

• Einzelqubit-Gattern wie X, Y, Z, H, T
• Zweiqubit-Gattern wie CNOT oder CZ

Fehlertolerante Codes erfordern meist transversale Gatter, bei denen jede physikalische Operation unabhängig auf korrespondierenden Qubits eines Codes wirkt – um Fehlerausbreitung zu verhindern.

Messpräzision

Kodierte Qubits erfordern nicht-destruktive Messungen bestimmter Operatoren (z. B. Stabilisatoren). Diese Messungen sind indirekt: Man liest nicht das Qubit direkt aus, sondern ein Hilfsqubit (Ancilla), das zuvor mit einem bestimmten Operator gekoppelt wurde.

Beispiel: Zur Messung eines Stabilisators Z_1 Z_2 Z_3 Z_4 koppelt man die vier Qubits über CNOTs an ein Ancilla-Qubit, das dann gemessen wird. Das Ergebnis (+1 oder −1) ergibt das Syndrom dieses Operators.

Timing und Wiederholung

Fehlerkorrektur ist ein zyklischer Prozess, der sich viele tausend Male pro Sekunde wiederholen muss. Jede Runde besteht aus:

1. Gattersequenz für Syndrom-Messung
2. Messung der Ancillas
3. Auswertung des Fehler-Syndroms
4. Anwendung von Korrekturoperationen (sofern notwendig)

Je schneller und präziser dieser Zyklus abläuft, desto höher die nutzbare logische Kohärenzzeit.

Fehlersyndrome und ihre Interpretation

Die Auswertung der Syndrome ist das Herzstück jedes Fehlerkorrekturverfahrens. Sie entscheidet, ob ein Fehler vorliegt – und wenn ja, wo.

Was ist ein Fehler-Syndrom?

Ein Fehler-Syndrom ist die Signatur eines aufgetretenen Fehlers im Raum der Stabilisatoren. Es besteht aus einer Sammlung von \pm1-Werten für alle gemessenen Stabilisatoren {S_i}.

Wenn ein Syndromwert −1 auftritt, bedeutet das: Der Zustand befindet sich nicht im +1-Eigenraum des entsprechenden Stabilisators – also ist ein Fehler aufgetreten.

Dekodierung

Die große Herausforderung ist nun: Aus einem gegebenen Syndrom muss auf die wahrscheinlichste Fehlerkonfiguration geschlossen werden.

Dieser Schritt wird Dekodierung genannt. Es handelt sich um ein Optimierungsproblem, bei dem aus einer Vielzahl möglicher Fehler jene mit der minimalen Wahrscheinlichkeitsstrafe gewählt wird.

Algorithmen dafür:

• Minimum Weight Perfect Matching (MWPM) – Standard bei Surface Codes
• Belief Propagation – bei LDPC-Codes
• Neural Decoders – ML-gestützte, trainierte Modelle für schnellere Auswertung

Zeitkritik und Korrektur

Die Dekodierung muss schneller erfolgen als die nächste Fehlerkorrekturrunde – sonst akkumulieren sich Fehler. Viele Systeme nutzen dafür dedizierte FPGAs oder spezielle Decoder-ASICs.

Ein korrektes Syndrom-Management ist essenziell, um logische Fehler frühzeitig zu unterbinden.

Softwaregestützte Steuerung kodierter Qubit-Systeme

Da die Anzahl physikalischer Qubits bei kodierten Systemen schnell in die Hunderte bis Tausende geht, wird Software zur zentralen Steuerinstanz. Sie ist verantwortlich für Koordination, Optimierung und Diagnose.

Steuerungs-Stacks

Moderne Quantencomputer bestehen aus einem mehrlagigen Software-Stack:

1. Low-Level Control (Mikrowellensteuerung, Laser-Pulse)
2. Fehlerkorrektur-Engine (Syndromauswertung, Decoder)
3. Compiler für logische Operationen
4. User-Interface für Algorithmendesign

Beispiel:

• IBM verwendet den Qiskit Runtime Service, der auch Surface-Code-Steuerung integriert.
• Google nutzt eine Kombination aus C++-basierter Qubitsteuerung und FPGA-Syndromauswertung.
• Quantinuum integriert tKet mit eigenen Fehlerkorrekturbibliotheken für Ionenfallen.

 Simulation und Testumgebungen

Bevor echte kodierte Qubits verwendet werden, werden die Prozesse häufig in Software emuliert:

• Fehlerkanal-Simulationen (Depolarisierungs-, Bit-/Phase-Flip-Modelle)
• Decoder-Leistungsanalysen
• Testen logischer Gates unter realistischen Bedingungen

Solche Simulationen helfen beim Verständnis der Fehlerdynamik und beim Optimieren der Hardware.

Zukunft: Autonome Fehlerkorrektur

Ein visionärer Trend ist der Aufbau autonomer Kontrollsysteme, bei denen:

• Fehlererkennung
• Dekodierung
• Reaktionslogik

komplett automatisiert ablaufen – teilweise mithilfe von Reinforcement Learning oder KI-basierter Fehleranalyse.

Fazit dieses Abschnitts: Die Umsetzung kodierter Qubits ist ein hochdynamisches Zusammenspiel zwischen Physik, Elektrotechnik, Informatik und Softwaredesign. Ohne präzise Kontrolle, exakte Fehleranalyse und intelligente Steuerung bliebe die Quanteninformation trotz Kodierung ungeschützt. Doch mit diesen Werkzeugen lässt sich die fundamentale Vision der fehlertoleranten Quantenverarbeitung Wirklichkeit werden.

Forschungsprojekte und Meilensteine

Kodierte Qubits sind längst keine theoretische Konstruktion mehr – sie sind zum Prüfstein realer Quantenhardware geworden. Forschungsgruppen auf der ganzen Welt arbeiten daran, den Übergang vom fehleranfälligen NISQ-Gerät hin zum fehlertoleranten Quantenprozessor zu schaffen. Dieser Abschnitt stellt vier maßgebliche Projekte vor, die als Wegbereiter für die praktische Umsetzung kodierter Qubits gelten.

Google Sycamore & Surface Code-Implementierung

Das bekannteste Projekt zur praktischen Anwendung kodierter Qubits stammt von Google Quantum AI in Santa Barbara. Die Plattform Sycamore – ein supraleitender Quantenprozessor – wurde weltbekannt durch das Experiment zur „Quantenüberlegenheit“ 2019. Doch für kodierte Qubits ist ein anderer Meilenstein bedeutend:

Fehlerkorrigierter Qubit-Kern

Im Jahr 2023 veröffentlichte Google eine Arbeit zur Implementierung eines logischen Qubits mittels Surface Code mit Code-Distanz d = 5 bis 9. Dabei wurde gezeigt:

• Wie logische Qubit-Zustände über ein Gitter von über 50 physikalischen Qubits realisiert wurden
• Dass sich die logische Fehlerrate exponentiell mit der Code-Distanz reduzierte, wie theoretisch vorhergesagt
• Dass kontinuierliche Fehlerkorrekturzyklen stabil funktionierten

Relevanz

Google demonstrierte damit erstmals auf Hardware-Niveau, dass eine Surface-Code-Kodierung nicht nur simuliert, sondern praktisch stabilisierend wirken kann. Dies gilt als kritischer Meilenstein auf dem Weg zum skalierbaren Quantencomputer.

ETH Zürich und modulare Fehlertoleranz

Die ETH Zürich – insbesondere die Gruppe um Prof. Andreas Wallraff – zählt zu den weltweit führenden Forschungsstellen für supraleitende Qubits und skalierbare Quantenarchitekturen.

Multiqubit-Module

Im Fokus steht hier die Entwicklung modularer Quantenprozessoren, bei denen kleinere kodierte Einheiten (z. B. 3×3 oder 5×5 Gitterblöcke) als Bausteine dienen, die über Bus-Resonatoren gekoppelt werden.

Solche Module ermöglichen:

• Lokalisierte Fehlerkorrektur
• Schnellere Entwicklungstests
• Bessere thermische Isolation einzelner Subsysteme

Verbindungsnetzwerke und Fehlerausbreitung

Die ETH forscht zudem an optimalen Verbindungstopologien, um Fehlerausbreitung zwischen Modulen zu minimieren – ein Thema von wachsender Bedeutung bei wachsenden Prozessorgrößen.

Microsofts Ansatz mit Majorana-Qubits

Microsoft verfolgt seit Jahren einen alternativen, topologischen Ansatz zur Fehlerkorrektur – mit dem Ziel, Qubits zu bauen, deren Zustände intrinsisch geschützt sind.

Majorana-Zustände

Im Zentrum stehen sogenannte Majorana-Zero-Modes, die in topologischen Supraleitern entstehen sollen – meist in Hybridsystemen aus Halbleitern (z. B. InSb) und Supraleitern (z. B. NbTiN).

Zwei räumlich getrennte Majorana-Moden definieren ein einziges logisches Qubit, das nur durch globale Operationen verändert werden kann – das Prinzip des topologischen Schutzes.

Station Q und Meilensteine

Das Forschungszentrum Microsoft Station Q arbeitet seit über einem Jahrzehnt an:

• Materialien zur stabilen Erzeugung von Majorana-Zuständen
• Messmethoden zur Bestätigung topologischer Eigenschaften
• Integrationsstrategien in skalierbare Architekturen

2022 meldete Microsoft Fortschritte in der Bestätigung topologischer Signaturen, jedoch ist ein stabiler Majorana-Qubit bisher nicht demonstriert worden.

Potenzielle Vorteile

• Passive Fehlerresistenz
• Weniger Overhead als Surface Codes
• Langfristiges Ziel: kombinierte Plattform mit Surface-Code-kompatiblen Gattern

IBM Quantum und das Ziel des „Logical Qubit“

Auch IBM Quantum verfolgt aktiv das Ziel eines funktionsfähigen logischen Qubits mit fehlertoleranter Kodierung – primär basierend auf supraleitenden Qubits und Surface Codes.

Roadmap bis 2029

IBM hat eine mehrstufige Roadmap veröffentlicht:

• 2023–2025: Demonstration logischer Qubits mit stabilisierter Fehlerkorrektur
• 2026–2029: Integration mehrerer logischer Qubits mit logischen Gattern und skalierbarer Kontrolle
• Ziel: Aufbau eines modularen Quantenprozessors mit 1000+ logischen Qubits

„Heron“ und „Condor“-Chips

Mit Chips wie Heron und Condor entwickelt IBM supraleitende Architekturen mit:

• Fehlerwahrscheinlichkeiten unter 10^{-3}
• Optimierter Qubit-Konnektivität für 2D-Surface-Code-Gitter
• Paralleler Fehlerauslesung und FPGA-gestützter Dekodierung

Logische Gatter und Crosstalk-Optimierung

IBM forscht zudem an fehlertoleranten logischen Gattern, z. B. transversal ausführbaren CNOTs, sowie an Crosstalk-Suppressionsstrategien, um logische Operationen in dichter Kodierung sicher auszuführen.

Diese vier Projekte repräsentieren komplementäre Strategien zur Realisierung kodierter Qubits:

Kodierte Qubits und die Zukunft des Quantencomputings

Kodierte Qubits markieren nicht nur einen technologischen Fortschritt – sie verkörpern den Übergang in eine neue Ära des Quantencomputings. Während die derzeitigen Systeme in der sogenannten NISQ-Zeit (Noisy Intermediate-Scale Quantum) operieren, ermöglichen kodierte Qubits die Entstehung fehlertoleranter Quantencomputer, die stabil, skalierbar und für reale Anwendungen bereit sind. Dieser Abschnitt untersucht diesen fundamentalen Wandel und die Rolle kodierter Qubits in der Zukunft der Quanteninformatik.

Von NISQ zur FTQC-Ära: Rolle kodierter Qubits beim Übergang

NISQ-Ära: Grenzen und Potenziale

Die NISQ-Ära – ein Begriff geprägt von John Preskill – beschreibt die aktuelle Generation von Quantenprozessoren:

• 50–1000 physikalische Qubits
• Hohe Fehlerraten (10^{-2} bis 10^{-3})
• Keine systematische Fehlerkorrektur
• Anwendungen: Variational Quantum Eigensolver (VQE), Quantum Approximate Optimization Algorithm (QAOA)

Diese Geräte sind hervorragend für die Erforschung hybrider Quantenklassik-Algorithmen geeignet, jedoch nicht in der Lage, lange und komplexe Berechnungen verlässlich durchzuführen.

FTQC-Ära: Fehlertoleranz als Voraussetzung

Der Übergang zur Fault-Tolerant Quantum Computing (FTQC)-Ära erfordert:

• Logische Qubits mit stabiler Fehlerkorrektur
• Fehlertolerante logische Gatter
• Fehlerkaskaden-Erkennung und -Behandlung in Echtzeit

Kodierte Qubits sind das zentrale Mittel, um die Hardwarefehler unter eine praktikable Schwelle p_{\text{th}} zu drücken und die Fehlerwahrscheinlichkeit p_L für logische Operationen zu kontrollieren.

Schwellenwerttheoreme

Ein zentraler theoretischer Pfeiler ist das Threshold Theorem:

Wenn p < p_{\text{th}}, kann durch Kodierung und Fehlerkorrektur jeder gewünschte Grad an Zuverlässigkeit erreicht werden – bei exponentiellem Ressourcenaufwand.

Beispiel: Für einen Surface Code mit p = 10^{-3} und Code-Distanz d = 21 ergibt sich eine logische Fehlerwahrscheinlichkeit von:

p_L \approx \left( \frac{10^{-3}}{10^{-2}} \right)^{(21+1)/2} \approx 10^{-10}

Ein Wert, der sogar für kryptographische Anwendungen ausreicht.

Fehlertolerante Quantenalgorithmen

Die Entwicklung fehlertoleranter Algorithmen ist eine eigenständige Forschungsdisziplin – denn nicht alle Algorithmen lassen sich 1:1 auf kodierte Qubits übertragen.

Transversale Gatter

Ein transversales Gatter ist ein logisches Gatter, das sich als eine Folge von unabhängigen physikalischen Operationen auf jeweils korrespondierenden Qubits zweier Codeblöcke realisieren lässt.

Beispiel: Ein transversal ausgeführter logischer CNOT:

\text{CNOT}L = \bigotimes{i=1}^n \text{CNOT}_i

Solche Gatter sind fehlertolerant, da Fehler nicht auf andere Qubits innerhalb des Blocks überspringen.

Magic-State Distillation

Viele wichtige Gatter (z. B. das T-Gatter) sind nicht transversal ausführbar und erfordern komplexere Techniken wie:

• State Injection
• Magic-State Distillation
• Teleportation-basierte Gatter

Diese Methoden sind aufwendig, aber essenziell für die vollständige Universalität im fehlertoleranten Quantenrechnen.

Compiler und Optimierung

Fehlertolerante Algorithmen benötigen spezialisierte Compiler-Optimierungen, um:

• Gatterfolgen auf logische Gatter zu mappen
• Dekodierzyklen zu synchronisieren
• Ressourcenbedarf zu minimieren

Führende Compiler-Frameworks: Qiskit, tKet, Cirq, OpenQL

Skalierbare Quantenarchitekturen durch Kodierung

Die Implementierung vieler kodierter Qubits erfordert nicht nur Fehlerkorrektur, sondern auch Architekturen, die modular, rekonfigurierbar und technisch kontrollierbar sind.

2D-Gitter und modulare Chips

• Surface-Code-Gitter lassen sich modular in Chips implementieren.
• Verbindungsnetzwerke (quantum interconnects) ermöglichen Kommunikation zwischen logischen Qubits auf separaten Chips.

Führende Plattformen: Google, IBM, ETH Zürich

Topologische Cluster States

Eine skalierbare Alternative ist die One-Way Quantum Computation mit topologisch kodierten Cluster-Zuständen. Dabei wird der gesamte Quantenalgorithmus durch eine Sequenz adaptiver Messungen auf einem vorher vorbereiteten kodierten Zustand ausgeführt.

Vorteile:

• Parallelisierung
• Intrinsische Kodierung in Zustandstopologie

Logikgatternetzwerke und Routing

In skalierbaren Architekturen müssen logische Qubits:

• miteinander interagieren
• verschoben, kopiert oder getauscht werden

Dies erfordert:

• Fehlerkorrigierte SWAP-Operationen
• Teleportationsroutinen
• Routingstrategien, z. B. in Quanten-Rechenclustern

Gesamtziel: Logische Infrastruktur

Langfristig entsteht eine fehlertolerante logische Infrastruktur, vergleichbar mit klassischen Prozessorarchitekturen – aber quantenmechanisch geschützt:

• Kodierte Register
• Kodierte logische Busse
• Kodierte Speicher-Arrays
• Kontrollierte Dekodierungs- und Neuzustandsinitialisierung

Fazit dieses Abschnitts: Kodierte Qubits sind nicht nur notwendig, um Quantencomputer vor Fehlern zu schützen – sie sind die architektonische Voraussetzung für skalierbare, zuverlässige Quantenprozessoren. Ob durch Surface Codes, modulare Cluster oder topologische Zustände: Die Zukunft des Quantencomputings ist logisch kodiert.

Kritische Betrachtung und offene Herausforderungen

Kodierte Qubits sind das Rückgrat fehlertoleranter Quantencomputer – doch sie bringen erhebliche technische und konzeptionelle Hürden mit sich. Die effiziente Realisierung solcher Systeme ist kein Selbstläufer. Dieses Kapitel beleuchtet die zentralen Herausforderungen: den extremen Ressourcenbedarf, das Spannungsfeld zwischen Fehlertoleranz und algorithmischer Effizienz sowie konkurrierende Ansätze, die Abhilfe versprechen.

Ressourcenbedarf und Overhead bei der Kodierung

Physikalischer Overhead

Kodierung bedeutet Redundanz – und Redundanz bedeutet Ressourcenverbrauch. Für einen logischen Qubit, der mit einem Surface Code kodiert ist, gilt in der Regel:

n_{\text{phys}} \approx d^2

Beispiel: Ein logischer Qubit mit Code-Distanz d = 25 benötigt rund 625 physikalische Qubits. Dazu kommen:

• Ancilla-Qubits für Stabilisator-Messungen
• Steuer- und Leseelektronik
• Kühlungs- und Synchronisationssysteme

Zeitlicher Overhead

Fehlerkorrektur ist zyklisch – jeder Berechnungsschritt erfordert zusätzliche Fehlererkennungs- und Dekodierungszyklen. Der effektive Rechentakt eines logischen Qubits ist daher um Größenordnungen langsamer als der eines physikalischen Qubits.

Logistik und Integration

Ein voll funktionsfähiger Quantenprozessor mit 1000 logischen Qubits könnte – je nach Code-Distanz – Millionen physikalische Qubits benötigen. Dies wirft Fragen auf nach:

• Chipgröße und Verdrahtung
• Fehlertoleranter Datenfluss
• Skalierbarkeit von Kühl- und Steuereinheiten

Kurzum: Der Ressourcenbedarf ist die zentrale technische Hürde auf dem Weg zur praktischen Skalierung.

Fehlertoleranz versus Rechenkomplexität

Tiefe logischer Gatter

Die Kodierung schützt die Information, erhöht aber die Tiefe der logischen Operationen – d. h. die Anzahl sequentieller Schritte, die zur Ausführung eines Algorithmus notwendig sind.

Ein einfaches logisches T-Gatter beispielsweise erfordert:

• Magic-State-Vorbereitung
• State Distillation
• State Injection

Diese Prozeduren erhöhen die Rechenlatenz und die Algorithmuskomplexität erheblich.

Beschränkung transversal ausführbarer Gatter

Nicht alle Gatter lassen sich transversal, also fehlertolerant, ausführen. Dies schränkt den direkten Entwurf universeller Quantenalgorithmen ein. Manche Codes benötigen:

• Code-Switching
• Gatter-Teleportation
• Measurement-Based Quantum Computing

Diese Verfahren sind aufwendig und fehleranfällig.

Balanceproblem

Es entsteht ein Spannungsfeld:

Die große Herausforderung liegt darin, diese Zielkonflikte zu balancieren und praktikable Kompromisse zu finden.

Alternative Ansätze: Quantum LDPC Codes, bosonische Codes u.a.

Zur Reduktion des Kodierungsaufwands werden derzeit eine Reihe alternativer Fehlerkorrekturansätze erforscht.

Quantum LDPC Codes (Low-Density Parity-Check)

LDPC-Codes sind bekannt aus der klassischen Kommunikationstechnik. Im Quantenkontext bieten sie:

• Konstante Check-Gewichte – d. h. jeder Stabilisator wirkt auf nur wenige Qubits
• Potentiell geringeren Overhead bei vergleichbarer Fehlerresistenz

Ein Beispiel: Die Hypergraph Product Codes ermöglichen lineare Skalierung der logischen Qubits bei gleichzeitigem Schutz gegen Mehrfachfehler.

Bosonische Codes

Statt viele diskrete Qubits zu koppeln, nutzt man hier kontinuierliche Zustände in einzelnen physikalischen Systemen (z. B. Mikrowellenresonatoren oder Oszillatoren).

Ein Beispiel: der Gottesman-Kitaev-Preskill-Code (GKP-Code), bei dem die Quanteninformation in bestimmten Gitterstrukturen des Phasenraums gespeichert wird.

Vorteile:

• Weniger physikalische Einheiten pro logischem Qubit
• Möglichkeit zur kontinuierlichen Fehlerkompensation

Herausforderungen:

• Hohe Anforderungen an Präzision und Kontrolle
• Schwierige Initialisierung und Stabilisierung

Topologische Cluster-State-Kodierung

Diese basiert auf der Measurement-Based Quantum Computation. Ein großer, entkoppelbarer Cluster-State wird erzeugt, und die Berechnung erfolgt durch eine Abfolge adaptiver Einzelmessungen.

Vorteile:

• Fehlerresistente Architektur
• Intrinsisch parallelisierbar

Nachteile:

• Komplexe Zustandsvorbereitung
• Hoher Mess- und Feedforward-Aufwand

Fazit dieses Abschnitts: Kodierte Qubits bieten das Tor zur fehlertoleranten Quantenverarbeitung – doch sie sind teuer, komplex und architektonisch anspruchsvoll. Die Suche nach ressourcenschonenderen Alternativen wie LDPC-, bosonischen oder Cluster-Codes zeigt, dass die Entwicklung kodierter Qubit-Architekturen noch längst nicht abgeschlossen ist. In Zukunft könnte eine hybride Kombination dieser Methoden der Schlüssel zu praktikablen, leistungsstarken Quantencomputern sein.

Fazit: Kodierte Qubits als Schlüssel zur Quantenrealität

Kodierte Qubits – Vom theoretischen Konzept zur technologischen Notwendigkeit

Was einst als mathematische Vision begann, ist heute ein unverzichtbares Werkzeug auf dem Weg zum skalierbaren Quantencomputer: Kodierte Qubits sind das Bindeglied zwischen fragiler Quantendynamik und stabiler, kontrollierbarer Informationsverarbeitung. Sie ermöglichen es, physikalisch realisierte Qubits vor Fehlern zu schützen – nicht durch Abschottung, sondern durch intelligente Redundanz und systematische Fehlerkorrektur.

Ob in Form klassischer Stabilizer-Architekturen, geometrisch definierter Surface Codes oder zukunftsweisender topologischer Ansätze – kodierte Qubits bilden den strukturellen Kern aller Bemühungen, die Quanteninformationstechnologie aus dem Labor in die Anwendung zu bringen.

Fortschritt durch Struktur: Kodierung als Architekturprinzip

Der entscheidende Fortschritt kodierter Qubits liegt nicht allein in der Fehlerbehandlung, sondern in der gestalterischen Kraft der Kodierung selbst: Sie transformiert die Qubitverarbeitung zu einem architektonischen System, in dem logische Operationen, Fehlermanagement und Datenfluss aufeinander abgestimmt sind. Die Einführung von Kodierung verlagert die Perspektive: Weg vom idealisierten Einzelqubit – hin zur strukturierten, fehlertoleranten Quantenlogik-Infrastruktur.

Herausforderungen bleiben – und treiben Innovation

Die Realisierung kodierter Qubits ist mit massivem Ressourcenaufwand, technischer Komplexität und algorithmischen Grenzen verbunden. Millionen physikalischer Qubits, hochpräzise Steuertechnik, synchronisierte Fehlerdiagnostik und ausgeklügelte Dekodierungssysteme sind heute noch notwendig, um einen stabilen logischen Qubit zu betreiben. Dieser Overhead limitiert gegenwärtig die Skalierbarkeit und Effizienz.

Doch genau diese Herausforderungen treiben neue Ansätze voran: LDPC-Codes, bosonische Kodierungen und autonome Kontrollsysteme eröffnen neue Perspektiven auf eine ressourcenschonendere, skalierbare Zukunft des Quantum Computings.

Der Weg zur fehlertoleranten Quantenära führt über kodierte Qubits

Eines steht fest: Die Zukunft des Quantencomputings wird nicht durch rohe Qubitanzahl entschieden, sondern durch Fehlertoleranz und logische Kontrolle. Kodierte Qubits sind kein Nebenprodukt der Quantenforschung, sondern ihre strukturelle Basis. Sie sind das Werkzeug, mit dem aus einer Vielzahl fehleranfälliger physikalischer Komponenten ein zuverlässiges, programmierbares und robustes Quanteninformationssystem entsteht.

Solange es keine naturgegebene Lösung für das Dekohärenzproblem gibt, bleiben kodierte Qubits der Schlüssel zur Realisierung von Quantenalgorithmen, zur Beherrschung komplexer Vielteilchensysteme und zur praktischen Nutzbarmachung des Quantenpotenzials.

Mit freundlichen Grüßen

---

Anhang

Institute, Forschungszentren und Persönlichkeiten – Vertiefte Übersicht

Im Folgenden werden zentrale Akteure vorgestellt, die entscheidend zur Theorie, Entwicklung und praktischen Implementierung kodierter Qubits beigetragen haben. Sie sind nicht nur als Quelle weiterführender Fachinformationen relevant, sondern auch als Orientierung für aktuelle und zukünftige Forschungsprojekte im Bereich der Quantenfehlerkorrektur.

Forschungsinstitute und akademische Gruppen

Google Quantum AI (Santa Barbara, Kalifornien, USA)

• Relevanz: Pionier bei der praktischen Implementierung des Surface Codes auf supraleitenden Qubit-Plattformen.
• Meilenstein: Demonstration eines logischen Qubits mit exponentiell sinkender Fehlerwahrscheinlichkeit (2023).
• Forschungsschwerpunkte: Surface Codes, Crosstalk-Reduktion, QEC-Pipelining, Hardware-Software-Co-Design
• Webseite: https://quantumai.google

IBM Quantum (Yorktown Heights, NY, USA)

• Relevanz: Führender Entwickler supraleitender Qubit-Chips mit Roadmap zur logischen Skalierung.
• Projekte: „Eagle“, „Heron“, „Condor“ Chips; Qiskit Runtime mit Fehlerkorrekturmodulen
• Forschungsschwerpunkte: Kodierte Qubits in Surface-Code-Gittern, Fehlertolerante Logikgatter
• Webseite: https://research.ibm.com/quantum

ETH Zürich – Quantum Device Lab (Schweiz)

• Leitung: Prof. Dr. Andreas Wallraff
• Relevanz: Europäische Spitzenforschung im Bereich supraleitender Qubits und modularer kodierter Architekturen
• Forschungsschwerpunkte: Fehlerkorrektur in Multi-Modul-Systemen, 3D-Verkabelung, Skalierbarkeit
• Webseite: https://quantum-device-lab.ethz.ch

Quantinuum (UK/USA)

• Hintergrund: Fusion von Honeywell Quantum Solutions & Cambridge Quantum
• Plattform: Trapped-Ion-Prozessor H1 mit stabiler Fehlerkorrektur auf [[7,1,3]]-Code-Basis
• Forschungsschwerpunkte: Modulare QEC-Architekturen, Softwaregestützte Dekodierung, Logical Benchmarking
• Webseite: https://www.quantinuum.com

Microsoft Station Q (Redmond, USA)

• Relevanz: Fokus auf topologische Qubits und Majorana-Fehlerresistenz
• Status: Experimentelle Suche nach stabilen topologischen Phasen in Halbleiter-Supraleiter-Hybriden
• Forschungsschwerpunkte: Braiding, Quantum Materials, Topological Quantum Computing
• Webseite: https://www.microsoft.com/en-us/quantum

QuTech – TU Delft (Niederlande)

• Konsortium: Zusammenarbeit mit TNO und Intel
• Relevanz: Forschung an Silizium-Qubits, LDPC-Codes und photonischer Fehlerkorrektur
• Forschungsschwerpunkte: Quantum Network Architectures, Surface-Code-Gitter auf Silizium
• Webseite: https://qutech.nl

Einzelpersonen und wissenschaftliche Wegbereiter

Peter W. Shor (MIT)

• Bekannt für: Erfinder des ersten voll funktionsfähigen Quantenfehlerkorrekturcodes ([[9,1,3]])
• Relevanz: Grundlagenarbeit zur Machbarkeit fehlertoleranter Quanteninformatik
• Webseite: https://math.mit.edu/~shor/

Andrew Steane (University of Oxford)

• Beitrag: Entwicklung des Steane-Codes ([[7,1,3]]) als CSS-Code mit effizienten Eigenschaften
• Fokus: Theorie und Physik der Quantenfehlerkorrektur, Dekodierbare Codes
• Webseite: https://users.physics.ox.ac.uk/~Steane/

Daniel Gottesman (Perimeter Institute)

• Beitrag: Entwicklung des Stabilisator-Formalismus, GKP-Code, Transversale Logik
• Bedeutung: Theoretischer Architekt moderner Fehlerkorrekturmethoden
• Webseite: https://www.perimeterinstitute.ca/people/daniel-gottesman

John Preskill (Caltech)

• Beitrag: Konzeptualisierung der NISQ-Ära, Vordenker der FTQC-Roadmap
• Relevanz: Vermittler zwischen Theorie, Anwendungen und realem Fortschritt
• Webseite: http://www.theory.caltech.edu/~preskill/

Barbara Terhal (RWTH Aachen & QuTech Delft)

• Spezialisierung: Quantum LDPC Codes, Paritätssysteme, Dekodierungsalgorithmen
• Beitrag: Brückenbauerin zwischen Theorie und praktikabler Umsetzung in Hybridarchitekturen
• Webseite: https://iqit.rwth-aachen.de/go/id/pwug

Community-Ressourcen und Quellensammlungen

• Quantum Error Correction Zoo (QECZoo)

Eine gepflegte, community-getriebene Übersicht über über 300 bekannte Quantenfehlerkorrekturcodes – mit Klassifikation, Metriken und Literaturverweisen. Link: https://errorcorrectionzoo.org

• Qiskit Tutorials zur Fehlerkorrektur (IBM)

Interaktive Jupyter-Notebooks mit Beispielen für Shor-, Steane- und Surface-Codes – auch zur Simulation auf klassischen Rechnern. Link: https://qiskit.org/learn

• QEC Benchmarks (Q-CTRL / Quantinuum / Unitary Fund)

Initiativen zur Standardisierung von Fehlermodellen, Dekodierungsverfahren und Performanzmetriken in kodierten Systemen. Link: https://unitary.fund

Zusammenfassung: Der Aufbau und Betrieb kodierter Qubits ist ein hochgradig interdisziplinäres Unterfangen – und die hier aufgeführten Institute und Personen bilden das globale Rückgrat dieser Bewegung. Ihre Arbeiten prägen sowohl die mathematische Fundierung als auch die ingenieurtechnische Umsetzung dieser Schlüsseltechnologie. Für Forschende, Entwickler und Unternehmen, die sich mit fehlertoleranter Quantenverarbeitung befassen, stellen diese Adressen zentrale Ausgangspunkte für Kooperation, Innovation und Fortschritt dar.