Dela via

Quantinuum-provider

  • Artikel

Dricks

Förstagångsanvändare får automatiskt 500 USD kostnadsfria Azure Quantum-krediter för användning med varje deltagande kvantmaskinvaruleverantör.

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.

Targets

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

Target Namn Target ID Antal kvantbitar beskrivning
Syntaxkontroll för H1-1 quantinuum.sim.h1-1sc 20 kvantbitar Använd detta för att validera kvantprogram mot H1-1-kompilatorn innan du skickar till maskinvara eller emulatorer på Quantinuums plattform. Kostnadsfritt.
Syntaxkontroll för H2-1 quantinuum.sim.h2-1sc 56 qubits Använd detta för att validera kvantprogram mot H2-1-kompilatorn innan du skickar till maskinvara eller emulatorer på Quantinuums plattform. Kostnadsfritt.
H1-1-emulator quantinuum.sim.h1-1e 20 kvantbitar Använder en realistisk fysisk modell och brusmodell av H1-1.
H2-1-emulator quantinuum.sim.h2-1e 56/32 kvantbitar Använder en realistisk fysisk modell och brusmodell av H2-1. 56 qubit-simulering är endast tillgängligt som en stabalizer-simulering
H1-1 quantinuum.qpu.h1-1 20 kvantbitar Quantinuums H1-1 fångade jonenhet.
H2-1 quantinuum.qpu.h2-1 56 qubits Quantinuums H2-1 fångade jonenhet.

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.

Dricks

Kvantjobb som skickas under en session har exklusiv åtkomst till Quantinuum-maskinvara så länge du köar jobb inom en minut från varandra. Därefter godkänns och hanteras alla jobb med standardlogik för kö och prioritering. Mer information finns i sessioner i Azure Quantum.

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.

Kapacitet beskrivning
Mått och återställning av mellankretsar (MCMR) Mät kvantbitar mitt i en krets och återanvänd dem
Godtycklig vinkel ZZ-grindar Utför direkt 2-qubit godtyckliga vinkelgrindsrotationer
Emulatorbrusparametrar Experimentera med brusparametrarna som används i Quantinuum H-seriens emulatorer
TKET-optimeringar i H-Series Stack Experimentera med att aktivera olika nivåer av TKET-optimeringar i H-seriens stack

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 .

I Q# MResetZ kan funktionen användas både för att mäta en qubit och återställa den. Mer information om den här funktionen MResetZ finns i Q#-dokumentationen.

%%qsharp
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.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];
}

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 .

I Q#implementeras den godtyckliga vinkeln ZZ-grinden med åtgärden Rzz .

%%qsharp
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.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;
}

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 .

I Q#implementeras general SU(4) Entangling-grinden via Quantinuums QIR-profil. Om du vill använda den definierar du en funktion med en anpassad inbyggd som matchar QIR-profilsignaturen och använder den här funktionen inom åtgärden SU4Example .

För att säkerställa att kretsen körs med General SU(4) Entangling-grinden skickar du följande alternativ i H-seriens stack:

  • nativetq: Rxxyyzz för att förhindra ombasering till andra inbyggda portar.
  • noreduce: True för att undvika ytterligare kompilatoroptimeringar (valfritt).
%%qsharp
open Microsoft.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)
}

Kompilera nu åtgärden:

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

Anslut till Azure Quantum, välj target datorn och konfigurera brusparametrarna för emulatorn:

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
}

Skicka in noreduce alternativet när jobbet skickas:

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 .

Importera först de nödvändiga paketen och starta basprofilen:

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

Definiera sedan funktionen.

%%qsharp
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Arrays;
open Microsoft.Quantum.Convert;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

och kompilera åtgärden:

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

Anslut till Azure Quantum, välj target datorn och konfigurera brusparametrarna för emulatorn:

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

Skicka in emulatorns brusalternativ när du skickar jobbet:

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

Om du vill inaktivera emulatorns brusmodell anger du error-model alternativet till False. Som standard är detta inställt på True.

option_params = {
    "error-model": False 
}

Om du vill använda stabilisatoremulatorn anger du simulator alternativet till stabilizer. Som standard är detta inställt på state-vector.

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:

Importera först de nödvändiga paketen och starta basprofilen:

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

Definiera sedan funktionen.

%%qsharp
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Arrays;
open Microsoft.Quantum.Convert;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

och kompilera åtgärden:

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

Anslut till Azure Quantum, välj target datorn och konfigurera brusparametrarna för emulatorn:

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
}

Skicka in optimeringsalternativet när du skickar jobbet:

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

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.

Kommentar

Den totala kostnaden i HQC:er omfattar alla portar och mätningar över alla villkorsstyrda grenar eller kontrollflöden. Detta kan ha en högre inverkan på integrerade hybridjobb.

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.

Kommentar

Om du använder en Azure Quantum Credits-plan och inte en faktureringsplan mappar kvotinformationen till dina allokerade krediter. I så fall visar kvoten det totala antalet krediter som du har fått.