In dieser Application Note werden wir die verschiedenen Arten von Quanten-Constraints erörtern, warum sie wichtig sind und wie die Classiq-Softwareplattform für den Entwurf von Quantenalgorithmen den Benutzern ermöglicht, diese Constraints zu erfüllen und die Kompromisse zwischen ihnen zu untersuchen.

Über Constraints

Wir leben in einer Welt mit Einschränkungen. In der klassischen Datenverarbeitung zeigt die Fülle von Sortieralgorithmen, dass es bei jeder Einschränkung einen Kompromiss gibt, wobei es keine einzige Lösung gibt, die für alle Fälle die beste ist. Die Schnellsortierung ist sehr schnell, wird aber durch die richtige Implementierung eingeschränkt, die Heap-Sortierung benötigt wenig Speicherplatz, kann aber durch die Geschwindigkeit eingeschränkt werden, und so weiter. Beschränkungen sind die Barrieren zwischen dem Möglichen und dem Unmöglichen.

In der Quanteninformatik zeigt sich dies in einer Vielzahl von messbaren Eigenschaften: Anzahl der Qubits, Dekohärenzzeiten, Schaltkreistiefe, Basisgatter usw. 

Diese Quantenbeschränkungen diktieren das Potenzial, wobei viele Kompromisse untersucht werden sollten. Ein Finanzinstitut, das an der Optimierung von Portfolios mithilfe hybrider Quanten-/Klassik-Algorithmen interessiert ist, legt vielleicht mehr Wert auf die Anzahl der Qubits als auf die reine Genauigkeit der Lösung. Oder ein Logistikunternehmen, das an der Lösung von Erfüllbarkeitsproblemen mit reinen Quantenalgorithmen interessiert ist, ist am meisten an der Schaltungstiefe interessiert, da die Fehler mit jedem Gatter zunehmen. Quantenbeschränkungen sind keine Einheitsgröße für alle. Jeder Quantenanwendungsfall hat andere Prioritäten, und jeder Hardwarehersteller hat andere Einschränkungen. Es lohnt sich, offen und beweglich zu bleiben, da sich die Führung im Hardware-Quantenwettrüsten häufig ändert.

Die heutigen Quantencomputer werden zu gegebener Zeit ersetzt werden, wobei sich die Grenzen ihres Potenzials weiterentwickeln. Wir haben bereits gesehen, dass Hardware mit einstelligen Qubit-Zahlen von solchen mit Hunderten von Qubits übertroffen wurde, und IBM erwartet bis 2023 eine 1000-Qubit-Maschine. Die Unternehmen wollen die maximale Leistung aus den bestehenden Computern herausholen, aber auch flexibel genug sein, um sich an die neuen Anforderungen künftiger Generationen von Quantencomputern anzupassen.

Classiq bietet eine einzigartige Softwareplattform, die Unternehmen bei der Erstellung optimierter Quantensoftware unterstützt, indem sie die Vorteile der heutigen Maschinen nutzt und sich gleichzeitig auf die Maschinen von morgen vorbereitet. Mit der Classiq-Plattform können Benutzer problemlos zwischen Hardware-Anbietern und ihren spezifischen Einschränkungen wechseln. Die leistungsstarke Synthese-Engine von Classiq nimmt High-Level-Funktionsmodelle (z. B. eine Definition dessen, was die Software tun muss) und eine Reihe von benutzerdefinierten Einschränkungen auf. Die Plattform wandelt diese dann in ein implementierbares Programm um, das die Funktionalität unter Einhaltung der Einschränkungen liefert und auf dem Quantenhardware-Anbieter der Wahl ausgeführt werden kann.

Da nicht festgelegt werden muss, welche Gatter mit welchen Qubits verbunden sind, können sich die Benutzer darauf konzentrieren, was innerhalb welcher Einschränkungen erreicht werden kann, während die Classiq-Plattform das Wie regelt. Die Classiq-Plattform kümmert sich um das Wie, indem sie einen riesigen Entwurfsraum möglicher Implementierungen untersucht und versucht, eine Methode zu finden, die sowohl die Funktionalität als auch die Randbedingungen erfüllt. Wenn sich also die Randbedingungen ändern, wird einfach eine neue Schaltung unter Verwendung des bestehenden Funktionsmodells erstellt.

Untersuchen wir einige Quanten-Constraints und ihre Kompromisse, die mit Classiq implementiert werden können.

Schaltungsgenauigkeit

