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.

• Herausgeber: Quantinuum
• Anbieter-ID: quantinuum

Targets

Die folgenden targets sind bei diesem Anbieter verfügbar:

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.

Syntaxprüfer

Es wird empfohlen, dass Benutzer zuerst eine Syntaxprüfung verwenden, um ihren Code zu überprüfen. Syntaxüberprüfungen überprüfen die ordnungsgemäße Syntax, den Kompilierungsabschluss und die Computerkompatibilität. Syntaxprüfer verwenden denselben Compiler wie der Quantencomputer, den sie verwenden target. Beispielsweise verwendet die H2-1-Syntaxprüfung denselben Compiler wie H2-1. Der vollständige 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 eine Fehlermeldung an, mit der Benutzer ihre Schaltkreissyntax debuggen können. 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:
  • 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.

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 statevectorbasierter Quantenemulator, der ein realistisches physikalisches Rauschmodell und generalisierte Fehlerparameter verwendet, die auf der typischen Leistung eines SystemModell H2-Quantencomputers basieren. Die durchgeführte Quantensimulation ist identisch mit dem System Model H2 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 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 H2

Technische Details zu Systemmodell H2 finden Sie in den Produktdatenblättern von Quantinuum auf der Seite System Modell H2 neben Links zur Quantinuum-Spezifikation und den Quantenvolumen-Datenrepositories sowie Anleitungen zur Zitierung und Nutzung von Quantinuum-Systemen.

Zusätzliche Funktionen

Weitere Funktionen, die über die Quantinuum-API verfügbar sind, sind hier aufgeführt.

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 auf der MCMR-Seite auf Quantinuum Docs.

%%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];
}

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

# Set up quantum circuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.name = "MCMR Example with Conditional Logic"

# Perform Bell Test
circuit.h(q[0])
circuit.cx(q[0], q[1])

# Measure and reset Qubit 1
circuit.measure(q[1], c[1])
circuit.reset(q[1])

# Continue additional computation, conditioned on Qubit 1's measurement outcome
circuit.x(q[0]).c_if(c, 1)
circuit.cx(q[0], q[1])

# Measure all qubits
circuit.measure(q, c)

# Print out the circuit
circuit.draw()

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. Für Informationen zu beliebigen Winkel-ZZ-Toren in Quantinuum-Systemen: Seite zu parametrisierten Angle ZZ Gates auf Quantinuum Docs.

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

from qiskit import QuantumCircuit

theta = 0.25

# Set up quantum circuit
circuit = QuantumCircuit(2, 2)
circuit.name = "Arbitrary Angle ZZ Gate Example"

circuit.h(0)
circuit.rz(theta, 0)
circuit.rz(theta, 1)
circuit.x(1)

# Add arbitrary angle ZZ gate
circuit.rzz(theta, 0, 1)

circuit.measure_all()

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 General SU(4) Entangler in Quantinuum-Systemen finden Sie auf der Seite "Parametrisierte Angle SU(4) Gates" auf Quantinuum Docs.

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

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "nativetq": `Rxxyyzz`,
    "noreduce": True
}

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 zu den verfügbaren Rauschparametern finden Sie auf der Seite „Quantinuum Emulators“ in der Quantinuum-Dokumentation.

from qdk import qsharp
from qdk.azure import Workspace

qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%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);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulators page
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
    }
}

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

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

# Specify the emulator backend target to submit to
backend = provider.get_backend("quantinuum.sim.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulator page
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
    }
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

option_params = {
    "error-model": False 
}

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 den TKET-Kompilierungsschritten experimentieren und sehen möchten, 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 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:

• pytket
• pytket Benutzerhandbuch

from qdk import qsharp
from qdk.azure import Workspace
qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%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);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}

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

# Specify the backend target to submit to
backend = provider.get_backend("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

Technische Daten

Technische Details zu den System Modell H2- und System Modell H2-Emulatoren finden Sie auf der Seite "Hardware User Guide" neben Quantinuum Spezifikation und Quantenvolumen-Datenrepositorien und "Wie man Quantinuum Systeme zitiert".

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 nimmt Aufträge an, verarbeitet sie jedoch momentan 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 auf der Registerkarte "Anbieter " eines Arbeitsbereichs im Azure-Portal abgerufen werden.

Pricing

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 $

where:

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

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.