Ordnung aus dem Rauschen: Quantenfehlerkorrektur und der Weg zum fehlertoleranten Quantencomputer

Der Aufhänger: Der zerbrechlichste Zustand der Welt

Stell dir einen Computer vor, dessen Rechenbausteine so empfindlich sind, dass ein einziges verirrtes Photon aus der kosmischen Hintergrundstrahlung, eine winzige Vibration im Kühlsystem oder ein kaum messbares Magnetfeld genügt, um die Rechnung zu ruinieren. Kein grober Fehler, kein Absturz mit Fehlermeldung – sondern ein leises, unbemerktes Verrutschen des Zustands, das die Antwort still und heimlich verfälscht. Genau das ist die Ausgangslage jedes Quantencomputers. Die Qubits, seine Recheneinheiten, sind die zerbrechlichsten Objekte, die die Ingenieurskunst je zu beherrschen versucht hat.

Ein moderner supraleitender Qubit-Chip wird auf rund 15 Millikelvin heruntergekühlt – kälter als der tiefste Winkel des interstellaren Raums – und trotzdem verliert ein einzelnes physikalisches Qubit seine Kohärenz oft schon nach einigen zehn bis wenigen hundert Mikrosekunden. In dieser Zeitspanne, kürzer als ein Wimpernschlag, muss der gesamte quantenmechanische Nutzen extrahiert sein, bevor das Rauschen der Umwelt die Information auffrisst. Zum Vergleich: Ein klassisches Bit in deinem Arbeitsspeicher hält seinen Wert über Jahre, und die Fehlerrate moderner DRAM- oder CPU-Logik ist so absurd niedrig, dass wir sie im Alltag komplett ignorieren.

Hier liegt die zentrale Ironie des Quantencomputings. Der theoretische Nutzen ist gewaltig – Shors Algorithmus, der RSA in polynomialer Zeit brechen könnte, Simulationen von Molekülen und Materialien, die klassisch für immer unerreichbar bleiben. Doch die physikalischen Bausteine sind so unzuverlässig, dass eine ernsthafte Rechnung ohne einen Rettungsanker vollkommen aussichtslos wäre. Dieser Rettungsanker heißt Quantenfehlerkorrektur (englisch quantum error correction, kurz QEC). Sie ist nicht ein Detail unter vielen, sondern die vielleicht entscheidende Ingenieursleistung, die überhaupt darüber bestimmt, ob nützliche Quantencomputer je gebaut werden können.

Für jemanden, der aus der klassischen Informatik kommt, ist die Fehlerkorrektur ein gelöstes Problem, das man kaum je bewusst wahrnimmt. Man kopiert ein Bit dreifach und stimmt per Mehrheit ab. Man hängt Prüfsummen an, berechnet ECC-Codes im Speicher, verwendet Hamming-Codes. Fertig. Doch im Quantenreich versagt jede einzelne dieser Techniken – und zwar nicht wegen technischer Unreife, sondern aus fundamentalen physikalischen Gründen. Dieser Artikel nimmt dich mit auf die vollständige Strecke: warum klassische Fehlerkorrektur im Quantenreich verboten ist, mit welchem eleganten Trick die Physik dieses Verbot dennoch umgeht, wie der Surface Code Fehler entdeckt, ohne die Rechnung zu zerstören, was das Schwellenwerttheorem verspricht – und warum der Dezember 2024 mit Googles Willow-Chip als der Moment in die Geschichte eingehen könnte, in dem die Fehlerkorrektur zum ersten Mal wirklich funktionierte.

Teil 1: Warum das Klassische versagt

Drei Verbote der Quantenmechanik

Um zu verstehen, warum Quantenfehlerkorrektur so schwer ist, muss man drei Eigenheiten der Quantenmechanik nebeneinanderlegen, von denen jede einzelne die naheliegende klassische Lösung blockiert.

