Quantencomputing verständlich erklärt — Episode 9

Warum sich Quantencomputer so schwer skalieren lassenQuantencomputing verständlich erklärt — Episode 9In Episode 8B haben wir gesehen, was eine QPU tatsächlich ist.

Sie enthält physische Qubits, deren gemeinsamer Quantenzustand durch Quantengatter kontrolliert verändert wird.

Ein Quantencomputer mit mehr Qubits kann entsprechend größere Quantenzustände darstellen.

Bei n Qubits benötigen wir:

2^nAmplituden, um diesen gemeinsamen Zustand mathematisch zu beschreiben.

Das klingt zunächst nach einem einfachen Weg zu immer leistungsfähigeren Quantencomputern:

mehr Qubits
↓
größerer Quantenzustand
↓
größere QuantenberechnungenIn der Praxis ist genau dieser Schritt jedoch eines der größten Probleme des Quantencomputings.

Denn ein Qubit ist kein gewöhnlicher Transistor, den wir einfach millionenfach auf einen Chip setzen können.

Ein Qubit muss seinen Quantenzustand erhaltenEin klassisches Bit ist vergleichsweise robust.

Wenn eine Speicherzelle eine 0 enthält, bleibt sie normalerweise eine 0, bis wir ihren Zustand gezielt verändern.

Bei einem Qubit müssen wir dagegen einen empfindlichen Quantenzustand kontrollieren.

Dieser Zustand kann beispielsweise beschrieben werden als:

α |0⟩ + β |1⟩Dabei sind nicht nur die Messwahrscheinlichkeiten wichtig.

Auch die Phase zwischen den Bestandteilen des Zustands muss erhalten bleiben.

Genau diese Phase benötigen wir beispielsweise für Interferenz.

Verliert das Qubit diese Eigenschaften, funktioniert der geplante Quantenalgorithmus nicht mehr korrekt.

Was bedeutet Dekohärenz?Ein Qubit ist kein vollständig isoliertes System.

Es befindet sich in einer realen Umgebung.

Es kann beispielsweise mit seiner Umgebung wechselwirken.

Dadurch kann der sorgfältig vorbereitete Quantenzustand nach und nach verloren gehen.

Diesen Verlust der für die Quantenberechnung wichtigen Eigenschaften nennt man Dekohärenz.

Vereinfacht:

vorbereiteter Quantenzustand
↓
ungewollte Wechselwirkungen mit der Umgebung
↓
Amplitude und Phase verändern sich
↓
ursprünglicher Quantenzustand geht verlorenDas bedeutet nicht unbedingt, dass das Qubit plötzlich vollständig zerstört ist.

Aber der Zustand entspricht nicht mehr genau dem Zustand, den der Algorithmus benötigt.

Ein Qubit hat deshalb nur begrenzt ZeitEin Quantenalgorithmus muss innerhalb eines begrenzten Zeitraums ausgeführt werden.

Vereinfacht:

Qubit vorbereiten
↓
Quantengatter ausführen
↓
weitere Quantengatter
↓
...
↓
messenJe länger die Berechnung dauert, desto größer wird die Gefahr, dass Störungen den Quantenzustand verändern.

Ein Quantencomputer benötigt deshalb nicht nur funktionierende Qubits.

Er benötigt Qubits, die ihren Zustand lange genug und präzise genug erhalten, um die geplante Berechnung auszuführen.

Aber auch die Quantengatter sind nicht perfektBisher haben wir Quantengatter mathematisch als exakte Operationen betrachtet.

Ein H-Gatter führte beispielsweise genau die vorgesehene Transformation aus.

Auf realer Hardware wird ein Quantengatter jedoch durch physische Steuersignale umgesetzt.

Diese Umsetzung ist nicht vollkommen fehlerfrei.

Statt genau der gewünschten Veränderung kann beispielsweise eine geringfügig andere Veränderung entstehen.

Vereinfacht:

gewünschte Operation
↓
H
↓
exakter neuer Zustandist das mathematische Modell.

Auf realer Hardware kann es eher so aussehen:

gewünschte Operation
↓
physische Steuerung
↓
fast der gewünschte ZustandEin kleiner Fehler muss bei einer einzelnen Operation noch kein großes Problem sein.

