Quantinuum-provider

Quantinuum ger åtkomst till system med fångade joner med hög återgivning, fullständigt anslutna kvantbitar och möjlighet att utföra mätning mellan kretsar.

• Utgivare: Quantinuum
• Provider-ID: quantinuum

Targets

Följande targets är tillgängliga från den här providern:

Quantinuum motsvarar targets en QIR Adaptive RI profil. Mer information om den här target profilen och dess begränsningar finns i Förstå target profiltyper i Azure Quantum.

Alla Quantinuum har targets nu stöd för integrerade hybridkretsar. Mer information om hur du skickar in integrerade hybridjobb finns i Integrerad hybridberäkning.

Information om hur du kommer igång med Quantinuum-providern i Azure Quantum finns i Kom igång med Q# och en Azure Quantum-notebook-fil.

Syntaxkontroll

Vi rekommenderar att användarna först verifierar sin kod med hjälp av en syntaxkontroll. Det här är ett verktyg för att verifiera korrekt syntax, slutförande av kompilering och maskinkompatibilitet. Syntaxkontroll använder samma kompilator som kvantdatorn som de target. Syntaxkontrollen H1-1 använder till exempel samma kompilator som H1-1. Den fullständiga kompileringsstacken körs med undantag för de faktiska kvantåtgärderna. Om koden kompileras returnerar syntaxkontrollen en success status och ett resultat av alla 0:er. Om koden inte kompileras returnerar syntaxkontrollen en misslyckad status och ger felet returnerat för att hjälpa användarna att felsöka sin kretssyntax. Med syntaxkontroll kan utvecklare verifiera sin kod när som helst, även när datorer är offline.

• Jobbtyp: Simulation
• Dataformat: honeywell.openqasm.v1, honeywell.qir.v1
• Target ID:
  • Syntaxkontroll för H1-1: quantinuum.sim.h1-1sc
  • Syntaxkontroll för H2-1: quantinuum.sim.h2-1sc
• Target Körningsprofil: QIR Adaptive RI

Användning av syntaxkontroll erbjuds kostnadsfritt.

System Model H1-emulatorer

När de har verifierat syntaxen för sin kod med en syntaxkontroll kan användarna dra nytta av Quantinuums System Model H1-emulatorer, emuleringsverktyg som innehåller en detaljerad fysisk modell och realistisk brusmodell för den faktiska systemmodell H1-maskinvaran. Brusmodellerna härleds från en detaljerad beskrivning av maskinvaran. System Model H1-emulatorerna använder ett identiskt API för jobböverföring som systemmodell H1-maskinvara, vilket möjliggör sömlös övergång från emulering till maskinvara. För att maximera produktiviteten och förkorta utvecklingstiden är System Model H1-emulatorerna tillgängliga även när maskinvaran är offline.

Mer information finns i systemmodell H1-emulatorns produktdatablad på sidan SystemModell H1 .

• Jobbtyp: Simulation
• Dataformat: quantinuum.openqasm.v1
• Target ID:
  • H1-1-emulator: quantinuum.sim.h1-1e
• Target Körningsprofil: QIR Adaptive RI

System Model H1-emulatoranvändning erbjuds kostnadsfritt med en maskinvaruprenumeration. Mer information finns i Priser för Azure Quantum.

H-seriens emulator (molnbaserad)

H-seriens emulator är tillgänglig kostnadsfritt på sidan Kod med Azure Quantum på Azure Quantum-webbplatsen, där du kan skriva Q#-kod och skicka dina jobb till Quantinuum H-seriens emulator utan ett Azure-konto. H-seriens emulator är en statevector-baserad kvantemulator som använder en realistisk fysisk brusmodell och generaliserade felparametrar baserat på den typiska prestandan för en systemmodell H1-kvantdator. Den kvantsimulering som utförs är densamma som System Model H1-emulatorn , men den klassiska kretsoptimeringsrutinen reduceras för att öka dataflödet. Stöd för integrerad hybridberäkning planeras för ett framtida datum.

Systemmodell H1

System Model H1-generationen av kvantdatorer, Powered by Honeywell, består av en kvantladdningskoppling (QCCD) med ett linjärt avsnitt och innehåller för närvarande en dator targets: H1-1. Användarna uppmanas att testa kodens kompatibilitet med H1-1 genom att skicka jobb till en syntaxkontroll och System Model H1-emulatorn innan de skickas till datorerna target .

System Model H1-datorn uppgraderas kontinuerligt under produktens livscykel. Användarna får åtkomst till den senaste, avancerade och kompatibla maskinvaran.

Mer information finns i produktdatabladet systemmodell H1 på sidan System Model H1 .

• Jobbtyp: Quantum Program
• Dataformat: honeywell.openqasm.v1, honeywell.qir.v1
• Target ID:
  • H1-1: quantinuum.qpu.h1-1
• Target Körningsprofil: QIR Adaptive RI