Das erste Verbot ist das No-Cloning-Theorem. 1982 bewiesen Wootters, Zurek und unabhängig Dieks, dass es physikalisch unmöglich ist, einen unbekannten Quantenzustand exakt zu kopieren. Es gibt keine Maschine, keinen Prozess, kein Naturgesetz, das aus einem beliebigen Qubit-Zustand \(|\psi\rangle\) zwei identische Kopien \(|\psi\rangle|\psi\rangle\) herstellt. Das ist kein technisches Problem, das man mit besserer Hardware lösen könnte – es folgt zwingend aus der Linearität der Quantenmechanik. Und damit fällt die einfachste klassische Idee sofort weg: Man kann ein Qubit nicht dreimal kopieren und per Mehrheit abstimmen. Der triviale Wiederholungscode ist im Quantenreich buchstäblich unbaubar.

Das zweite Verbot ist die Zerstörung durch Messung. In der klassischen Welt kann ich ein Bit jederzeit ansehen, um zu prüfen, ob es noch stimmt. Ein Qubit dagegen befindet sich im Allgemeinen in einer Superposition, etwa \(\alpha|0\rangle + \beta|1\rangle\). Sobald ich es messe, kollabiert diese Superposition unwiderruflich auf \(|0\rangle\) oder \(|1\rangle\), und die feinen Amplituden \(\alpha\) und \(\beta\) – die eigentliche Quanteninformation – sind für immer verloren. Ich kann also nicht einfach nachschauen, ob ein Fehler aufgetreten ist, denn das Nachschauen selbst ist die schlimmste Form von Fehler.

Das dritte Problem ist die Kontinuität der Fehler. Ein klassisches Bit kann nur auf eine einzige Weise kaputtgehen: Es kippt von 0 auf 1 oder umgekehrt. Ein Qubit dagegen lebt auf einer kontinuierlichen Kugeloberfläche, der Bloch-Kugel. Ein Fehler kann eine winzige Drehung um einen beliebigen Winkel sein, eine Mischung aus Bit-Flip und Phasen-Flip in jedem denkbaren Verhältnis. Es gibt nicht nur einen möglichen Fehler, sondern ein Kontinuum unendlich vieler. Wie soll man gegen unendlich viele verschiedene Fehler schützen, wenn man sie nicht einmal ansehen darf?

Der Ausweg: Information verstecken, nicht kopieren

Der konzeptuelle Durchbruch, den Peter Shor 1995 und Andrew Steane 1996 unabhängig lieferten, ist so raffiniert, dass er beim ersten Verständnis fast wie ein Taschenspielertrick wirkt. Die Lösung besteht darin, alle drei Verbote gleichzeitig zu umgehen.

Statt die Quanteninformation zu kopieren, wird sie verteilt und verschränkt. Ein einzelnes logisches Qubit wird nicht in einem physikalischen Qubit gespeichert, sondern über viele physikalische Qubits hinweg in deren gemeinsamem verschränkten Zustand versteckt. Die Information liegt nicht an einem Ort, sondern in den Korrelationen zwischen den Qubits. Das verletzt das No-Cloning-Theorem nicht, denn es wird nichts dupliziert – der Zustand wird lediglich auf eine nicht-lokale Weise ausgebreitet. Ich habe hier immer noch genau ein logisches Qubit an Information, nur eben verschmiert über viele physikalische Träger.

Und für das Messproblem findet sich ein ähnlich eleganter Ausweg, der den Kern der ganzen Disziplin ausmacht und dem wir uns jetzt zuwenden.

Teil 2: Syndrome messen, ohne hinzusehen

Die entscheidende Idee der Stabilisatormessung

Hier liegt für mich die schönste Einsicht der gesamten Quantenfehlerkorrektur. Man darf den Zustand der Daten-Qubits nicht messen, weil das ihre Superposition zerstört. Aber man muss auch gar nicht wissen, welchen Wert ein Qubit hat. Man muss nur wissen, ob sich zwei benachbarte Qubits relativ zueinander verändert haben – ob also ein Fehler dazwischengefahren ist. Und diese Frage nach der Relation lässt sich beantworten, ohne die absoluten Werte zu enthüllen.

