Freigeben über

Quantinuum-Anbieter

  • Artikel

Tipp

Wenn Sie einen Azure Quantum-Arbeitsbereich erstellen, erhalten Sie automatisch USD500 kostenlose Azure Quantum Credits für jeden Quantenhardwareanbieter. Sie können azure Quantum Credits verwenden, um Ihre ersten Quantenprogramme an echte Quantenhardware zu übermitteln.

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.

Targets

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

Target-Name Target 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.
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 Stabalizersimulation 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.

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
  • Target ID:
    • H1-1-Syntaxprüfung: quantinuum.sim.h1-1sc
    • H2-1 Syntaxprüfer: quantinuum.sim.h2-1sc
  • Target Ausfü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
  • Target ID:
    • H1-1-Emulator: quantinuum.sim.h1-1e
  • Target Ausfü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.

H-Series Emulator (cloudbasiert)

Der H-Series-Emulator ist kostenlos auf der Seite "Code mit Azure Quantum " auf der Azure Quantum-Website verfügbar, auf der Sie Q#-Code schreiben und Ihre Aufträge ohne Azure-Konto an den Quantinuum H-Series-Emulator übermitteln können. Der H-Series Emulator ist ein statevectorbasierter Quantenemulator, der ein realistisches physikalisches Rauschmodell und generalisierte Fehlerparameter auf der Grundlage der typischen Leistung eines Systemmodell-H1-Quantencomputers verwendet. 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 Systemmodell-H1-Emulator übermitteln, bevor sie an die target Computer übermittelt werden.

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
  • Target ID:
    • H1-1: quantinuum.qpu.h1-1
  • Target Ausfü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
  • Target ID:
    • H2-1 Emulator: quantinuum.sim.h2-1e
  • Target Ausfü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
  • Target ID:
    • H2-1: quantinuum.qpu.h2-1
  • Target Ausfü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
Emulator-Rauschparameter Experimentieren Sie mit den Rauschparametern, die in den Quantinuum H-Series-Emulatoren verwendet werden.
TKET-Optimierungen im H-Series-Stapel Experimentieren Sie mit dem Aktivieren verschiedener TKET-Optimierungen im H-Series-Stapel

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 auf den Produktdatenblättern der H-Serie 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 zu Beliebigen Winkel-ZZ-Toren in Quantinuum-Systemen finden Sie auf den Produktdatenblättern der H-Serie 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) {
        set 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 zu den Allgemeinen SU(4) Entangler in Quantinuum-Systemen finden Sie in den Produktdatenblättern der H-Serie 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 Schaltkreis mit dem General SU(4) Entangling Gate läuft, übergeben Sie die folgenden Optionen im H-Series-Stapel:

  • 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 zu den vollständigen verfügbaren Rauschparametern finden Sie auf den Produktdatenblättern des Emulators der H-Serie auf den Seiten "System Model 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 H-Series-Stapel

Schaltkreise, die an Quantinuum H-Series-Systeme übermittelt werden, mit Ausnahme integrierter Hybridübermittlungen, werden automatisch über TKET-Kompilierungsdurchläufe für H-Series-Hardware ausgeführt. Dadurch können Schaltkreise automatisch für H-Series-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 Softwarestapel der H-Serie wird die angewendete Optimierungsebene mit dem tket-opt-level Parameter festgelegt. Die Standardkompilierungseinstellung für alle Schaltungen, die an H-Series-Systeme übermittelt werden, ist die Optimierungsebene 2.

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 option_paramsfestgelegt True 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.

Target Verfügbarkeit

Die Quantencomputer der Quantinuum H-Serie sollen kontinuierlich aktualisiert werden. Dadurch haben Kunden Zugriff auf die neuesten Hardwarefunktionen, da Quantinuum kontinuierlich die Gatterfidelität und Systemgeschwindigkeit verbessert sowie Speicherfehler behebt.

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

Quantinuums Quoten werden basierend auf der QPU-Nutzungskrediteinheit H-System Quantum Credit (HQC) für Aufträge nachverfolgt, die an Quantinuum-Quantencomputer übermittelt werden, und Emulator-HQCs (eHQCs) für Aufträge, die an Emulatoren übermittelt werden.

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.