Systemmodell H2-emulator

När du har verifierat syntaxen för koden med syntaxkontrollen H2-1 kan användarna dra nytta av Quantinuums System Model H2-emulator, ett emuleringsverktyg som innehåller en detaljerad fysisk modell och en realistisk brusmodell för den faktiska systemmodell H2-maskinvaran. Mer information om brusmodellen finns i systemmodell H2-emulatorns produktdatablad på sidan System Model H2 . System Model H2-emulatorn använder ett identiskt API för jobböverföring som systemmodell H2-maskinvara, vilket möjliggör sömlös övergång från emulering till maskinvara. För att maximera produktiviteten och förkorta utvecklingstiden är H2-emulatorn tillgänglig även när maskinvaran är offline.

• Jobbtyp: Simulation
• Dataformat: quantinuum.openqasm.v1
• Target ID:
  • H2-1-emulator: quantinuum.sim.h2-1e
• Target Körningsprofil: QIR Adaptive RI

System Model H2-emulatoranvändning erbjuds kostnadsfritt med en maskinvaruprenumeration. Mer information finns i Priser för Azure Quantum.

Systemmodell H2

Quantinuum System Model H2-generationen av kvantdatorer, Powered by Honeywell, består av en kvantladdningskopplad enhet (QCCD) med två anslutna linjära sektioner och har för närvarande 1 dator, H2-1. Mer information finns i produktdatabladet för System Model H2 på sidan System Model H2 . Användarna uppmanas att testa kodens kompatibilitet genom att skicka jobb till en syntaxkontroll och System Model H2-emulatorn innan de skickas till datorerna target .

Om en användare skickar ett jobb till H2-1-datorn och H2-1-datorn inte är tillgänglig förblir jobbet kvar i den datorns kö tills datorn blir tillgänglig.

System Model H2-maskinvaran uppgraderas kontinuerligt under produktens livscykel. Användarna får åtkomst till den senaste, avancerade och kompatibla maskinvaran.

• Jobbtyp: Quantum Program
• Dataformat: quantinuum.openqasm.v1
• Target ID:
  • H2-1: quantinuum.qpu.h2-1
• Target Körningsprofil: QIR Adaptive RI

Tekniska specifikationer för systemmodell H1 och H2

Teknisk information för System Model H1 och System Model H2 finns i Quantinuums produktdatablad på sidorna System Model H1 och System Model H2 tillsammans med länkar till Quantinuum-specifikations- och kvantvolymdatalagringsplatser och hur du citerar användning av Quantinuum-system.

Ytterligare funktioner

Ytterligare funktioner som är tillgängliga via Quantinuum-API:et visas här.

Användarna kan dra nytta av dessa ytterligare funktioner via kretsfunktioner eller genomströmningsparametrar i Azure Quantum Q# och Qiskit-leverantörerna.

Mått och återställning i mitten av kretsen

McMR (Mid Circuit Measurement and Reset) gör det möjligt för användare att mäta kvantbitar mitt i en krets och återställa dem. Detta möjliggör funktioner för kvantfelkorrigering samt möjlighet att återanvända kvantbitar i kretsen.

På grund av den interna nivåstrukturen för kvantbitar med fångade joner kan en mätning i mitten av kretsen lämna kvantbiten i ett icke-beräkningstillstånd. Alla mätningar i mitten av kretsen bör följas av en återställning om kvantbiten ska användas igen i den kretsen. Följande kodexempel visar detta.

När en delmängd kvantbitar mäts i mitten av kretsen kan den klassiska informationen från dessa mätningar användas för att villkora framtida element i kretsen. Exemplen belyser även den här användningen.

Information om MCMR i Quantinuum-system finns i produktdatabladen i H-serien på sidorna System Model H1 och System Model H2 .

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

Godtycklig vinkel ZZ-grindar

Quantinuums inbyggda grinduppsättning innehåller godtyckliga vinkel-ZZ-grindar. Detta är fördelaktigt för att minska antalet 2 kvantbitar för många kvantalgoritmer och grindsekvenser. Information om godtyckliga vinkel-ZZ-portar i Quantinuum-system finns i produktdatabladen i H-serien på sidorna System Model H1 och System Model H2 .

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

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()

Allmän SU(4) Entangling Gate

Quantinuums inbyggda grinduppsättning innehåller en allmän SU(4) insnärjande grind. Observera att kvantkretsar som skickas till maskinvaran är ombaserade till den helt sammanflätade ZZ-grinden och den godtyckliga RZZ-vinkelporten. Kretsar bygger bara om till General SU(4) Entangling Gate om användarna väljer det. Information om General SU(4) Entangler i Quantinuum-system finns i produktdatabladen i H-serien på sidorna System Model H1 och System Model H2 .

%%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.h1-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()

Emulatorbrusparametrar