Das Werkzeug dafür heißt Stabilisatormessung. Statt ein Daten-Qubit direkt zu messen, führt man zusätzliche Hilfs-Qubits ein, die sogenannten Ancilla-Qubits (auch Mess-Qubits genannt). Man verschränkt ein Ancilla-Qubit gezielt mit einer Gruppe von Daten-Qubits und misst dann nur das Ancilla. Die Kunst der Konstruktion sorgt dafür, dass das Ergebnis dieser Messung – das sogenannte Syndrom – ausschließlich Auskunft darüber gibt, ob ein bestimmter Fehlertyp aufgetreten ist, nicht aber über den eigentlichen Zustand der Daten. Das Syndrom ist gleichsam eine Antwort auf die Frage „Haben sich diese vier Qubits gemeinsam auf eine verdächtige Weise verändert?" – eine Frage, deren Antwort keinerlei Information über die kostbare Superposition preisgibt.

Konkret misst man zwei Arten von Prüfungen, die als Paritätsprüfungen funktionieren. Eine Z-Stabilisator-Messung prüft die gemeinsame Parität einer Gruppe von Qubits und deckt damit Bit-Flip-Fehler auf (ein \(|0\rangle\), das versehentlich zu \(|1\rangle\) wurde). Eine X-Stabilisator-Messung prüft die Parität in der komplementären Basis und deckt Phasen-Flip-Fehler auf (ein Vorzeichenwechsel zwischen den Superpositionsanteilen, der klassisch kein Gegenstück hat). Weil jeder beliebige Ein-Qubit-Fehler sich mathematisch als Kombination aus Bit-Flip, Phasen-Flip und beidem zugleich schreiben lässt, genügt es erstaunlicherweise, gegen genau diese beiden Grundfehler zu schützen.

Die Diskretisierung des Kontinuums

Damit löst sich auch das dritte Verbot auf – das der kontinuierlichen Fehler –, und das auf eine fast magische Weise. Wenn ein Qubit einen kleinen, kontinuierlichen Fehler erleidet, also eine winzige Drehung um einen beliebigen Winkel, dann kann man diesen Zustand mathematisch als Überlagerung schreiben aus „kein Fehler" und „ein vollständiger Bit-Flip" (und/oder Phasen-Flip), gewichtet mit den entsprechenden Amplituden. Der entscheidende Punkt: In dem Moment, in dem man die Stabilisatoren misst, kollabiert diese Überlagerung. Der winzige, kontinuierliche Fehler wird durch die Messung gezwungen, sich zu entscheiden – entweder „kein Fehler" oder „ganzer Fehler". Das kontinuierliche Problem wird auf einen Schlag in ein diskretes verwandelt.

Das ist der Grund, warum man nur gegen eine endliche, überschaubare Menge von Fehlertypen schützen muss, obwohl in Wahrheit unendlich viele physikalische Störungen möglich sind. Die Messung selbst erledigt die Diskretisierung. Ich halte das für einen der elegantesten Momente der gesamten Physik: Ausgerechnet die Messung, die im Quantenreich sonst der Feind aller feinen Zustände ist, wird hier zum Werkzeug, das das ansonsten unlösbare Kontinuumsproblem in ein handhabbares diskretes Problem verwandelt.

Vom Syndrom zur Korrektur: der Decoder

Sobald die Syndrome gemessen sind, liegt ein Muster von Nullen und Einsen vor – eine Landkarte der Verdachtsmomente. Diese Rohdaten müssen nun interpretiert werden: Wo genau ist welcher Fehler aufgetreten, und welche Korrektur macht ihn rückgängig? Diese Aufgabe übernimmt der Decoder, ein klassischer Algorithmus, der aus dem Syndrom die wahrscheinlichste Fehlerursache berechnet.

Das ist keineswegs trivial. Ein und dasselbe Syndrom kann von verschiedenen Fehlerkombinationen erzeugt worden sein, und der Decoder muss die wahrscheinlichste auswählen. Für den Surface Code, dem wir uns gleich zuwenden, wird dieses Problem oft mit einem Verfahren namens Minimum-Weight Perfect Matching gelöst – man deutet die Syndrome als Endpunkte von Fehlerketten und sucht die kürzeste Verbindung, die sie erklärt. Der Clou dabei: Der Decoder rechnet auf einem ganz gewöhnlichen klassischen Rechner. Der Quantencomputer liefert nur die Syndrome; die eigentliche Detektivarbeit erledigt klassische Software. Und weil die Qubits während dieser Berechnung weiter zerfallen, muss der Decoder atemberaubend schnell sein – ein Punkt, der sich als eine der härtesten praktischen Hürden herausstellen wird.

