Speed-oriented quantum circuit backend

Die Autoren stellen eine neuartige Software vor, die durch ihre hohe Geschwindigkeit bei der Generierung von Quantenschaltkreisen – wie am Beispiel des Quanten-Fourier-Transforms mit bis zu 2000 Qubits demonstriert – bestehende Frameworks wie Qiskit und Q# übertrifft und somit die klassische Vorverarbeitungszeit für Anwendungen wie kombinatorische Optimierung minimiert.

Das Wesentliche

Stellen Sie sich vor, Sie wollen ein riesiges, komplexes Bauwerk errichten – sagen wir, einen Wolkenkratzer aus Legosteinen. In der Welt der Quantencomputer sind diese Legosteine die sogenannten Qubits und die Anweisungen, wie sie zusammengefügt werden, sind die Quantenschaltungen.

Bisher gab es ein Problem: Die Architekten (die Software), die diese Pläne entwerfen, waren oft viel zu langsam und verschwenderisch. Bevor der eigentliche Bau (die Berechnung auf dem Quantencomputer) beginnen konnte, musste die Software stundenlang Pläne zeichnen, die dann oft wieder verworfen wurden. Das war wie ein Architekt, der für ein kleines Haus erst eine ganze Bibliothek voller Baupläne schreibt, nur um dann festzustellen, dass er den ersten Stein gar nicht richtig gesetzt hat.

Hier kommt die Arbeit von Sören Wilkening ins Spiel. Er hat eine neue, superschnelle Software entwickelt, die diese Pläne entwirft.

Die Hauptidee: Der "Turbo-Architekt"

Stellen Sie sich die alte Software wie einen langsamen, sorgfältigen Handwerker vor, der jeden einzelnen Legostein einzeln nimmt, ihn in eine Liste schreibt, die Liste durchsucht, um zu sehen, ob er schon einen ähnlichen Stein hat, und dann erst baut. Wenn Sie 2000 Steine haben, dauert das ewig.

Die neue Software von Wilkening ist wie ein Roboter-Architekt mit einem perfekten Gedächtnis:

1. Keine unnötigen Umwege: Statt die ganze Liste jedes Mal zu durchsuchen, weiß der Roboter sofort: "Ah, für diesen Stein gibt es genau diese eine Stelle in der Reihe." Er nutzt eine Art intelligentes Regalsystem (in der Fachsprache "Lookup-Table"), bei dem er sofort weiß, wo welcher Stein hingelegt werden muss.
2. Gleichzeitiges Bauen: Wenn zwei Steine sich nicht gegenseitig stören, legt der Roboter sie nicht nacheinander, sondern parallel in die gleiche "Schicht" des Gebäudes. Das spart enorm viel Zeit.
3. Selbstkorrektur: Wenn der Roboter merkt, dass er gerade einen Stein legt, der einen vorherigen wieder rückgängig macht (wie "Vorwärts" und dann sofort "Rückwärts"), löscht er beide einfach aus dem Plan, ohne sie erst aufzuschreiben. Das ist wie ein Textverarbeitungsprogramm, das "Löschen" und "Einfügen" sofort wieder rückgängig macht, bevor Sie überhaupt den Enter-Taste drücken.

Das große Rennen: 2000 Qubits

Um zu beweisen, wie schnell ihre Software ist, haben sie einen klassischen Testlauf gemacht: Die Quanten-Fourier-Transformation (QFT). Man kann sich das wie das Entwirren eines riesigen, verknoteten Fadens vorstellen. Je mehr Qubits (Fadenenden) man hat, desto schwieriger wird es.

