Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Quantinuum bietet Zugang zu Systemen mit gefangenen Ionen, hoher Treue, vollständig verbundenen Qubits und der Fähigkeit zur Durchführung von Messungen innerhalb eines Schaltkreises.
- Herausgeber: Quantinuum
- Anbieter-ID:
quantinuum
Ziele
Die folgenden targets sind bei diesem Anbieter verfügbar:
Zielname | Ziel-ID | Anzahl von Qubits | Beschreibung |
---|---|---|---|
H1-1-Syntaxprüfung | quantinuum.sim.h1-1sc | 20 Qubits | Hiermit können Sie Quantenprogramme für den H1-1-Compiler überprüfen, bevor Sie sie an Hardware oder Emulatoren der Quantinuum-Plattform übermitteln. Dafür fallen keine Kosten an. |
H2-1-Syntaxprüfer | quantinuum.sim.h2-1sc | 56 Qubits | Verwenden Sie dies, um Quantenprogramme gegen den H2-1-Compiler zu validieren, bevor Sie auf der Quantinuum-Plattform an Hardware oder Emulatoren übermitteln. Dafür fallen keine Kosten an. |
H2-2-Syntax Checker | quantinuum.sim.h2-2sc | 56 Qubits | Hiermit können Sie Quantenprogramme für den H2-2-Compiler überprüfen, bevor Sie sie an Hardware oder Emulatoren der Quantinuum-Plattform übermitteln. Dafür fallen keine Kosten an. |
H1-1-Emulator | quantinuum.sim.h1-1e | 20 Qubits | Verwendet ein realistisches physisches Modell und ein entsprechendes Rauschmodell von H1-1. |
H2-1 Emulator | quantinuum.sim.h2-1e | 56/32 Qubits | Verwendet ein realistisches physisches Modell und ein entsprechendes Rauschmodell von H2-1. 56-Qubit-Simulation ist nur als Stabilisatorsimulation verfügbar. |
H2-2-Emulator | quantinuum.sim.h2-2e | 56/32 Qubits | Verwendet ein realistisches physisches Modell und ein entsprechendes Rauschmodell von H2-2. 56-Qubit-Simulation ist nur als Stabilisatorsimulation verfügbar. |
H1-1 | quantinuum.qpu.h1-1 | 20 Qubits | H1-1-Gerät mit Ionenfalle von Quantinuum. |
H2-1 | quantinuum.qpu.h2-1 | 56 Qubits | Das H2-1-Ionenfalle-Gerät von Quantinuum. |
H2-2 | quantinuum.qpu.h2-1 | 56 Qubits | H2-2-Gerät mit Ionenfalle von Quantinuum. |
Die targets von Quantinuum entsprechen einem QIR Adaptive RI-Profil. Weitere Informationen zu diesem target Profil und seinen Einschränkungen finden Sie unter Grundlegendes target zu Profiltypen in Azure Quantum.
Alle targets von Quantinuum unterstützen jetzt integrierte Hybridschaltungen. Weitere Informationen zum Übermitteln integrierter Hybridaufträge finden Sie unter Integrated Hybrid Computing.
Informationen zu den ersten Schritten mit dem Quantinuum-Anbieter in Azure Quantum finden Sie unter "Erste Schritte mit Q#" und einem Azure Quantum-Notizbuch.
Tipp
Quantum-Aufträge, die im Rahmen einer Sitzung eingereicht werden, haben exklusiven Zugriff auf die Quantinuum-Hardware, solange Sie die Aufträge innerhalb einer Minute nacheinander in die Warteschlange stellen. Danach wird jeder Auftrag mit der Standard-Warteschlangen- und Priorisierungslogik akzeptiert und behandelt. Weitere Informationen finden Sie in Sitzungen in Azure Quantum.
Syntaxprüfungen
Benutzer sollten ihren Code zunächst mithilfe einer Syntaxprüfung überprüfen. Dies ist ein Tool zum Überprüfen der richtigen Syntax, Kompilierungsabschluss und Computerkompatibilität. Syntaxprüfer verwenden denselben Compiler wie der Quantencomputer.target Beispielsweise verwendet die Syntaxprüfung H1-1 denselben Compiler wie H1-1. Der gesamte Kompilierungsstapel wird ausgeführt (mit Ausnahme der tatsächlichen Quantenvorgänge). Wenn der Code kompiliert wird, gibt die Syntaxprüfung einen success
Status und ein Ergebnis aller 0er zurück. Wenn der Code nicht kompiliert wird, gibt die Syntaxprüfung einen Fehlerstatus zurück und gibt den zurückgegebenen Fehler an, um Benutzern das Debuggen ihrer Schaltkreissyntax zu erleichtern. Mit der Syntaxprüfung können Entwickler ihren Code jederzeit überprüfen, auch wenn die Computer offline sind.
- Auftragstyp:
Simulation
- Datenformate:
honeywell.openqasm.v1
,honeywell.qir.v1
- Ziel-ID:
- H1-1-Syntaxprüfung:
quantinuum.sim.h1-1sc
- H2-1 Syntaxprüfer:
quantinuum.sim.h2-1sc
- H2-2-Syntaxprüfung:
quantinuum.sim.h2-2sc
- H1-1-Syntaxprüfung:
- Zielausführungsprofil: QIR Adaptive RI
Die Verwendung von Syntaxprüfungen ist kostenlos.
System Model H1 Emulatoren
Nach der Überprüfung der Syntax ihres Codes mit einer Syntaxprüfung können Benutzer die Vorteile der Systemmodell-H1-Emulatoren von Quantinuum nutzen, Emulationstools, die ein detailliertes physisches Modell und ein realistisches Rauschmodell der tatsächlichen Hardware des Systemmodells H1 enthalten. Die Rauschmodelle werden von einer detaillierten Charakterisierung der Hardware abgeleitet. Der Emulator für das Systemmodell H1 verwendet eine identische API für die Auftragsübermittlung wie die Hardware des Systemmodells H1, um einen nahtlosen Übergang von der Emulation zur Hardware zu ermöglichen. Um die Produktivität zu maximieren und die Entwicklungszeit zu verkürzen, stehen die Systemmodell-H1-Emulatoren auch dann zur Verfügung, wenn die Hardware offline ist.
Weitere Informationen finden Sie auf der Seite Systemmodell H1 unter Systemmodell H1-Emulator – Produktdatenblatt.
- Auftragstyp:
Simulation
- Datenformat:
quantinuum.openqasm.v1
- Ziel-ID:
- H1-1-Emulator:
quantinuum.sim.h1-1e
- H1-1-Emulator:
- Zielausführungsprofil: QIR Adaptive RI
Die Nutzung des Systemmodell h1 Emulators wird kostenlos mit einem Hardwareabonnement angeboten. Ausführliche Informationen finden Sie unter Preisdetails für Azure Quantum.
Quantinuum-Emulator (cloudbasiert)
Der Quantinuum Emulator steht kostenlos auf der Seite Code mit Azure Quantum auf der Azure Quantum-Website zur Verfügung. Dort können Sie Q# Code schreiben und Ihre Jobs an den Quantinuum Emulator senden, ohne ein Azure Konto zu besitzen. Der Quantinuum-Emulator ist ein statevector-basierter Quantenemulator, der ein realistisches physikalisches Rauschmodell und generalisierte Fehlerparameter basierend auf der typischen Leistung eines System Model H1 Quantencomputersverwendet. Die durchgeführte Quantensimulation ist identisch mit dem System Model H1 Emulator , aber die klassische Schaltkreisoptimierungsroutine wird reduziert, um den Durchsatz zu erhöhen. Die Unterstützung für integrierte Hybrid-Computing ist für die Zukunft geplant.
Systemmodell H1
Die System Model H1 Generation von Quantencomputern, Powered by Honeywell, besteht aus einem Quantum Charge-Coupled Device (QCCD) mit einem linearen Abschnitt und umfasst derzeit eine Maschine targets: die H1-1. Benutzer werden ermutigt, die Kompatibilität ihres Codes mit dem H1-1 zu testen, indem sie Aufträge an einen Syntaxprüfer und einen System Modell H1 Emulator senden, bevor sie sie an die target übermitteln.
Die Systemmodell H1-Maschine wird während des gesamten Produktlebenszyklus kontinuierlich aktualisiert. Benutzern wird Zugriff auf die aktuellste, fortschrittlichste und fähigste Hardware gewährt.
Weitere Informationen finden Sie im Produktdatenblatt "Systemmodell H1" auf der Seite "Systemmodell H1 ".
- Auftragstyp:
Quantum Program
- Datenformat:
honeywell.openqasm.v1
,honeywell.qir.v1
- Ziel-ID:
- H1-1:
quantinuum.qpu.h1-1
- H1-1:
- Zielausführungsprofil: QIR Adaptive RI
Systemmodell H2 Emulator
Nach der Überprüfung der Syntax ihres Codes mit der H2-1-Syntaxprüfung können Benutzer den Systemmodell-H2-Emulator von Quantinuum nutzen, ein Emulationstool, das ein detailliertes physisches Modell und realistisches Rauschmodell der tatsächlichen Systemmodell H2-Hardware enthält. Weitere Informationen über das Rauschmodell finden Sie im Produktdatenblatt zum Systemmodell H2 Emulator auf der Seite Systemmodell H2 . Der Systemmodell H2-Emulator verwendet eine identische API für die Auftragsübermittlung als Systemmodell H2-Hardware und ermöglicht einen nahtlosen Übergang von Emulation zu Hardware. Um die Produktivität zu maximieren und die Entwicklungszeit zu verkürzen, ist der H2-Emulator auch verfügbar, wenn die Hardware offline ist.
- Auftragstyp:
Simulation
- Datenformat:
quantinuum.openqasm.v1
- Ziel-ID:
- H2-1 Emulator:
quantinuum.sim.h2-1e
- H2-2-Emulator:
quantinuum.sim.h2-2e
- H2-1 Emulator:
- Zielausführungsprofil: QIR Adaptive RI
Die Nutzung des Systemmodell h2-Emulators wird kostenlos mit einem Hardwareabonnement angeboten. Ausführliche Informationen finden Sie unter Preisdetails für Azure Quantum.
Systemmodell H2
Die Quantinuum System Model H2-Generation der Quantencomputer, unterstützt von Honeywell, umfasst eine Quantum Charge-Coupled Device (QCCD) mit zwei verbundenen linearen Teilen und bietet derzeit einen Rechner, den „H2-1“. Weitere Informationen finden Sie im Produktdatenblatt "SystemModell H2" auf der Seite "Systemmodell H2 ". Benutzer werden ermutigt, die Kompatibilität ihres Codes zu testen, indem Sie Aufträge an eine Syntaxprüfer und einen Systemmodell-H2-Emulator übermitteln, bevor sie an die target Computer übermittelt werden.
Wenn ein Benutzer einen Auftrag an den H2-1-Computer sendet und der H2-1-Computer nicht verfügbar ist, verbleibt der Auftrag in der Warteschlange dieses Computers, bis der Computer verfügbar ist.
Systemmodell H2-Hardware wird während des gesamten Produktlebenszyklus kontinuierlich aktualisiert. Benutzern wird Zugriff auf die aktuellste, fortschrittlichste und fähigste Hardware gewährt.
- Auftragstyp:
Quantum Program
- Datenformat:
quantinuum.openqasm.v1
- Ziel-ID:
- H2-1:
quantinuum.qpu.h2-1
- H2-2:
quantinuum.qpu.h2-2
- H2-1:
- Zielausführungsprofil: QIR Adaptive RI
Technische Spezifikationen des Systemmodells H1 und H2
Technische Details zu Systemmodell H1 und Systemmodell H2 finden Sie in quantinuums Produktdatenblättern auf den Seiten SystemModell H1 und Systemmodell H2 neben Links zur Quantinuum Spezifikation und Quantum Volume Data Repositorys und wie man die Verwendung von Quantinuum-Systemen zitieren kann.
Weitere Funktionen
Weitere Funktionen, die über die Quantinuum-API verfügbar sind, sind hier aufgeführt.
Fähigkeit | Beschreibung |
---|---|
Mid-Circuit Messung und Reset (MCMR) | Messen Sie Qubits in der Mitte einer Schaltung und verwenden Sie sie erneut. |
Beliebige Winkel ZZ Gates | Direkte Durchführung von 2-Qubit-Torrotationen mit beliebigem Winkel |
Allgemeines SU(4)-Verschränkungstor | Direkte Durchführung von 2-Qubit-Torrotationen mit beliebigem Winkel |
Emulator-Rauschparameter | Experimentieren mit den in den Quantinuum-Emulatoren verwendeten Rauschparametern |
TKET-Optimierungen im Quantinuum-Stack | Experimentieren mit der Aktivierung verschiedener Stufen von TKET-Optimierungen im Quantinuum-Stack |
Benutzer können diese zusätzlichen Funktionen über Schaltkreisfunktionen oder Pass-Through-Parameter in den Azure Quantum Q#- und Qiskit-Anbietern nutzen.
Messung und Reset mitten im Stromkreis
Mid-Circuit Measurement and Reset (MCMR) ermöglicht es Benutzern, Qubits in der Mitte eines Schaltkreises zu messen und zurückzusetzen. Dies ermöglicht Funktionen für die Quantenfehlerkorrektur sowie die Möglichkeit, Qubits innerhalb des Schaltkreises wiederzuverwenden.
Aufgrund der internen Ebenenstruktur von gefangenen Ionen-Qubits kann eine Zwischenkreis-Messung den Qubit in einem nicht-rechenbaren Zustand zurücklassen. Auf alle Messungen innerhalb einer Quantenschaltung sollte eine Zurücksetzung folgen, wenn das Qubit erneut in derselben Schaltung verwendet werden soll. Die folgenden Codebeispiele veranschaulichen dies.
Wenn eine Teilmenge von Qubits in der Mitte des Schaltkreises gemessen wird, können die klassischen Informationen aus diesen Messungen verwendet werden, um zukünftige Elemente des Schaltkreises zu bestimmen. In den Beispielen wird auch diese Verwendung hervorgehoben.
Informationen zu MCMR in Quantinuum-Systemen finden Sie in den Produktdatenblättern zu Quantinuum-Systemen auf den Seiten Systemmodell H1 und Systemmodell H2.
In Q# kann die MResetZ
-Funktion verwendet werden, um ein Qubit zu messen und es zurückzusetzen. Weitere Informationen zu dieser Funktion finden Sie MResetZ
in der Q#-Dokumentation.
%%qsharp
import Std.Measurement.*;
operation ContinueComputationAfterReset() : Result[] {
// Set up circuit with 2 qubits
use qubits = Qubit[2];
// Perform Bell Test
H(qubits[0]);
CNOT(qubits[0], qubits[1]);
// Measure Qubit 1 and reset it
let res1 = MResetZ(qubits[1]);
// Continue additional computation, conditioned on qubits[1] measurement outcome
if res1 == One {
X(qubits[0]);
}
CNOT(qubits[0], qubits[1]);
// Measure qubits and return results
let res2 = Measure([PauliZ, PauliZ], qubits);
return [res1, res2];
}
Arbiträre Winkel ZZ Gates
Quantinuums nativer Gattersatz enthält ZZ-Gatter mit beliebigem Winkel. Dies ist vorteilhaft für die Reduzierung der 2-Qubit-Gate-Anzahl für viele Quantenalgorithmen und Gatesequenzen. Informationen über Arbitrary Angle ZZ Gates in Quantinuum Systemen finden Sie in den Produktdatenblättern der Quantinuum-Systeme auf den Seiten Systemmodell H1 und Systemmodell H2.
In Q# wird das Arbitrary Angle ZZ Gate mit der Operation Rzz
implementiert.
%%qsharp
import Std.Intrinsic.*;
import Std.Measurement.*;
import Std.Arrays.*;
operation ArbitraryAngleZZExample(theta : Double) : Result[] {
// Set up circuit with 2 qubits
use qubits = Qubit[2];
// Create array for measurement results
mutable resultArray = [Zero, size = 2];
H(qubits[0]);
Rz(theta, qubits[0]);
Rz(theta, qubits[1]);
X(qubits[1]);
// Add Arbitrary Angle ZZ gate
Rzz(theta, qubits[0], qubits[1]);
// Measure qubits and return results
for i in IndexRange(qubits) {
resultArray w/= i <- M(qubits[i]);
}
return resultArray;
}
Allgemeines SU(4)-Verschränkungstor
Quantinuums nativer Gattersatz enthält ein allgemeines SU(4) Verschränkungsgatter. Beachten Sie, dass Quantenschaltungen, die der Hardware vorgelegt werden, auf das vollständig verschränkende ZZ-Gatter und das RZZ-Gatter mit beliebigem Winkel umbasiert werden. Die Schaltkreise werden nur dann auf das Allgemeine SU(4)-Verschränkungsgatter umbasiert, wenn die Benutzer dies wünschen. Informationen zum Allgemeinen SU(4) Entangler in Quantinuum-Systemen finden Sie in den Produktdatenblättern für Quantinuum-Systeme auf den Seiten Systemmodell H1 und Systemmodell H2.
In Q# wird das Allgemeine SU(4)-Verschränkungsgatter über das QIR-Profil von Quantinuum implementiert. Um sie zu verwenden, definieren Sie eine Funktion mit einer benutzerdefinierten systeminternen Übereinstimmung mit der QIR-Profilsignatur, und verwenden Sie diese Funktion innerhalb des SU4Example
Vorgangs.
Um sicherzustellen, dass der Circuit mit dem General SU(4) Entangling Gate ausgeführt wird, übergeben Sie die folgenden Optionen im Quantinuum-Stack:
-
nativetq: Rxxyyzz
, um ein Umbasieren auf andere native Gates zu verhindern. -
noreduce: True
um zusätzliche Compileroptimierungen (optional) zu vermeiden.
%%qsharp
import Std.Math.*;
operation __quantum__qis__rxxyyzz__body(a1 : Double, a2 : Double, a3 : Double, q1 : Qubit, q2 : Qubit) : Unit {
body intrinsic;
}
operation SU4Example() : Result[] {
use qs = Qubit[2];
// Add SU(4) gate
__quantum__qis__rxxyyzz__body(PI(), PI(), PI(), qs[0], qs[1]);
MResetEachZ(qs)
}
Kompilieren Sie nun den Vorgang:
MyProgram = qsharp.compile("GenerateRandomBit()")
Stellen Sie eine Verbindung mit Azure Quantum her, wählen Sie den target Computer aus, und konfigurieren Sie die Rauschparameter für den Emulator:
MyWorkspace = azure.quantum.Workspace(
resource_id = "",
location = ""
)
MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")
# Update TKET optimization level desired
option_params = {
"nativetq": `Rxxyyzz`,
"noreduce": True
}
Geben Sie die Option noreduce
an, wenn Sie den Auftrag einreichen:
job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()
Emulator-Rauschparameter
Benutzer haben die Möglichkeit, mit den Rauschparametern der Quantinuum-Emulatoren zu experimentieren. Hier werden nur einige der verfügbaren Noise-Parameter hervorgehoben , um zu zeigen, wie Sie die Parameter in den Azure Quantum-Anbietern durchreichen.
Weitere Informationen über den vollständigen Satz der verfügbaren Rauschparameter finden Sie in den Produktdatenblättern des Quantinuum-Emulators auf den Seiten Systemmodell H1 und Systemmodell H2.
Importieren Sie zunächst die erforderlichen Pakete, und initiieren Sie das Basisprofil:
import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)
Definieren Sie als Nächstes die Funktion.
%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;
operation GenerateRandomBit() : Result {
use target = Qubit();
// Apply an H-gate and measure.
H(target);
return M(target);
}
und kompilieren Sie den Vorgang:
MyProgram = qsharp.compile("GenerateRandomBit()")
Stellen Sie eine Verbindung mit Azure Quantum her, wählen Sie den target Computer aus, und konfigurieren Sie die Rauschparameter für den Emulator:
MyWorkspace = azure.quantum.Workspace(
resource_id = "",
location = ""
)
MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")
# Update the parameter names desired
# Note: This is not the full set of options available.
# For the full set, see the System Model H1 Emulator Product Data Sheet
option_params = {
"error-params": {
"p1": 4e-5,
"p2": 3e-3,
"p_meas": [3e-3, 3e-3],
"p_init": 4e-5,
"p_crosstalk_meas": 1e-5,
"p_crosstalk_init": 3e-5,
"p1_emission_ratio": 6e-6,
"p2_emission_ratio": 2e-4
}
}
Geben Sie die Geräuschoptionen des Emulators an, wenn Sie den Auftrag absenden:
job = MyTarget.submit(MyProgram, "Experiment with Emulator Noise Parameters",
shots = 10,
input_params = option_params)
job.get_results()
Um das Emulator-Rauschmodell zu deaktivieren, setzen Sie die Option error-model
auf False
. Sie ist standardmäßig auf True
festgelegt.
option_params = {
"error-model": False
}
Um den Stabilisierungs-Emulator zu verwenden, legen Sie die simulator
Option auf stabilizer
. Sie ist standardmäßig auf state-vector
festgelegt.
option_params = {
"simulator": "stabilizer"
}
TKET-Kompilierung im Quantinuum-Stack
Circuits, die an Quantinuum Quantinuum-Systeme gesendet werden, mit Ausnahme von integrierten hybriden Übermittlungen, werden automatisch durch die TKET-Kompilierungsläufe für Quantinuum-Hardware ausgeführt. Dadurch können Circuits automatisch für Quantinuum-Systeme optimiert und effizienter ausgeführt werden.
Weitere Informationen zu den angewendeten Kompilierungsdurchläufen finden Sie in der pytket-quantinuum
Dokumentation, insbesondere im pytket-quantinuum
Abschnitt "Kompilierungsdurchläufe ".
Im Quantinuum-Softwarestapel wird die angewendete Optimierungsebene mit dem Parameter tket-opt-level
festgelegt.
Der Kompilierungsparameter für alle an Quantinuum-Systeme übermittelten Circuits ist standardmäßig auf Optimierungsstufe 2 festgelegt.
Benutzer, die TKET-Kompilierungsläufe ausprobieren möchten und erfahren wollen, welche Optimierungen auf ihre Schaltkreise angewendet werden, bevor Aufträge übermittelt werden, können sich das Notizbuch Quantinuum_compile_without_api.ipynb im Ordner pytket-quantinuum
Beispiele ansehen.
Um die TKET-Kompilierung im Stack auszuschalten, kann eine andere Option, no-opt
, auf True
innerhalb von option_params
gesetzt werden. Beispiel: "no-opt": True
.
Weitere Informationen über pytket
finden Sie unter den folgenden Links:
Importieren Sie zunächst die erforderlichen Pakete, und initiieren Sie das Basisprofil:
import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)
Definieren Sie als Nächstes die Funktion.
%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;
operation GenerateRandomBit() : Result {
use target = Qubit();
// Apply an H-gate and measure.
H(target);
return M(target);
}
und kompilieren Sie den Vorgang:
MyProgram = qsharp.compile("GenerateRandomBit()")
Stellen Sie eine Verbindung mit Azure Quantum her, wählen Sie den target Computer aus, und konfigurieren Sie die Rauschparameter für den Emulator:
MyWorkspace = azure.quantum.Workspace(
resource_id = "",
location = ""
)
MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")
# Update TKET optimization level desired
option_params = {
"tket-opt-level": 1
}
Geben Sie die Optimierungsoption an, wenn Sie den Auftrag einreichen:
job = MyTarget.submit(MyProgram, "Experiment with TKET Compilation", shots = 10, input_params = option_params)
job.get_results()
Technische Spezifikationen
Technische Details zu den Systemmodellen H1 und H2 sowie den Emulatoren für diese Modelle finden Sie in den Produktdatenblättern von Quantinuum auf der Seite "Systemmodell H1" und "Systemmodell H2" neben Links zur Quantinuum-Spezifikation, zu den Quantenvolumen-Datenrepositories und zur Angabe der Verwendung von Quantinuum-Systemen.
Zielverfügbarkeit
Die Quantinuum-Quantencomputer sind so konzipiert, dass sie ständig weiterentwickelt werden, wodurch Kunden Zugriff auf die neuesten Hardwarefunktionen haben können, indem Quantinuum kontinuierlich die Gate-Fidelitäten, Speicherfehler und Systemgeschwindigkeit verbessert.
Quantinuum-Hardware durchläuft kommerzielle Phasen und Entwicklungsphasen. Während kommerzieller Phasen ist die Hardware für die Verarbeitung von Aufträgen über ein Warteschlangensystem verfügbar. Während der Entwicklungsphasen ist die Hardware offline, da Upgrades angewendet werden.
Jeden Monat wird ein Kalender an Quantinuum-Benutzer gesendet, die Informationen zu den kommerziellen Phasen und Entwicklungsphasen erhalten. Wenn Sie diesen Kalender nicht erhalten haben, senden Sie bitte E-Mail an QCsupport@quantinuum.com.
Ein target-Status gibt seine aktuelle Fähigkeit zur Bearbeitung von Jobs an. Die möglichen Zustände eines target sind:
- Verfügbar: Das target ist online, verarbeitet übermittelte Aufträge und akzeptiert neue.
- Herabgestuft: Das target System akzeptiert Aufträge, verarbeitet sie jedoch derzeit nicht.
- Nicht verfügbar: Dies target ist offline und akzeptiert keine neuen Auftragsübermittlungen.
Für den Quantinuum-Quantencomputer targetsentsprechen "Available" und "Degraded" kommerziellen Zeiträumen, während "Nicht verfügbar" Entwicklungsperioden entspricht, in denen der Computer für Upgrades offline ist.
Aktuelle Statusinformationen können im Azure-Portal auf der Registerkarte Anbieter eines Arbeitsbereichs abgerufen werden.
Preise
Die Abrechnungspläne für Quantinuum finden Sie unter Azure Quantum-Preise.
Grenzen und Kontingente
Die Kontingente von Quantinuum werden auf der Grundlage der Einheit des QPU-Nutzungsguthabens, Hardware Quantum Credit (HQC), für Jobs, die an Quantinuum-Quantencomputer gesendet werden, und Emulator-HQCs (eHQCs) für Jobs, die an Emulatoren gesendet werden, verfolgt.
HQC und eHQC werden verwendet, um die Kosten einer Auftragsausführung zu berechnen. Die Berechnung basiert auf der folgenden Formel:
$$ HQC = 5 + C(N_{1q} + 10 N_{2q} + 5 N_m)/5000 $
Dabei gilt Folgendes:
- $N_{1q}$ ist die Anzahl der Ein-Qubit-Vorgänge in einer Schaltung.
- $N_{2q}$ ist die Anzahl der nativen Zwei-Qubit-Vorgänge in einer Schaltung. Natives Gate entspricht CNOT bis zu mehreren Ein-Qubit-Gates.
- $N_{m}$ ist die Anzahl der Zustandsvorbereitungs- und Messvorgänge (State Preparation and Measurement, SPAM) in einer Schaltung einschließlich der anfänglichen impliziten Zustandsvorbereitung und aller Zwischen- und endgültigen Messungen sowie Zustandszurücksetzungen.
- $C$ ist die Anzahl der Ausführungen.
Hinweis
Die Gesamtkosten in HQCs umfassen alle Gates und Messungen über alle bedingten Verzweigungen oder Kontrollflüsse. Dies kann einen höheren Einfluss auf integrierte Hybridaufträge haben.
Kontingente basieren auf dem ausgewählten Plan und können per Supportticket erhöht werden. Um Ihre aktuellen Grenzwerte und Kontingente anzuzeigen, wechseln Sie zum Abschnitt "Vorgänge ", und wählen Sie das Blatt "Kontingente" Ihres Arbeitsbereichs im Azure-Portal aus. Weitere Informationen finden Sie unter Azure Quantum-Kontingente.