Teil 3: Die Ahnenreihe der Codes

Der Shor-Code: Der erste Beweis, dass es geht

Der erste vollständige Quantenfehlerkorrektur-Code stammt von Peter Shor aus dem Jahr 1995. Sein Neun-Qubit-Code kodiert ein logisches Qubit in neun physikalische Qubits. Die Konstruktion ist konzeptuell durchsichtig: Sie verschachtelt zwei Ebenen. Zunächst schützt ein Drei-Qubit-Wiederholungscode gegen Phasen-Flips, und dann wird jedes dieser drei Qubits noch einmal durch einen Drei-Qubit-Wiederholungscode gegen Bit-Flips abgesichert. Drei mal drei ergibt neun. Shors Code war der historische Beweis, dass Quantenfehlerkorrektur überhaupt möglich ist – eine Aussage, die vor 1995 keineswegs offensichtlich war und die viele für unmöglich hielten.

Der Steane-Code und die CSS-Familie

Kurz darauf, 1996, lieferte Andrew Steane einen effizienteren Entwurf: den Sieben-Qubit-Code. Er ist besonders schön, weil er zwei klassische Codes wiederverwendet – den [7,4,3]-Hamming-Code für Bit-Flips und dessen dualen Code für Phasen-Flips. Steanes Code gehört zur Familie der CSS-Codes (benannt nach Calderbank, Shor und Steane), die eine Brücke zwischen der reifen klassischen Codierungstheorie und dem neuen Quantenreich schlagen. Diese Codes zeigten, dass sich jahrzehntelanges Wissen aus der klassischen Nachrichtentechnik in die Quantenwelt übertragen lässt, statt bei null anfangen zu müssen.

In der abstrakten Notation schreibt man einen solchen Code als \(n, k, d\): \(n\) physikalische Qubits kodieren \(k\) logische Qubits mit einem Codeabstand \(d\). Der Steane-Code ist ein \(7,1,3\)-Code. Der Abstand \(d\) ist dabei die zentrale Kennzahl: Er gibt an, wie viele einzelne Qubit-Fehler nötig wären, um unbemerkt von einem gültigen logischen Zustand in einen anderen zu springen. Ein Code mit Abstand \(d\) kann bis zu \(\lfloor (d-1)/2 \rfloor\) Fehler zuverlässig korrigieren. Ein größerer Abstand bedeutet mehr Schutz – aber auch mehr physikalische Qubits.

Der Surface Code: Der Favorit der Hardware

So elegant Shor- und Steane-Code theoretisch sind, in der Praxis hat sich ein anderer Entwurf durchgesetzt, der Surface Code. Er geht auf Ideen von Alexei Kitaev aus den späten 1990er Jahren zurück (ursprünglich als toric code formuliert) und ist heute der De-facto-Standard für supraleitende Quantenprozessoren, wie sie Google und lange auch IBM bauen. Der Grund für seine Dominanz ist ausgesprochen praktisch.

Der Surface Code ordnet die Qubits auf einem zweidimensionalen Schachbrettgitter an. Es gibt zwei Sorten: Daten-Qubits, welche die eigentliche Information tragen, und dazwischen liegende Mess-Qubits (Ancillas), die abwechselnd X- und Z-Stabilisatoren prüfen. Der entscheidende Vorteil: Jeder Stabilisator prüft nur seine unmittelbaren Nachbarn – höchstens vier benachbarte Qubits. Es sind ausschließlich lokale Wechselwirkungen zwischen direkt nebeneinanderliegenden Qubits nötig. Genau das passt perfekt zur physischen Realität supraleitender Chips, wo Qubits nun einmal auf einer flachen Oberfläche sitzen und nur mit ihren direkten Nachbarn gut koppeln können. Ein Code, der Wechselwirkungen zwischen beliebig weit entfernten Qubits verlangte, wäre hardwaretechnisch ein Albtraum; der Surface Code verlangt sie nie.

Der zweite große Vorteil ist der hohe Schwellenwert des Surface Codes, auf den wir im nächsten Teil kommen. Der Preis dafür ist ein hoher Overhead: Der Surface Code braucht viele physikalische Qubits pro logischem Qubit. Bei einem Codeabstand von 11 sind es grob 121 Daten-Qubits plus die Mess-Qubits – über hundert physikalische Qubits, um ein einziges gut geschütztes logisches Qubit zu erzeugen. Diese Verschwendung ist der wunde Punkt, der die gesamte Feldforschung antreibt.