• Der Vergleich: Sie haben ihre Software gegen die großen, bekannten Konkurrenten (wie Qiskit, Cirq oder Q#) antreten lassen.
• Das Ergebnis: Bei kleinen Projekten (wenige Qubits) war ihre Software schon 100- bis 1000-mal schneller. Aber bei großen Projekten (bis zu 2000 Qubits) wurde es spektakulär:
  • Gegenüber Q# war ihre Software über 1,7 Millionen Mal schneller.
  • Gegenüber PyTKet waren es über 1200-mal schneller.

Das ist so, als würde ein Rennwagen, der in 10 Sekunden eine Strecke schafft, während die anderen Autos noch in der Einfahrt stehen und den Motor starten.

Warum ist das wichtig?

Man könnte denken: "Na und? Der Quantencomputer ist trotzdem langsam." Aber hier liegt der Clou:

In vielen Anwendungen (wie der Optimierung von Lieferketten oder Finanzmodellen) muss der klassische Computer erst den Plan für den Quantencomputer erstellen, bevor dieser überhaupt anfangen kann zu rechnen. Wenn das Erstellen des Plans länger dauert als die eigentliche Rechnung, verliert man den ganzen Vorteil der Quantentechnologie.

Wilkeings Software sorgt dafür, dass das Planen fast sofort passiert. So bleibt mehr Zeit für das eigentliche, magische Rechnen des Quantencomputers.

Zusammenfassung in einem Satz

Sören Wilkening hat einen digitalen Baumeister gebaut, der Quantenpläne so schnell und effizient entwirft, dass er die alten Methoden um ein Vielfaches übertrifft – und damit den Weg für riesige, zukünftige Quantencomputer ebnet, ohne dass wir uns Sorgen machen müssen, dass der Planer den ganzen Tag braucht, nur um die Baustelle freizumachen.

Technische Zusammenfassung

Titel: Geschwindigkeitsorientiertes Backend für Quantenschaltkreise

Autor: Sören Wilkening (Institut für Theoretische Physik, Leibniz Universität Hannover)

---

1. Problemstellung

Mit dem Fortschritt hin zu fehlertoleranten Quantencomputern mit einer großen Anzahl an Qubits verschieben sich die Anforderungen an die Software-Stacks. Während in der aktuellen NISQ-Ära (Noisy Intermediate-Scale Quantum) die Optimierung von Qubit-Anzahl und Gate-Tiefe im Vordergrund steht, wird bei zukünftigen großen Systemen die Laufzeit der klassischen Vorverarbeitung (insbesondere die Generierung der Schaltkreise selbst) zu einem kritischen Engpass.

In Anwendungen wie der kombinatorischen Optimierung darf die Zeit für die Schaltkreisgenerierung den Gesamtlaufzeitvorteil des Quantenalgorithmus nicht aufzehren. Bestehende Frameworks (wie Qiskit, Cirq, Q#) kombinieren oft Generierung, Simulation und Ausführung, was zu hohem Overhead führt. Es fehlt an spezialisierten Backends, die sich ausschließlich auf die hohe Durchsatzrate und minimale Laufzeit bei der Schaltkreisgenerierung konzentrieren, ohne dabei die Generierungsfähigkeit für komplexe Algorithmen einzuschränken.

2. Methodik und Architektur

Der Autor stellt ein neues Softwarepaket zur Quantenschaltkreis-Generierung (QCG) vor, das für maximale Performance optimiert ist.

• Implementierungssprache: Das Backend wurde in C geschrieben, um externe Abhängigkeiten zu vermeiden und maximale Kontrolle über Speicher und Laufzeit zu gewährleisten.
• Datenstrukturen:
  • Gate-Repräsentation: Ein Gate wird durch Typ, Ziel-Qubits, Kontroll-Qubits und (optional) einen Parameter definiert.
  • Schichtbasierte Darstellung (Layered Representation): Anstatt Gates linear in einer Liste zu speichern, werden sie in Schichten (Layers) organisiert. Eine Schicht besteht aus unabhängigen Operationen auf disjunkten Qubits, die parallel ausgeführt werden können.
  • Optimierte Lookup-Tabellen: Um die Komplexität beim Einfügen neuer Gates zu minimieren, werden zwei spezielle Tabellen verwendet:
    1. last_layer_of_qubit: Speichert für jedes Qubit die Liste der besetzten Schichten, um die minimal mögliche Schicht für ein neues Gate in O(1) Zeit zu bestimmen (statt O(N) durch Suche).
    2. gate_index: Eine 2D-Struktur, die den Index eines Gates im Array basierend auf Layer und Qubit speichert, um effiziente Zugriffe und Optimierungen (wie das Zusammenfassen parametrischer Gates) zu ermöglichen.
• Algorithmen zur Optimierung:
  • Redundanzeliminierung: Wenn ein neues Gate das Inverse eines bereits existierenden Gates in der letzten Schicht ist, werden beide eliminiert.
  • Parametrisches Zusammenfassen: Bei parametrischen Gates (z. B. kontrollierte Phasengates) mit gleichen Kontroll- und Ziel-Qubits werden die Parameter addiert, anstatt neue Gates zu erzeugen.
  • Kommutativitätsprüfung: Gates werden so weit wie möglich in frühere Schichten verschoben, wenn sie mit dortigen Gates kommutieren, um die Gesamttiefe zu reduzieren.
• High-Level-Primitiven: Das System unterstützt nicht nur Gate-für-Gate-Generierung, sondern auch „Assembly-ähnliche" Anweisungen für ganzzahlige und boolesche Operationen (Addition, Multiplikation, Division). Diese werden als vordefinierte Routinen (z. B. QFT) direkt in die korrekten Schichten eingefügt, was die Generierung weiter beschleunigt.

3. Wichtige Beiträge

1. Spezialisiertes Backend: Ein reines Generierungs-Backend, das Entkopplung von Simulation und Ausführung bietet, was eine nahtlose Integration in High-Level-Sprachen oder Optimierer erlaubt.
2. Skalierbarkeit: Die Fähigkeit, Schaltkreise für Systeme mit bis zu 2000 Qubits zu generieren, was mit bestehenden Tools oft nicht oder nur extrem langsam möglich ist.
3. Effiziente Datenstrukturen: Die Einführung der schichtbasierten Darstellung mit Lookup-Tabellen ermöglicht konstante Zugriffszeiten (O(1)) für das Einfügen und Optimieren von Gates.
4. Benchmarking: Umfassender Vergleich mit 12 führenden Quanten-Software-Frameworks (u.a. Qiskit, Cirq, Q#, PyTKet, Quipper).

4. Ergebnisse

Als Benchmark diente die Quanten-Fourier-Transformation (QFT), da sie in vielen Algorithmen (Shor, Amplitudenabschätzung) vorkommt.

• Laufzeit:
  • Für kleine Schaltkreise (1–10 Qubits) ist das neue Backend 2 bis 3 Größenordnungen schneller als die schnellsten existierenden Tools.
  • Bei 2000 Qubits erreicht das optimierte Backend (QCB-improved) eine 1.748.000-fache Beschleunigung im Vergleich zu Q# und eine 1209-fache Beschleunigung im Vergleich zu PyTKet.
  • Das Backend nähert sich der theoretischen Untergrenze für die Generierungszeit an.
• Speichereffizienz:
  • Zur Generierung eines 2000-Qubit-QFT-Schaltkreises werden nur 100–300 MB RAM benötigt.
  • Im Vergleich dazu benötigen andere Tools mehrere Gigabyte RAM für dieselbe Aufgabe. Nur das Tool „Ket" war bei den größten Schaltkreisen minimal effizienter, aber bei weitem nicht so schnell.
• Theoretische Grenzen: Die Ergebnisse zeigen, dass das Backend nahe an die physikalischen Grenzen der Datenverarbeitung (Hardware-Limit) herankommt und keine signifikant schnellere Single-Thread-Implementierung möglich erscheint.

5. Bedeutung und Ausblick

Das Paper demonstriert, dass die klassische Vorverarbeitung nicht länger als vernachlässigbarer Schritt betrachtet werden darf. Durch die drastische Reduzierung der Generierungszeit und des Speicherverbrauchs ermöglicht dieses Backend:

• Realistischere Zeitplanungen: Genauere Schätzungen der Gesamtlaufzeit (Wall-Clock-Time) für End-to-End-Quanten-Workflows.
• Skalierbarkeit: Die Möglichkeit, sehr große Probleme in Cloud-Umgebungen oder verteilten Systemen zu bearbeiten, ohne dass die Ressourcenkosten durch den Speicherbedarf explodieren.
• Grundlage für zukünftige Stacks: Es dient als fundamentale Komponente für zukünftige High-Level-Programmiersprachen, die auf große Quantensysteme ausgelegt sind.

Zukünftige Arbeiten sollen die Integration von hardware-spezifischen Kompilierungsoptimierungen, automatischer Fehlerkorrektur (logisch zu physikalisch) und Multithreading umfassen, um die Leistung weiter zu steigern.