Die Genauigkeit einer Schaltung kann auf viele Arten dargestellt werden und ist ein Maß dafür, wie nahe unser Ergebnis an unseren Erwartungen liegt. In einem Schaltkreis, der Qubits auf einen bestimmten Zustand vorbereitet, bietet Classiq beispielsweise verschiedene Fehlermetriken an - die Kullback-Leibler (KL)-Divergenz, Lp-Normen und mehr - sei es durch die Angabe der Wahrscheinlichkeitsfunktion oder der Gaußschen Mischung. Heute werden wir zeigen, wie wir mit der KL-Metrik arbeiten. 

Nehmen wir an, wir müssen 3 Qubits mit dem folgenden Zustand initialisieren:

Wir können dies erreichen, indem wir die Funktion Classiq State Preparation aufrufen und die Wahrscheinlichkeiten angeben. Beginnen wir damit, dass wir als Einschränkung einen maximalen KL-Fehler von 1 % oder eine Genauigkeit von 99 % für jeden Zustand festlegen.

Classiq bietet zwei gleichwertige Methoden zum Entwurf von Quantenschaltungen: ein Textmodell, das als VSCode-Plugin zugänglich ist, oder ein Python-SDK.

So sieht diese Zustandsvorbereitung im Textuellen Modell aus:

{
   "logic_flow": [{
       "function": "StatePreparation",
       "function_params": {
         "probabilities": {"pmf": [0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
         "error_metric": {"KL": {"upper_bound": 0.01}}
       }
     }
   ]
 }

Und mit dem Python-SDK:

from classiq import ModelDesigner
from classiq.builtin_functions import StatePreparation
from classiq.interface.generator.state_preparation import PMF

model_designer = ModelDesigner()
probabilities = (0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06)

params = StatePreparation(probabilities=PMF(pmf=probabilities),
                         error_metric={"KL": {"upper_bound": 0.01}})

model_designer.StatePreparation(params=params)

circuit = model_designer.synthesize()
circuit.show()
print(circuit.qasm)

Wenn wir diese Schaltung generieren, wird der Code des Benutzers über die Cloud an Classiq gesendet, die Synthese-Engine findet die optimale Schaltung, das Ergebnis wird an den Benutzer zurückgeschickt, und der an die Cloud gesendete Code wird automatisch gelöscht, wobei Classiq nur die Metriken behält, die sich darauf beziehen, ob die Synthese erfolgreich war. Hier ist unser Ergebnis in VS Code:

Wir haben einfach die Wahrscheinlichkeiten und die Genauigkeit angegeben, und wir erhalten diese Schaltung mit 4 Qubits, die durch eine Vielzahl von Gattern gesteuert werden. Da wir drei Qubits in diesem speziellen Zustand haben wollten (gekennzeichnet als _q0 bis _q2), wurde automatisch ein zusätzliches Qubit, _q3, erzeugt, um die Berechnungen bei der Vorbereitung unserer drei Qubits zu unterstützen.

Neben unserem generierten Schaltkreisbild sehen wir auf der rechten Seite den Open QASM 2.0 Code, der dies implementiert.

Was aber, wenn wir nicht über die Ressourcen für eine so genaue Schaltung verfügen oder es vorziehen, die Quantenressourcen für spätere Phasen unseres Algorithmus zu erhalten? Schauen wir uns an, wie anders eine Schaltung mit einem KL-Fehler von 5 % aussieht.

Mit einer kleinen Änderung können wir sehr unterschiedliche Ergebnisse erzielen. Wir können sehen, wie unterschiedlich diese Genauigkeiten sind, wenn wir unseren Open QASM 2.0 Code in den IBM Quantum Composer einfügen.

Da es so einfach ist, Quantenschaltungen mit funktionalem Code zu bearbeiten, können die Benutzer viel mehr Zeit damit verbringen, Kompromisse zu untersuchen oder neue Ideen für Schaltungen zu entwickeln. Sehen wir uns ein weiteres Beispiel für eine Quantenbeschränkung an.

Breite des Kreises

Die Breite eines Quantenschaltkreises ist die Anzahl der Qubits im Schaltkreis. Im Gegensatz zu klassischen Schaltkreisen können Quantenschaltungen nur in eine Richtung fließen, wobei die Breite oder die Anzahl der Qubits die Form des Schaltkreises zusammen mit der Tiefe bestimmt, auf die wir später noch eingehen werden. Während manche die Anzahl der Qubits eines Quantencomputers als Hauptfaktor für seine Stärke bezeichnen, spielen viele Faktoren eine Rolle bei der Entscheidung, welcher Computer für welchen Fall am besten geeignet ist.

Nehmen wir an, wir benötigen 3 Instanzen unserer obigen 3-Qubits-Zustandsvorbereitung mit einem KL-Fehler von 5%.

Im weiteren Verlauf dieser Application Note konzentrieren wir uns auf das Textual Model, obwohl die Funktionalität auch mit dem Python SDK erreicht werden kann. Wir rufen unsere State Preparation-Funktion dreimal auf:

{
	"logic_flow": [
    	{
    	"function": "StatePreparation",
    	"function_params": {
        	"probabilities": {"pmf":[0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
        	"error_metric": {"KL": {"upper_bound": 0.05}}
            },
    	"name": "state_preparation_1"
    	},
    	{
    	"function": "StatePreparation",
    	"function_params": {
        	"probabilities": {"pmf":[0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
        	"error_metric": {"KL": {"upper_bound": 0.05}}
        	},
    	"name": "state_preparation_2"
    	},
    	{
    	"function": "StatePreparation",
    	"function_params": {
        	"probabilities": {"pmf":[0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
        	"error_metric": {"KL": {"upper_bound": 0.05}}
        	},
    	"name": "state_preparation_3"
    	}
	]
}

Und unsere daraus resultierende Schaltung:

‍

Was aber, wenn wir auf 10 Qubits beschränkt sind, um diese Schaltung zu erstellen? Können wir die gleiche Funktionalität wie mit dieser Schaltung erreichen, obwohl wir in der Breite eingeschränkt sind? Versuchen wir, die Anzahl der Qubits zu beschränken.

In unserem Textmodell fügen wir diese Zeile direkt vor unserem logischen Ablauf ein.

"constraints": {"max_width": 10},

Das Ergebnis?

Die Schaltungssynthese ist erfolgreich. Dieser interaktive Schaltkreis kann durch Anklicken des -/+ Symbols in der oberen linken Ecke jedes Blocks komprimiert/erweitert werden. Wir haben 2 Qubits eingespart, während wir einen tieferen Schaltkreis erstellt haben, da die Classiq-Plattform automatisch die Wiederverwendung von Hilfsqubits erforscht, wie hier bei q3 _{und q7}. Dies spart nicht nur Quantenexperten Zeit und Energie beim Entwurf auf Komponentenebene, sondern dieser Prozess der Lösungsfindung unter gegebenen Randbedingungen kann auch von Experten in anderen Bereichen mühelos durchgeführt werden.

Schaltungstiefe

Die Tiefe bestimmt, wie oben erwähnt, die Form der Schaltung, wobei tiefere Schaltungen oft mehr Gatter haben als flachere. In der heutigen Ära der Quantenhardware können sich Gatterfehler schnell summieren. Bei einer zu tiefen Schaltung kann es zu unsinnigem Rauschen kommen, so dass die Minimierung der Tiefe entscheidend sein kann.

Nehmen wir an, wir haben 16 Qubits, um 5 verschiedene Zustandsvorbereitungen mit unterschiedlichen KL-Fehlern zu implementieren, wie im folgenden Code zu sehen:

{
   "constraints": {
       "max_width": 16
   },
   "logic_flow": [{
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.2, 0.05, 0.3, 0.0, 0.0, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.3}}
       },
       "name": "sp1"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.2, 0.05, 0.0, 0.3, 0.0, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.32}}
       },
       "name": "sp2"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.0, 0.05, 0.3, 0.0, 0.2, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.32}}
       },
       "name": "sp3"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.0, 0.2, 0.05, 0.3, 0.0, 0.0, 0.05]
           },
           "error_metric": {"KL": {"upper_bound": 0.34}}
       },
       "name": "sp4"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.2, 0.0, 0.35, 0.0, 0.0, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.3}}
       },
       "name": "sp5"
   }
]
}

Wir können sehen, dass die Wiederverwendung von Hilfsqubits auf _q3, _q7 und _q14 auftritt , und wir können das Werkzeug Classiq Analyzer verwenden, um zu sehen, wie tief dieser Schaltkreis ist - in diesem Fall 126.

Angenommen, wir sind auf eine Tiefe von 85 begrenzt. Fügen wir eine Tiefenbeschränkung hinzu, um zu sehen, ob diese Funktionalität auch auf andere Weise erstellt werden kann. Wir geben dies in unserem Constraints-Dictionary an.

   "constraints": {
       "max_width": 16,
       "max_depth": 85
   },

Und unsere Schaltung:

Wir sehen jetzt die Wiederverwendung von Hilfs-Qubits auf _q3, _q7, _q11 und _q15, und unsere Schaltungstiefe beträgt 82. Mit Classiq können Sie nicht nur einfach Quantenschaltungen synthetisieren und bearbeiten, sondern sie auch nahtlos analysieren, um die für Sie spezifischen Kompromisse besser zu untersuchen.

Tor-Satz

Genauso wie die spezifische Modalität zur Erreichung manipulierbarer Qubits von Hardware-Anbieter zu Hardware-Anbieter variiert, so variieren auch die nativen Gattersätze. Diese Basissätze bestimmen, welche Manipulationen möglich sind, wobei alle Operationen aus Kombinationen dieser Gatter bestehen. Der IBMQX5 verfügt beispielsweise über einen nativen Gattersatz aus _u1(λ), _u2(λ,θ), _u3(λ,θ,Φ) und CNOT-Gattern, während der Agave-Prozessor von Rigetti über _Rx-, _Rz- und CZ-Gatter verfügt. Wir wissen zwar nicht, wer das Quantenwettrüsten gewinnen wird, aber die Möglichkeit zu wählen, welche nativen Gatter Ihre Schaltung verwendet, ist wichtig, um nicht an einen Anbieter mit überragender Leistung gebunden zu sein.

Angenommen, wir wollen den folgenden Zustand:

Wir können diesen Zustand mit einem KL-Fehler von 1 % mit der Schaltung erreichen, die aus dem folgenden textuellen Modellcode erzeugt wird:

{
	"logic_flow":[
  	{
     	"function": "StatePreparation",
     	"function_params": {
        	"probabilities": {"pmf":[0.45, 0.11, 0.23, 0.21]},
        	"error_metric": {"KL": {"upper_bound": 0.01}}
     	}
  	}
   ]
}

Wir sehen unsere Ausgabe Open QASM 2.0 Code, und diese Schaltung hat 2 Qubits mit einer Tiefe von 7 durch die Verwendung von Hadamard, RY, X, und CNOT Gates.

Was aber, wenn unser Hardware-Anbieter einen speziellen Gattersatz ohne diese Optionen anbietet? Können wir mit einem Basisgattersatz aus CNOT-, SQRT(X)-, RZ- und X-Gattern die gleichen Ergebnisse erzielen? Lassen Sie uns diese Gatter in unserem Code über unserem Logikfluss angeben.

	"hardware_settings": {
  	"basis_gates": ["cx", "sx", "rz", "x"]
   },

Wir sehen, dass dieser Zustand auch dann erreicht werden kann, wenn man sich auf diese Gatter beschränkt, aber mit einem etwas tieferen Schaltkreis. 

Transpiler kümmern sich um die Umwandlung von Basisgattern in Universalgatter, aber wenn diese Einschränkung auf der Funktionsebene vorgenommen wird, können durch Optimierung bessere Ergebnisse erzielt werden, wenn die Schaltungen viel größer werden. Während ein Transpiler aufeinanderfolgende Hadamard-Gatter aufheben kann, sind sie nicht in der Lage, aufeinanderfolgende Funktionsblöcke, wie QFT gefolgt von ^QFT†, aufzuheben.

Zum Schluss wollen wir uns vergewissern, dass diese Schaltkreise die gleiche Funktionalität haben, indem wir unseren Open QASM 2.0-Code von jedem Schaltkreis in den IBM Quantum Composer kopieren.

Und wir sehen die gleiche Wahrscheinlichkeitsverteilung. Die Möglichkeit, die Basisgatter zu wechseln, ist ein wesentlicher Bestandteil der Flexibilität und Offenheit gegenüber mehreren Hardwareanbietern, die sich oft gegenseitig übertreffen und eine Vielzahl von Vorteilen bieten.

Schlussfolgerung

In dieser Application Note erfahren wir, wie Quantenbeschränkungen aus Hardwarebeschränkungen entstehen und wie eine Software, die diese Beschränkungen leicht anpassen kann, es den Benutzern ermöglicht, die Kompromisse zwischen ihnen zu untersuchen. Ganz gleich, ob Sie durch Schaltungstiefe, -breite, -genauigkeit oder andere Faktoren eingeschränkt sind, Classiq kann sich Ihren Anforderungen anpassen.

Wenn Sie mehr darüber erfahren möchten, wie Classiq Sie bei der Anpassung an verschiedene Quantenbeschränkungen unterstützen kann, vereinbaren Sie hier eine unverbindliche Demonstration oder sehen Sie sich unsere kommenden Veranstaltungen an.