Teil 4: Das Schwellenwerttheorem – das Versprechen der Skalierbarkeit

Der Wettlauf zwischen Schutz und Aufwand

Hier stoßen wir auf die vielleicht wichtigste theoretische Einsicht der ganzen Disziplin, und zugleich auf eine scheinbar paradoxe Gefahr. Wenn ich mehr physikalische Qubits verwende, um ein logisches Qubit zu schützen, dann füge ich einerseits Redundanz hinzu – das ist gut. Aber jedes zusätzliche physikalische Qubit ist selbst fehleranfällig und kann seinerseits neue Fehler einschleppen. Zudem braucht jede Stabilisatormessung selbst wieder fehlerhafte Operationen. Es ist also keineswegs selbstverständlich, dass mehr Qubits die Sache besser machen. Wenn die physikalischen Qubits zu schlecht sind, füge ich mit jedem weiteren Qubit mehr Fehler hinzu, als ich korrigieren kann – und mehr Redundanz macht die Sache schlimmer statt besser.

Genau an diesem Punkt greift das Schwellenwerttheorem (englisch threshold theorem), eines der tiefsten Resultate des gesamten Feldes. Es besagt, sinngemäß: Es gibt eine kritische physikalische Fehlerrate, den Schwellenwert. Solange die Fehlerrate der einzelnen physikalischen Qubits und Operationen unter diesem Schwellenwert liegt, kann man die logische Fehlerrate durch Vergrößern des Codes beliebig weit herabdrücken. Liegt sie dagegen über dem Schwellenwert, verschlimmert jede Vergrößerung des Codes die Lage.

Es ist buchstäblich ein Kipppunkt. Unterhalb der Schwelle arbeitet die Redundanz für dich, und zwar exponentiell: Jede Erhöhung des Codeabstands um zwei Stufen drückt die logische Fehlerrate um einen konstanten Faktor nach unten. Oberhalb der Schwelle arbeitet die Redundanz gegen dich. Das Schwellenwerttheorem ist damit das theoretische Fundament, das überhaupt erst die Hoffnung begründet, dass fehlertolerante Quantencomputer möglich sind. Ohne es wäre die ganze Vision hoffnungslos.

Warum „unterhalb der Schwelle" der eigentliche Meilenstein ist

Für den Surface Code liegt dieser Schwellenwert bei rund einem Prozent physikalischer Fehlerrate pro Operation – ein für die Praxis vergleichsweise gnädiger Wert, was mit ein Grund für seine Beliebtheit ist. Jahrelang war der Bau von Qubits gut genug, um diese Schwelle zu unterschreiten, das große ungelöste Ziel. Man konnte Fehlerkorrektur zwar demonstrieren, aber solange man oberhalb der Schwelle operierte, machte mehr Fehlerkorrektur die Sache schlechter, nicht besser. Das war ein zutiefst frustrierender Zustand: Man hatte die Theorie, man hatte die Codes, aber die Hardware war schlicht nicht gut genug, um den Kipppunkt zu überschreiten.

Und genau hier setzt der Durchbruch von 2024 an.

Teil 5: Der Willow-Moment – Dezember 2024

Was Google zeigte

Am 9. Dezember 2024 veröffentlichte Google Quantum AI in der Fachzeitschrift Nature eine Arbeit mit dem nüchternen Titel „Quantum error correction below the surface code threshold". Durchgeführt wurde sie auf Googles neuem supraleitenden Prozessor namens Willow. Der Kern des Ergebnisses lässt sich in einem Satz zusammenfassen: Zum ersten Mal wurde überzeugend demonstriert, dass das Vergrößern eines Surface-Code-Speichers die logische Fehlerrate tatsächlich senkt – das System operierte nachweislich unterhalb der Schwelle.