Ein Algorithmus kann jedoch sehr viele Quantengatter enthalten.

Dann können sich Fehler ansammeln.

Viele kleine Fehler werden zu einem großen ProblemNehmen wir vereinfacht an, ein Quantengatter funktioniert mit sehr hoher Zuverlässigkeit.

Auch dann gilt:

ein Gatter
→ sehr geringe Fehlerwahrscheinlichkeitaber:

viele Tausend oder Millionen Gatter
→ viele Gelegenheiten für FehlerFür große Quantenalgorithmen reicht es deshalb nicht, dass jedes einzelne Quantengatter „fast immer“ funktioniert.

Die gesamte Berechnung muss zuverlässig genug bleiben.

Mehr Qubits bedeuten auch mehr VerbindungenEin weiteres Problem entsteht dadurch, dass Qubits miteinander wechselwirken müssen.

Für ein Quantengatter auf einem einzelnen Qubit reicht es, dieses Qubit gezielt zu verändern.

Für ein Gatter wie CNOT benötigen wir dagegen zwei Qubits.

Diese Qubits müssen miteinander gekoppelt werden können.

Auf einem realen Chip ist aber nicht automatisch jedes Qubit direkt mit jedem anderen verbunden.

Vereinfacht könnte eine QPU beispielsweise so aufgebaut sein:

Q1 — Q2 — Q3
|
Q4Hier kann Q2 direkt mit mehreren Qubits wechselwirken.

Q1 und Q3 sind dagegen nicht unmittelbar miteinander verbunden.

Wenn ein Algorithmus eine Operation zwischen nicht direkt verbundenen Qubits benötigt, müssen ihre Zustände zunächst über zusätzliche Operationen bewegt oder umgeordnet werden.

Dadurch entstehen:

mehr Quantengatter
↓
längere Berechnung
↓
mehr Möglichkeiten für FehlerDie physische Anordnung der Qubits ist deshalb für die Ausführung eines Quantenalgorithmus wichtig.

Mehr Qubits bedeuten auch mehr SteuerungJedes Qubit muss kontrolliert werden können.

Bei unserem Transmon-Beispiel benötigt die QPU Steuersignale, um Quantengatter auszuführen.

Außerdem müssen die Qubits am Ende gemessen werden.

Mit zunehmender Anzahl der Qubits wächst deshalb auch die notwendige klassische Technik:

mehr Qubits
↓
mehr Steuerleitungen
↓
mehr Steuersignale
↓
mehr Messungen
↓
mehr klassische ElektronikDiese Signale dürfen sich außerdem möglichst wenig gegenseitig beeinflussen.

Eine Steuerung für ein Qubit soll nicht versehentlich den Zustand eines benachbarten Qubits verändern.

Qubits können sich gegenseitig störenDiese ungewollte gegenseitige Beeinflussung wird häufig Crosstalk genannt.

Ein Steuersignal ist beispielsweise für Qubit 1 bestimmt.

Es beeinflusst aber geringfügig auch Qubit 2.

Vereinfacht:

Signal für Q1
↓
Q1 verändert sich wie gewünscht
+
Q2 verändert sich ungewollt ein wenigBei wenigen Qubits kann man solche Effekte noch vergleichsweise gut charakterisieren und ausgleichen.

Mit zunehmender Größe des Systems wird die Kontrolle schwieriger.

Das eigentliche SkalierungsproblemWir können jetzt sehen, warum:

10 Qubitsnicht einfach durch hundertfaches Kopieren zu:

1.000 Qubitswerden.

Mit jedem zusätzlichen Qubit wächst nicht nur die Anzahl der Qubits.

Es wachsen gleichzeitig die Anforderungen an:

• Stabilität
• Steuerung
• Verbindung zwischen den Qubits
• Genauigkeit der Quantengatter
• Messung
• Kalibrierung
• klassische Steuerelektronik Und gleichzeitig müssen die Quanteneigenschaften erhalten bleiben, die den Quantencomputer überhaupt interessant machen.

Fehler lassen sich nicht einfach ignorierenBei klassischen Computern treten ebenfalls Fehler auf.

Deshalb verwenden Computer verschiedene Verfahren zur Fehlererkennung und Fehlerkorrektur.

Auch bei Quantencomputern benötigen wir Fehlerkorrektur.

