Freigeben über

Quantinuum-Anbieter

  • Artikel

Wichtig

Sie können Azure Quantum Credits nach dem 1. Juni 2025 nicht mehr verwenden. Wenn Sie über einen Restsaldo von Azure Quantum Credits verfügen, müssen Sie diese vor diesem Datum einlösen.

Quantinuum bietet Zugriff auf ein System mit abgefangenen Atomen mit hoher Genauigkeit, vollständig verbundenen Qubits und der Möglichkeit zur Durchführung von Messungen im Mittleren Schaltkreis.

Ziele

Die folgenden targets Optionen stehen von diesem Anbieter zur Verfügung:

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 physikalisches Modell und 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 Quantinuums H2-1 gefangenes Ionengerät.
H2-2 quantinuum.qpu.h2-1 56 Qubits H2-2-Gerät mit Ionenfalle von Quantinuum.

Quantinuum entspricht targets 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 Quantinuum unterstützen targets 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

Quantenaufträge, die unter einer Sitzung übermittelt werden, haben exklusiven Zugriff auf Quantinuum-Hardware, solange Sie Aufträge innerhalb einer Minute voneinander 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. Die Systemmodell-H1-Emulatoren verwenden eine identische API für die Auftragsübermittlung als Systemmodell H1-Hardware und ermöglichen einen nahtlosen Übergang von Emulation zu Hardware. 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 "System Model H1 Emulator Product Sheet " auf der Seite "SystemModell H1 ".

  • 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 einen zukünftigen Termin geplant.

Systemmodell H1

Die System Model H1 Generation von Quantencomputern, powered by Honeywell, besteht aus einem Quantum Charge-gekoppelten Gerät (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 eine Syntaxprüfer und einen

Die Systemmodell H1-Maschine wird während des gesamten Produktlebenszyklus kontinuierlich aktualisiert. Benutzern wird Zugriff auf die aktuellste, fortgeschrittene und fähige Hardware verfügbare 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 zum Rauschmodell finden Sie auf der Seite "System Model H2 Emulator Product Sheet". 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 von Quantencomputern, powered by Honeywell, besteht aus einem Quantum Charge-gekoppelten Gerät (QCCD) mit zwei verbundenen linearen Abschnitten und verfügt derzeit über 1 Maschine, die 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, fortgeschrittene und fähige Hardware verfügbare 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.

Funktion Beschreibung
Mid-Circuit Measurement and Reset (MCMR) Messen Von Qubits in der Mitte einer Schaltung und wiederverwenden
Beliebige Winkel-ZZ-Tore Direktes Ausführen von 2-Qubit-Drehungen beliebiger Winkeltordrehungen
Allgemeines SU(4)-Verschränkungstor Direktes Ausführen von 2-Qubit-Drehungen beliebiger Winkeltordrehungen
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.

Mid-Circuit-Messung und Zurücksetzen

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 trapped-ion qubits kann eine Mid-Circuit-Messung den Qubit in einem nicht rechenfreien Zustand verlassen. Auf alle Mid-Circuit-Messungen sollte eine Zurücksetzung folgen, wenn das Qubit wieder in diesem Schaltkreis 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 F# kann die MResetZ Funktion verwendet werden, um ein Qubit zu messen und 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];
}

Beliebige Winkel-ZZ-Tore

Quantinuums nativer Torsatz enthält beliebige Winkel-ZZ-Tore. 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 beliebige Winkel-ZZ-Gate mit dem Rzz Betrieb 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;
}

General SU(4) Entangling Gate

Quantinuums nativer Gate-Set enthält ein allgemeines SU(4) Verangling gate. Beachten Sie, dass an die Hardware übermittelte Quantenschaltungen auf das vollständig verschränkende ZZ-Tor und das beliebige Winkel-RZZ-Gate basieren. Schaltkreise werden nur dann auf das Entangling-Gate general SU(4) zurückgegliedert, wenn benutzer sich dafür entscheiden. 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 Entangling-Gate general SU(4) ü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 zu verhindern, dass sie auf andere einheimische Tore zurückbasiert werden.
  • 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
}

Übergeben Sie die noreduce Option beim Übermitteln des Auftrags:

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 Rauschparameter hervorgehoben , die zeigen, wie die Parameter in den Azure Quantum-Anbietern übergeben werden.

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
    }
}

Übergeben Sie die Rauschoptionen des Emulators, wenn Sie den Auftrag übermitteln:

job = MyTarget.submit(MyProgram, "Experiment with Emulator Noise Parameters", 
                      shots = 10, 
                      input_params = option_params)
job.get_results()

Um das Rauschmodell des Emulators zu deaktivieren, legen Sie die error-model Option 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 mit der TKET-Kompilierung experimentieren möchten, übergeben und sehen, welche Optimierungen auf ihre Schaltkreise angewendet werden, bevor sie Aufträge übermitteln, können das Notizbuch Quantinuum_compile_without_api.ipynb im pytket-quantinuum Ordner "Beispiele " anzeigen.

Um die TKET-Kompilierung im Stapel zu deaktivieren, no-optkann eine andere Option auf innen Truefestgelegt option_params werden. Beispiel: "no-opt": True.

Weitere Informationen pytketfinden 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
}

Übergeben Sie die Optimierungsoption beim Übermitteln des Auftrags:

job = MyTarget.submit(MyProgram, "Experiment with TKET Compilation", shots = 10, input_params = option_params)
job.get_results()

Technische Spezifikationen

Technische Details zu den Systemmodell H1- und H2- und Systemmodell H1- und H2-Emulatoren finden Sie auf den Produktdatenblättern von Quantinuum auf der Seite "SystemModell H1 " und "Systemmodell H2 " neben Links zur Quantinuum-Spezifikation und quantenvolum-Datenrepositorys und zur 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 targetStatus gibt seine aktuelle Fähigkeit zum Verarbeiten von Aufträgen an. Zu den möglichen Zuständen gehören target :

  • Verfügbar: Das target ist online, verarbeitet übermittelte Aufträge und akzeptiert neue.
  • Herabgestuft: Der target Vorgang akzeptiert Aufträge, verarbeitet sie derzeit jedoch 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 Tore und Messungen in allen bedingten Verzweigungen oder Kontrollflüssen. 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. Navigieren Sie zum Anzeigen Ihrer aktuellen Grenzwerte und Kontingente zum Blatt Gutschriften und Kontingente, und wählen Sie die Registerkarte Kontingente Ihres Arbeitsbereichs im Azure-Portal aus. Weitere Informationen finden Sie unter Azure Quantum-Kontingente.

Hinweis

Wenn Sie einen Azure Quantum-Guthabenplan und keinen Abrechnungsplan verwenden, werden die Kontingentinformationen Ihrem zugeteilten Guthaben zugeordnet. In diesem Fall wird für das Kontingent das Guthaben aufgeführt, das Sie insgesamt erhalten haben.