Konkret verglich das Team Surface Codes verschiedener Größe: einen Abstand-3-Code, einen Abstand-5-Code und einen Abstand-7-Code (letzterer mit 101 Qubits). Und die logische Fehlerrate sank tatsächlich mit jeder Vergrößerung. Die entscheidende Kennzahl ist der Faktor \(\Lambda\) (Lambda): Er gibt an, um welchen Faktor sich die logische Fehlerrate verbessert, wenn man den Codeabstand um zwei Stufen erhöht. Google berichtete \(\Lambda = 2{,}14 \pm 0{,}02\). Jeder Wert über 1 bedeutet, dass mehr Fehlerkorrektur hilft statt schadet – man ist unter der Schwelle. Ein \(\Lambda\) von rund 2 bedeutet: Jeder Sprung im Abstand um zwei halbiert die logische Fehlerrate. Der beste, der Abstand-7-Code, erreichte eine logische Fehlerrate von etwa 0,143 Prozent pro Korrekturzyklus.

„Jenseits von Break-Even"

Fast noch wichtiger als der reine \(\Lambda\)-Wert ist eine zweite Aussage: Das logische Qubit war „jenseits von Break-Even" (englisch beyond break-even). Das bedeutet, das aus vielen physikalischen Qubits zusammengesetzte, fehlerkorrigierte logische Qubit hielt seine Information länger als das beste einzelne physikalische Qubit im selben Chip – und zwar um einen Faktor von rund 2,4. Das ist die Schwelle, ab der Fehlerkorrektur überhaupt erst einen Sinn ergibt. Denn wenn das aufwendig geschützte logische Qubit kürzer lebte als ein nacktes physikalisches, wäre der ganze Aufwand absurd. Erst jenseits dieses Punktes zahlt sich der immense Overhead tatsächlich aus. Willow überschritt ihn.

Die Echtzeit-Hürde des Decoders

Ein Aspekt der Willow-Arbeit verdient besondere Beachtung, weil er eine der unterschätzten praktischen Schwierigkeiten beleuchtet: die Echtzeit-Dekodierung. Wie erwähnt, muss ein klassischer Decoder aus den Syndromen die Korrekturen berechnen. Bei einem echten, laufenden Quantencomputer darf dieser Decoder nicht hinterherhinken. Die Syndrome strömen mit jedem Zyklus herein – bei Willow beträgt die Zykluszeit rund 1,1 Mikrosekunden –, und wenn der Decoder langsamer ist als der Zustrom, staut sich ein immer wachsender Rückstand auf, der die Rechnung irgendwann unmöglich macht. Google demonstrierte eine Echtzeit-Dekodierung mit einer durchschnittlichen Latenz von rund 63 Mikrosekunden beim Abstand-5-Code, über eine Million Zyklen hinweg. Das zeigt, dass das Problem der Decoder-Geschwindigkeit lösbar ist – ein Punkt, der in der öffentlichen Wahrnehmung oft untergeht, für die praktische Umsetzbarkeit aber genauso entscheidend ist wie die Qubit-Qualität selbst.

Die richtige Einordnung

Man sollte den Willow-Durchbruch weder unter- noch überschätzen. Was gezeigt wurde, ist ein logischer Speicher – ein logisches Qubit, das seine Information stabil hält. Das ist noch nicht das Gleiche wie ein vollständiger fehlertoleranter Rechner, der beliebige logische Gatter fehlerfrei ausführt. Der Weg zu einem nützlichen Quantencomputer, der etwa Shors Algorithmus auf kryptographisch relevanten Schlüssellängen ausführt, erfordert noch Millionen physikalischer Qubits und die fehlertolerante Ausführung von Logikoperationen. Was Willow demonstrierte, ist gleichsam der Beweis, dass das Fundament trägt – dass die exponentielle Fehlerunterdrückung real ist und in echter Hardware funktioniert. Ich bin der Meinung, dass dies rückblickend als der Moment gelten wird, in dem die Quantenfehlerkorrektur den Sprung von der theoretischen Möglichkeit zur experimentellen Realität schaffte, auch wenn der praktisch nutzbare Quantencomputer noch Jahre entfernt bleibt.

Teil 6: Der Overhead und die Suche nach besseren Codes

Das Problem der Millionen Qubits