Hier entsteht jedoch ein zusätzliches Problem:

Wir können den Zustand eines Qubits nicht einfach jederzeit auslesen, prüfen und anschließend unverändert weiterrechnen.

Eine Messung verändert den Quantenzustand.

Wir benötigen deshalb eine Methode, mit der Fehler erkannt werden können, ohne den eigentlichen Quantenzustand direkt auszulesen.

Genau dafür gibt es die Quantenfehlerkorrektur.

Ein logisches Qubit besteht aus vielen physischen QubitsDie grundlegende Idee lautet:

Statt eine wichtige Quanteninformation in nur einem einzelnen physischen Qubit zu halten, verteilt man sie auf mehrere Qubits.

Diese Gruppe bildet zusammen ein logisches Qubit.

Wir müssen also zwei Begriffe unterscheiden:

Physisches QubitEin reales Qubit auf der Hardware.

Zum Beispiel ein einzelnes Transmon.

Logisches QubitEin durch mehrere physische Qubits gemeinsam geschütztes Qubit, mit dem der Algorithmus zuverlässig arbeiten soll.

Vereinfacht:

viele physische Qubits
↓
Fehlerkorrektur
↓
ein zuverlässigeres logisches QubitDas bedeutet:

Ein Quantencomputer mit beispielsweise:

1.000 physischen Qubitsbesitzt nicht automatisch:

1.000 zuverlässig nutzbare logische QubitsWarum braucht man dafür so viele Qubits?Die zusätzlichen Qubits helfen dabei festzustellen, ob Fehler aufgetreten sind.

Dabei versucht man nicht, einfach den gesamten Quantenzustand auszulesen.

Stattdessen werden bestimmte Beziehungen zwischen den Qubits überprüft.

Aus diesen Informationen kann das System erkennen, dass wahrscheinlich ein Fehler aufgetreten ist und welcher Art dieser Fehler war.

Der eigentliche Quanteninhalt soll dabei erhalten bleiben.

Vereinfacht:

Quantenzustand
↓
auf mehrere physische Qubits verteilt
↓
bestimmte Fehlerinformationen messen
↓
Fehler erkennen
↓
Korrektur durchführenDas ist erheblich aufwendiger als die Fehlerkorrektur eines klassischen Bits.

Fehlerkorrektur erzeugt selbst zusätzlichen AufwandDie zusätzlichen Qubits müssen ebenfalls:

• vorbereitet
• gesteuert
• gekoppelt
• gemessen werden.

Und auch diese Operationen können wieder Fehler verursachen.

Quantenfehlerkorrektur funktioniert deshalb nur, wenn die physischen Qubits und Quantengatter bereits ausreichend zuverlässig sind.

Erst dann kann die Fehlerkorrektur mehr Fehler beseitigen, als sie durch ihren eigenen zusätzlichen Aufwand erzeugt.

Physische Qubits und logische Qubits darf man deshalb nicht verwechselnWenn von der Größe eines Quantencomputers gesprochen wird, ist deshalb eine wichtige Frage:

Sind physische oder logische Qubits gemeint?Physische Qubits sind die realen Qubits auf der QPU.

Logische Qubits sind die für eine zuverlässige Berechnung nutzbaren, fehlerkorrigierten Einheiten.

Für große, lange laufende Quantenalgorithmen sind letztlich die logischen Qubits entscheidend.

Die reine Anzahl physischer Qubits erzählt deshalb nur einen Teil der Geschichte.

Mehr Qubits sind nicht automatisch ein besserer QuantencomputerDamit wird auch klar, warum die einfache Angabe:

Dieser Quantencomputer besitzt 1.000 Qubits.noch wenig über seine tatsächliche Leistungsfähigkeit aussagt.

Wir müssen zusätzlich wissen:

• Wie zuverlässig sind die Qubits?
• Wie lange bleibt ihr Quantenzustand erhalten?
• Wie zuverlässig sind die Quantengatter?
• Welche Qubits können direkt miteinander gekoppelt werden?
• Wie gut können die Qubits gemessen werden?
• Wie viele zusätzliche Operationen sind für einen Algorithmus notwendig?
• Gibt es bereits nutzbare logische Qubits? Die Zahl der Qubits allein ist deshalb keine direkte Entsprechung zu:

mehr Transistoren

schnellerer klassischer ProzessorWarum klassische Chips leichter skalierenBei einem klassischen Prozessor besteht die grundlegende Aufgabe darin, stabile elektrische Zustände zu erzeugen und gezielt zu schalten.

Transistoren sind dafür inzwischen extrem klein und zuverlässig.

Milliarden davon können auf einem Chip miteinander arbeiten.

Ihre Zustände sollen gerade nicht empfindlich auf winzige Einflüsse reagieren.

Bei einem Quantencomputer benötigen wir dagegen genau jene Quanteneigenschaften, die besonders empfindlich gegenüber ihrer Umgebung sind.

Das führt zu einem grundsätzlichen Spannungsfeld:

Qubits müssen gut kontrollierbar seinaber gleichzeitig:

Qubits müssen von störenden Einflüssen isoliert seinund zusätzlich:

Qubits müssen miteinander wechselwirken könnenDiese Anforderungen gleichzeitig zu erfüllen wird mit zunehmender Größe schwieriger.

Warum also nicht einfach bessere Qubits bauen?Natürlich versucht man genau das.

Bessere Qubits können:

• länger kohärent bleiben
• geringere Fehler bei Quantengattern besitzen
• genauer messbar sein
• weniger Crosstalk verursachen Aber selbst sehr gute physische Qubits werden nicht vollkommen fehlerfrei sein.

Für große zuverlässige Quantenberechnungen führt deshalb langfristig kein Weg an Fehlerkorrektur vorbei.

Das Ziel ist also nicht:

perfektes physisches Qubitsondern:

ausreichend gute physische Qubits
+
Fehlerkorrektur
↓
zuverlässige logische QubitsVon einem kleinen Experiment zu einem großen QuantencomputerDamit ergibt sich eine ganze Kette von Anforderungen:

physische Qubits bauen
↓
Qubits lange genug stabil halten
↓
Qubits präzise steuern
↓
Qubits gezielt miteinander koppeln
↓
Fehler bei Quantengattern reduzieren
↓
Qubits zuverlässig messen
↓
Fehler erkennen und korrigieren
↓
logische Qubits erzeugen
↓
viele logische Qubits miteinander betreiben
↓
großen Quantenalgorithmus ausführenJeder einzelne Schritt ist bereits anspruchsvoll.

Alle zusammen machen die Skalierung von Quantencomputern so schwierig.

Was wir jetzt wissen- Ein Qubit muss seinen Quantenzustand lange genug erhalten, damit eine Berechnung durchgeführt werden kann.

• Ungewollte Wechselwirkungen mit der Umgebung können diesen Zustand verändern.
• Der Verlust der für die Quantenberechnung wichtigen Eigenschaften wird Dekohärenz genannt.
• Auch reale Quantengatter sind nicht vollkommen fehlerfrei.
• Bei langen Berechnungen können sich kleine Fehler ansammeln.
• Nicht jedes Qubit einer QPU ist direkt mit jedem anderen verbunden.
• Zusätzliche Verbindungen und Umordnungen können weitere Quantengatter erfordern.
• Mehr Qubits benötigen mehr Steuerung und Messung.
• Qubits können sich durch Crosstalk gegenseitig beeinflussen.
• Große Quantencomputer benötigen deshalb Fehlerkorrektur.
• Ein logisches Qubit wird mit Hilfe mehrerer physischer Qubits geschützt.
• Die Anzahl physischer Qubits ist deshalb nicht gleich der Anzahl zuverlässig nutzbarer logischer Qubits.
• Die reine Qubit-Zahl reicht nicht aus, um die Leistungsfähigkeit eines Quantencomputers zu beurteilen.
• Skalierung bedeutet nicht nur, mehr Qubits zu bauen, sondern viele Qubits gleichzeitig zuverlässig zu kontrollieren. Ein großer Quantencomputer benötigt deshalb nicht einfach mehr Qubits.

Er benötigt viele Qubits, die gemeinsam lange und präzise genug funktionieren, damit daraus zuverlässige logische Qubits entstehen.

In Episode 10 schauen wir uns an, was Quantencomputer mit ausreichender Größe und Fehlerkorrektur tatsächlich schneller berechnen könnten — und welche Probleme auch dann klassische Computer bleiben werden.