Användare kan experimentera med brusparametrarna för Quantinuum-emulatorerna. Endast ett fåtal av de tillgängliga brusparametrarna är markerade här som visar hur du passerar parametrarna i Azure Quantum-leverantörerna.

Mer information om alla tillgängliga brusparametrar finns i produktdatabladen för H-seriens emulator på sidorna System Model H1 och System Model H2 .

import qsharp
import azure.quantum
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 = 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
    }
}

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.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
    }
}
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-kompilering i H-Series Stack

Kretsar som skickas till Quantinuum H-seriens system, förutom integrerade hybridöverföringar, körs automatiskt via TKET-kompileringspass för H-seriens maskinvara. Detta gör att kretsar automatiskt kan optimeras för H-seriens system och köras mer effektivt.

Mer information om de specifika kompileringspass som tillämpas finns i dokumentationen pytket-quantinuum , särskilt pytket-quantinuum avsnittet Kompileringspass .

I H-seriens programvarustack anges den tillämpade optimeringsnivån med parametern tket-opt-level . Standardinställningen för kompilering för alla kretsar som skickas till H-seriens system är optimeringsnivå 2.

Användare som vill experimentera med TKET-kompileringen skickar och se vilka optimeringar som skulle gälla för deras kretsar innan de skickar några jobb kan se notebook-filen Quantinuum_compile_without_api.ipynb i pytket-quantinuum mappen Exempel .

Om du vill inaktivera TKET-kompilering i stacken kan ett annat alternativ, no-opt, anges till True inuti option_params. Exempel: "no-opt": True

Mer information om pytketfinns i följande länkar:

• pytket
• pytket Användarhandbok

import qsharp
import azure.quantum
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 = 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
}

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.h1-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())

Tekniska specifikationer

Teknisk information för System Model H1- och H2- och System Model H1- och H2-emulatorerna finns i Quantinuums produktdatablad på sidan System Model H1 och System Model H2 tillsammans med länkar till Quantinuum-specifikations- och kvantvolymdatalagringsplatser och hur du citerar användning av Quantinuum-system.

Target Tillgänglighet

Kvantdatorerna i Quantinuum H-serien är utformade för kontinuerlig uppgradering, vilket gör det möjligt för kunder att få tillgång till de senaste maskinvarufunktionerna eftersom Quantinuum kontinuerligt förbättrar grindsymetri, minnesfel och systemhastighet.

Quantinuum-maskinvaran växlar genom kommersiella perioder och utvecklingsperioder. Under kommersiella perioder är maskinvaran tillgänglig för att bearbeta jobb via ett kösystem. Under utvecklingsperioder är maskinvaran offline när uppgraderingar tillämpas.

Varje månad skickas en kalender till Quantinuum-användare med information om kommersiella perioder och utvecklingsperioder. Om du inte har fått den här kalendern skickar du ett e-postmeddelande till QCsupport@quantinuum.com.

Statusen target's anger dess aktuella förmåga att bearbeta jobb. De möjliga tillstånden för ett target inkluderar:

• Tillgänglig: target är online, bearbetar skickade jobb och tar emot nya.
• Degraderad: target Accepterar jobb, men bearbetar dem inte för närvarande.
• Ej tillgänglig: är target offline och accepterar inte nya jobböverföringar.

För kvantdatorn targetsQuantinuum motsvarar Tillgänglig och Degraderad kommersiella perioder, medan Ej tillgänglig motsvarar utvecklingsperioder där datorn är offline för uppgraderingar.

Aktuell statusinformation kan hämtas från fliken Providers på en arbetsyta på Azure Portal.

Prissättning

Om du vill se Quantinuums faktureringsplaner går du till Priser för Azure Quantum.

Begränsningar och kvoter

Quantinuums kvoter spåras baserat på QPU-användningskreditenheten H-System Quantum Credit (HQC), för jobb som skickas till Kvantum-kvantdatorer och emulator-HQCs (eHQCs) för jobb som skickas till emulatorer.

HQCs och eHQCs används för att beräkna kostnaden för att köra ett jobb, och de beräknas baserat på följande formel:

$$ HQC = 5 + C(N_{1q} + 10 N_{2q} + 5 N_m)/5000 $$

där:

• $N_{1q}$ är antalet en qubit-åtgärder i en krets.
• $N_{2q}$ är antalet interna två qubit-åtgärder i en krets. Den inbyggda grinden motsvarar CNOT upp till flera portar med en qubit.
• $N_{m}$ är antalet åtgärder för förberedelse och mätning av tillstånd (SPAM) i en krets, inklusive inledande implicit tillståndsförberedelse och eventuella mellanliggande och slutliga mätningar och tillståndsåterställningar.
• $C$ är antalet skott.

Kvoter baseras på val av plan och kan ökas med en supportbegäran. Om du vill se dina aktuella gränser och kvoter går du till bladet Krediter och kvoter och väljer fliken Kvoter på arbetsytan på Azure Portal. Mer information finns i Azure Quantum-kvoter.