So ermutigend Willow ist, es rückt zugleich das größte verbleibende Hindernis ins Licht: den Overhead. Wenn man über hundert physikalische Qubits braucht, um ein einziges gutes logisches Qubit zu erzeugen, und ein kryptographisch relevanter Angriff auf RSA-2048 vielleicht ein paar tausend logische Qubits erfordert, dann landet man schnell bei Millionen physikalischer Qubits. Das ist mit heutiger Hardware, die einige hundert bis wenige tausend Qubits umfasst, um Größenordnungen entfernt. Der Surface Code ist robust und hardwarefreundlich, aber er ist auch verschwenderisch. Diese Verschwendung ist der Grund, warum die aktuelle Forschung mit Hochdruck an sparsameren Codes arbeitet.

qLDPC-Codes: Die Grenze von 2026

Der derzeit heißeste Kandidat für einen effizienteren Ersatz sind die qLDPC-Codes (quantum low-density parity-check codes). Der Name klingt technisch, die Idee ist aber greifbar: Es sind Codes, deren Paritätsprüfungen „dünn besetzt" sind (low-density), die aber trotzdem jede Prüfung auf geschickt gewählte, nicht rein lokale Qubit-Gruppen verteilen. Damit erreichen sie eine dramatisch bessere Rate von logischen zu physikalischen Qubits.

IBM veröffentlichte 2024 in Nature einen sogenannten „bivariate bicycle"-qLDPC-Code, der zwölf logische Qubits in 144 physikalischen Qubits kodiert – das ist rund die zehnfache Effizienz gegenüber dem Surface Code. Der Preis: Die Paritätsprüfungen verlangen Kopplungen zwischen Qubits, die nicht mehr nur unmittelbare Nachbarn sind, was höhere Anforderungen an die Chip-Konnektivität stellt. IBM hat seine gesamte Roadmap auf diese Wette umgestellt: Der 2025 vorgestellte Loon-Prozessor führt neue Koppler ein, um die für qLDPC nötige erweiterte Konnektivität zu ermöglichen; der Kookaburra-Chip soll das erste QEC-fähige Modul mit LDPC-Speicher werden; und das für 2028/29 geplante System namens Starling soll erstmals fehlertolerante Logikoperationen samt schnellem Decoder vereinen. Nach IBMs Wechsel zu qLDPC im Jahr 2024 wird erwartet, dass 2026 weitere Akteure nachziehen – hin zu einer Vielfalt fehlertoleranter Architekturen, die jeweils auf ihre spezifische Hardware zugeschnitten sind.

Weitere Wege: Bosonische und Cat-Qubits

Ein ganz anderer Ansatz verlagert einen Teil der Fehlerkorrektur bereits in die physikalische Ebene des einzelnen Qubits. Bosonische Codes und Cat-Qubits (etwa vom Unternehmen Alice & Bob verfolgt) nutzen die Physik von Mikrowellen-Resonatoren, um Qubits zu bauen, die von Natur aus gegen bestimmte Fehlertypen unempfindlich sind – insbesondere gegen Bit-Flips, sodass fast nur noch Phasen-Flips korrigiert werden müssen. Damit lässt sich das Verhältnis von physikalischen zu logischen Qubits in Einzelfälle-Bereiche drücken. Quantinuum wiederum berichtete jüngst über 94 logische Qubits mit einer Fehlerrate unter 0,01 Prozent bei einem Verhältnis von etwa 2:1 – auf ihrer ganz anderen Ionenfallen-Plattform, die naturgemäß andere Stärken und Schwächen mitbringt.

Die Landschaft ist also in Bewegung. Der Surface Code lieferte den ersten überzeugenden Beweis, dass Fehlerkorrektur funktioniert; die nächste Generation von Codes versucht, denselben Schutz mit einem Bruchteil der Qubits zu erreichen. Welcher Ansatz sich durchsetzt, ist noch offen und wird vermutlich von der jeweiligen Hardware-Plattform abhängen.

Frameworks zum Mitnehmen: Die zentralen Begriffe im Überblick

Die Erkenntnis zum Mitnehmen

