Freigeben über

Quantinuum-Anbieter

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.

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
  • 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
  • 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
  • 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
  • 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
  • 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_paramsgesetzt 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.