Die vielleicht wichtigste Lektion der Quantenfehlerkorrektur ist eine, die weit über die Physik hinausreicht. Sie lautet: Zuverlässigkeit ist keine Eigenschaft der Bausteine, sondern eine Eigenschaft der Architektur. Ein Quantencomputer wird niemals aus perfekten Qubits bestehen – perfekte Qubits gibt es nicht und wird es nie geben. Stattdessen entsteht Verlässlichkeit aus einem klugen Zusammenspiel vieler unzuverlässiger Teile, aus Redundanz, aus fortlaufender Überwachung und aus einem Kipppunkt, jenseits dessen das System sich selbst stabilisiert.

Diese Denkweise ist dem Ingenieur verteilter Systeme zutiefst vertraut. Auch ein hochverfügbarer Cloud-Dienst besteht aus Servern, die einzeln jederzeit ausfallen können; die Zuverlässigkeit des Ganzen entsteht erst durch Replikation, Konsens und Fehlererkennung – genau die Prinzipien, die auch die Quantenfehlerkorrektur trägt. Wer schon einmal über Quoren, Replikate und das Kippverhalten redundanter Systeme nachgedacht hat, findet in der QEC dieselbe Grammatik wieder, nur mit den zusätzlichen Verboten der Quantenmechanik als Erschwernis. Der praktische Handlungsanstoß: Wenn du das nächste Mal ein System entwirfst, dessen einzelne Komponenten unzuverlässig sind, frage nicht „Wie mache ich jede Komponente perfekt?", sondern „Ab welchem Punkt beginnt die Redundanz, für mich zu arbeiten statt gegen mich?" Das ist die Schwellenwert-Denkweise, und sie ist universell.

Querverweise im Vault

Dieses Thema steht in engem Zusammenhang mit mehreren bereits behandelten Artikeln. Die Quantenmechanik der Verschränkung, die überhaupt erst das „Verstecken" von Information über viele Qubits ermöglicht, wird ausführlich in Spukhafte Fernwirkung: Quantenverschränkung von Einstein zum Quanteninternet behandelt. Warum der Bau eines funktionierenden Quantencomputers – den die Fehlerkorrektur erst ermöglicht – die klassische Kryptographie bedroht und was dagegen unternommen wird, steht in Ernte jetzt, entschlüssle später: Post-Quanten-Kryptographie und das Rennen gegen den Quantencomputer. Die Idee, aus vielen unzuverlässigen Teilen ein zuverlässiges Ganzes zu bauen, ist der rote Faden von Wie Maschinen sich einig werden: Verteilter Konsens von FLP über Paxos zu Raft. Und dass beobachtbares Hardware-Verhalten oft mehr verrät als die logische Ebene vermuten lässt – ein Motiv, das auch dem Cache-Seitenkanal zugrunde liegt –, findet sich in Wenn der Prozessor zu viel rät: Spectre, Meltdown und die Sünde der spekulativen Ausführung.

Zum Nachdenken

Das Schwellenwerttheorem sagt uns, dass es einen Kipppunkt gibt, jenseits dessen mehr Redundanz ein System exponentiell zuverlässiger macht – und diesseits dessen sie es verschlimmert. Wo in deiner eigenen Arbeit – sei es in der Software-Architektur, im Team oder im persönlichen Lernen – gibt es einen solchen Schwellenwert, an dem sich „mehr vom Selben" von einer Belastung in einen selbstverstärkenden Vorteil verwandelt? Und woran würdest du erkennen, auf welcher Seite dieser Schwelle du gerade stehst?

Quellen

• Google Quantum AI et al., „Quantum error correction below the surface code threshold", Nature, 9. Dezember 2024: https://www.nature.com/articles/s41586-024-08449-y
• Preprint dazu (arXiv:2408.13687): https://arxiv.org/abs/2408.13687
• Joschka Roffe, „Quantum Error Correction: An Introductory Guide", Contemporary Physics (arXiv:1907.11157): https://arxiv.org/pdf/1907.11157
• The Quantum Insider, „What Is Quantum Error Correction & How Does It Work" (2026): https://thequantuminsider.com/2026/03/16/understanding-quantum-error-correction/
• Riverlane, „Quantum Error Correction: Our 2025 trends and 2026 predictions": https://www.riverlane.com/blog/quantum-error-correction-our-2025-trends-and-2026-predictions
• Google Research Blog, „Making quantum error correction work" / Willow-Ankündigung: https://research.google/blog/making-quantum-error-correction-work/

← All articles