Quantinuum-provider

Artikel
05/25/2024

Tip

Voor het eerst ontvangen gebruikers automatisch USD500 gratis Azure Quantum-tegoed voor gebruik bij elke deelnemende kwantumhardwareprovider.

Quantinuum biedt toegang tot ingesloten ionsystemen met hoogwaardige, volledig verbonden qubits en de mogelijkheid om mid-circuitmetingen uit te voeren.

Uitgever: Quantinuum
Provider-id: quantinuum

Doelen

De volgende targets zijn beschikbaar via deze provider:

Doelnaam	Doel-id	Aantal qubits	Beschrijving
H1-1 Syntaxiscontrole	quantinuum.sim.h1-1sc	20 qubits	Gebruik dit om kwantumprogramma's te valideren op basis van de H1-1-compiler voordat u verzendt naar hardware of emulators op het platform van Quantinuum. Gratis.
H2-1 Syntaxiscontrole	quantinuum.sim.h2-1sc	56 qubits	Gebruik dit om kwantumprogramma's te valideren op basis van de H2-1-compiler voordat u naar hardware of emulators verzendt op het platform van Quantinuum. Gratis.
H1-1 Emulator	quantinuum.sim.h1-1e	20 qubits	Maakt gebruik van een realistisch fysiek model en ruismodel van H1-1.
H2-1 Emulator	quantinuum.sim.h2-1e	56/32 qubits	Maakt gebruik van een realistisch fysiek model en ruismodel van H2-1. 56 qubitsimulatie is alleen beschikbaar als stabalizersimulatie
H1-1	quantinuum.qpu.h1-1	20 qubits	Quantinuum's H1-1 gevangen ion apparaat.
H2-1	quantinuum.qpu.h2-1	56 qubits	Quantinuum's H2-1 gevangen ion apparaat.

Quantinuum targets komt overeen met een QIR Adaptive RI profiel. Zie Profieltypen in Azure Quantum voor target meer informatie over dit target profiel en de beperkingen ervan.

Alle quantinuum's targets ondersteunen nu geïntegreerde hybride circuits. Zie Geïntegreerde hybride computing voor meer informatie over het indienen van geïntegreerde hybride taken.

Zie Aan de slag met Q# en een Azure Quantum-notebook om aan de slag te gaan met de Quantinuum-provider in Azure Quantum.

Tip

Kwantumtaken die onder een sessie worden ingediend, hebben exclusieve toegang tot Quantinuum-hardware, zolang u taken binnen één minuut van elkaar in de wachtrij zet. Daarna wordt elke taak geaccepteerd en verwerkt met de standaardlogica voor wachtrijen en prioriteitstelling. Zie sessies in Azure Quantum voor meer informatie.

Syntaxiscontrole

We raden gebruikers aan eerst hun code te valideren met behulp van een syntaxiscontrole. Dit is een hulpprogramma om de juiste syntaxis, compilatievoltooiing en machinecompatibiliteit te controleren. Syntaxiscontrole gebruikt dezelfde compiler als de kwantumcomputer die ze targetgebruiken. De H1-1-syntaxiscontrole gebruikt bijvoorbeeld dezelfde compiler als H1-1. De volledige compilatiestack wordt uitgevoerd met uitzondering van de werkelijke kwantumbewerkingen. Als de code wordt gecompileerd, retourneert de syntaxiscontrole een success status en een resultaat van alle 0's. Als de code niet wordt gecompileerd, retourneert de syntaxiscontrole een mislukte status en geeft de geretourneerde fout aan om gebruikers te helpen fouten in hun circuitsyntaxis op te sporen. Met syntaxiscontrole kunnen ontwikkelaars hun code op elk gewenst moment valideren, zelfs wanneer machines offline zijn.

Taaktype: Simulation
Gegevensindelingen: honeywell.openqasm.v1, honeywell.qir.v1
Doel-id:
- H1-1 Syntaxiscontrole: quantinuum.sim.h1-1sc
- H2-1 Syntaxiscontrole: quantinuum.sim.h2-1sc
Doeluitvoeringsprofiel: QIR Adaptive RI

Het gebruik van syntaxiscontroleers wordt gratis aangeboden.

Systeemmodel H1 Emulators

Na het valideren van de syntaxis van hun code met een syntaxiscontrole, kunnen gebruikers profiteren van de System Model H1 Emulators van Quantinuum, emulatiehulpprogramma's die een gedetailleerd fysiek model en een realistisch ruismodel van de daadwerkelijke System Model H1-hardware bevatten. De ruismodellen zijn afgeleid van een gedetailleerde karakterisering van de hardware. De System Model H1 Emulators gebruiken een identieke API voor taakverzending als de System Model H1-hardware, waardoor naadloze overgang van emulatie naar hardware mogelijk is. Om de productiviteit te maximaliseren en de ontwikkeltijd te verkorten, zijn de System Model H1 Emulators beschikbaar, zelfs als de hardware offline is.

Meer informatie vindt u in het productgegevensblad System Model H1 Emulator op de pagina System Model H1 .

Taaktype: Simulation
Gegevensindeling: quantinuum.openqasm.v1
Doel-id:
- H1-1 Emulator: quantinuum.sim.h1-1e
Doeluitvoeringsprofiel: QIR Adaptive RI

Systeemmodel H1 Emulator wordt gratis aangeboden met een hardwareabonnement. Zie De prijzen van Azure Quantum voor meer informatie.

H-Serie Emulator (op basis van de cloud)

De H-serie emulator is gratis beschikbaar op de pagina Code met Azure Quantum op de Azure Quantum-website , waar u Q#-code kunt schrijven en uw taken kunt verzenden naar de Quantinuum H-Series Emulator zonder een Azure-account. De H-serie Emulator is een kwantumemulator op basis van statevector die gebruikmaakt van een realistisch fysiek ruismodel en gegeneraliseerde foutparameters op basis van de typische prestaties van een kwantumcomputer van het systeemmodel H1. De uitgevoerde kwantumsimulatie is hetzelfde als de System Model H1 Emulator , maar de klassieke circuitoptimalisatieroutine wordt verminderd om de doorvoer te verhogen. Ondersteuning voor geïntegreerde hybride computing is gepland voor een toekomstige datum.

Systeemmodel H1

De systeemmodel H1-generatie van kwantumcomputers, mogelijk gemaakt door Honeywell, bestaat uit een QCCD (Quantum charge-connected device) met één lineaire sectie en bevat momenteel één machine targets: de H1-1. Gebruikers worden aangemoedigd om de compatibiliteit van hun code met de H1-1 te testen door taken in te dienen bij een syntaxiscontrole en System Model H1 Emulator voordat ze naar de target machines worden ingediend.

De systeemmodel H1-machine wordt continu geüpgraded gedurende de levenscyclus van het product. Gebruikers krijgen toegang tot de meest recente, geavanceerde en compatibele hardware die beschikbaar is.

Meer informatie vindt u in het productgegevensblad System Model H1 op de pagina System Model H1 .

Taaktype: Quantum Program
Gegevensindeling: honeywell.openqasm.v1, honeywell.qir.v1
Doel-id:
- H1-1: quantinuum.qpu.h1-1
Doeluitvoeringsprofiel: QIR Adaptive RI

Systeemmodel H2 Emulator

Na het valideren van de syntaxis van hun code met de H2-1-syntaxiscontrole, kunnen gebruikers profiteren van de System Model H2 Emulator van Quantinuum, een emulatiehulpprogramma dat een gedetailleerd fysiek model en realistisch ruismodel van de werkelijke System Model H2-hardware bevat. Meer informatie over het ruismodel vindt u in het productgegevensblad System Model H2 Emulator op de pagina System Model H2 . De System Model H2 Emulator maakt gebruik van een identieke API voor het indienen van taken als de System Model H2-hardware, waardoor naadloze overgang van emulatie naar hardware mogelijk is. Om de productiviteit te maximaliseren en de ontwikkeltijd te verkorten, is de H2 Emulator beschikbaar, zelfs als de hardware offline is.

Taaktype: Simulation
Gegevensindeling: quantinuum.openqasm.v1
Doel-id:
- H2-1 Emulator: quantinuum.sim.h2-1e
Doeluitvoeringsprofiel: QIR Adaptive RI

Het gebruik van system Model H2 Emulator wordt gratis aangeboden met een hardwareabonnement. Zie De prijzen van Azure Quantum voor meer informatie.

Systeemmodel H2

De Quantinuum System Model H2-generatie van kwantumcomputers, mogelijk gemaakt door Honeywell, bestaat uit een QCCD (Quantum charge-linked device) met twee verbonden lineaire secties en heeft momenteel 1 machine, de H2-1. Meer informatie vindt u in het productgegevensblad System Model H2 op de pagina System Model H2 . Gebruikers worden aangemoedigd om de compatibiliteit van hun code te testen door taken in te dienen bij een syntaxiscontrole en System Model H2 Emulator voordat ze naar de target computers worden ingediend.

Als een gebruiker een taak indient naar de H2-1-machine en de H2-1-machine niet beschikbaar is, blijft de taak in de wachtrij van die machine totdat de machine beschikbaar is.

Systeemmodel H2-hardware wordt voortdurend geüpgraded gedurende de levenscyclus van het product. Gebruikers krijgen toegang tot de meest recente, geavanceerde en compatibele hardware die beschikbaar is.

Taaktype: Quantum Program
Gegevensindeling: quantinuum.openqasm.v1
Doel-id:
- H2-1: quantinuum.qpu.h2-1
Doeluitvoeringsprofiel: QIR Adaptive RI

Technische specificaties van systeemmodel H1 en H2

Technische details voor System Model H1 en System Model H2 vindt u in de productgegevensbladen van Quantinuum op de pagina's Systeemmodel H1 en Systeemmodel H2 , naast koppelingen naar Quantinuum-specificatie en gegevensopslagplaatsen voor kwantumvolumes en het citeren van het gebruik van Quantinuum-systemen.

Aanvullende mogelijkheden

Aanvullende mogelijkheden die beschikbaar zijn via de Quantinuum-API, worden hier vermeld.

Mogelijkheid	Beschrijving
Middencircuitmeting en -reset (MCMR)	Qubits in het midden van een circuit meten en opnieuw gebruiken
Willekeurige hoek ZZ-poorten	Rechtstreeks 2-qubit willekeurige hoekpoortrotaties uitvoeren
Ruisparameters van emulator	Experimenteer met de ruisparameters die worden gebruikt in de Quantinuum H-Series-emulators
TKET-optimalisaties in H-serie stack	Experimenteren met het inschakelen van verschillende niveaus van TKET-optimalisaties in de H-seriestack

Gebruikers kunnen gebruikmaken van deze aanvullende mogelijkheden via circuitfuncties of passthrough-parameters in de Azure Quantum Q#- en Qiskit-providers.

Meting en reset van middencircuit

Met meting en reset van mid-circuit (MCMR) kunnen gebruikers qubits in het midden van een circuit meten en ze opnieuw instellen. Dit maakt functionaliteit mogelijk voor kwantumfoutcorrectie en de mogelijkheid om qubits binnen het circuit opnieuw te gebruiken.

Vanwege de interne niveaustructuur van gevangen-ion-qubits kan een gemiddelde circuitmeting de qubit in een niet-rekenkundige toestand achterlaten. Alle metingen van het middencircuit moeten worden gevolgd door een reset als de qubit opnieuw in dat circuit moet worden gebruikt. In de volgende codevoorbeelden ziet u dit.

Wanneer een subset van qubits wordt gemeten in het midden van het circuit, kan de klassieke informatie van deze metingen worden gebruikt om toekomstige elementen van het circuit te conditioneren. In de voorbeelden wordt dit gebruik ook gemarkeerd.

Zie de productgegevensbladen van de H-serie op de pagina's Systeemmodel H1 en Systeemmodel H2 voor informatie over MCMR-systemen in Quantinuum-systemen.

MCMR met Q#-provider
MCMR met Qiskit-provider

In Q# kan de MResetZ functie worden gebruikt om een qubit te meten en opnieuw in te stellen. Zie de Q#-documentatie voor meer informatie over deze functie MResetZ .

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

In Qiskit worden qubits expliciet gemeten en opnieuw ingesteld. Voorwaardelijke bewerkingen kunnen worden opgegeven met behulp van de c_if functie na een poort.

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

Willekeurige hoek ZZ-poorten

De systeemeigen poortset van Quantinuum bevat willekeurige hoek-ZZ-poorten. Dit is handig voor het verminderen van het aantal twee qubit-gates voor veel kwantumalgoritmen en poortreeksen. Zie de productgegevensbladen van de H-serie op de pagina's Systeemmodel H1 en Systeemmodel H2 voor informatie over willekeurige hoek-ZZ-poorten in Quantinuum-systemen.

Willekeurige hoek-ZZ-poorten met Q#-provider
Willekeurige hoek-ZZ-poorten met Qiskit Provider

In Q# wordt de willekeurige hoek-ZZ-poort geïmplementeerd met de Rzz bewerking.

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

operation ContinueComputationAfterReset(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;
}

In Qiskit wordt de willekeurige hoek-ZZ-poort geïmplementeerd met de rzz methode.

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

Ruisparameters van emulator

Gebruikers kunnen experimenteren met de ruisparameters van de Quantinuum-emulators. Hier worden slechts enkele beschikbare ruisparameters gemarkeerd die laten zien hoe u de parameters in de Azure Quantum-providers doorgeeft.

Zie de productgegevensbladen van de H-serie emulator op de pagina's System Model H1 en System Model H2 voor meer informatie over de volledige set ruisparameters die beschikbaar zijn.

Ruisparameters emulator met Q#-provider
Ruisparameters emulator met Qiskit-provider

Importeer eerst de vereiste pakketten en initieer het basisprofiel:

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

Definieer vervolgens de functie.

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

en compileer de bewerking:

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

Maak verbinding met Azure Quantum, selecteer de target machine en configureer de ruisparameters voor de 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
    }
}

Geef de ruisopties van de emulator door bij het verzenden van de taak:

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

Als u het emulatorruismodel wilt uitschakelen, stelt u de error-model optie in op False. Dit is standaard ingesteld op True.

option_params = {
    "error-model": False 
}

Als u de stabilisatoremulator wilt gebruiken, stelt u de simulator optie in op stabilizer. Dit is standaard ingesteld op state-vector.

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

Als u het emulatorruismodel wilt uitschakelen, stelt u de error-model optie in op False. Dit is standaard ingesteld op True.

option_params = {
    "error-model": False 
}

Als u de stabilisatoremulator wilt gebruiken, stelt u de simulator optie in op stabilizer. Dit is standaard ingesteld op state-vector.

option_params = {
    "simulator": "stabilizer" 
}

TKET-compilatie in H-serie stack

Circuits die worden verzonden naar Quantinuum H-Series-systemen, met uitzondering van geïntegreerde hybride inzendingen, worden automatisch uitgevoerd via TKET-compilatiepassen voor hardware uit de H-serie. Hierdoor kunnen circuits automatisch worden geoptimaliseerd voor systemen uit de H-serie en efficiënter worden uitgevoerd.

Meer informatie over de specifieke compilatiepassen die zijn toegepast, vindt u in de pytket-quantinuum documentatie, met name de pytket-quantinuum sectie Compilatiepassen .

In de softwarestack van de H-serie wordt het toegepaste optimalisatieniveau ingesteld met de tket-opt-level parameter. De standaardcompilatie-instelling voor alle circuits die worden verzonden naar systemen uit de H-serie is optimalisatieniveau 2.

Gebruikers die willen experimenteren met de TKET-compilatie en zien welke optimalisaties van toepassing zijn op hun circuits voordat ze taken indienen, kunnen de notebook Quantinuum_compile_without_api.ipynb zien in de pytket-quantinuum map Voorbeelden .

Om TKET-compilatie in de stack uit te schakelen, kan een andere optie worden no-optingesteld True op binnen option_params. Bijvoorbeeld: "no-opt": True.

Zie de volgende koppelingen voor meer informatie pytket:

TKET-compilatie met Q#-provider
TKET-compilatie met Qiskit-provider

Importeer eerst de vereiste pakketten en initieer het basisprofiel:

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

Definieer vervolgens de functie.

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

en compileer de bewerking:

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

Maak verbinding met Azure Quantum, selecteer de target machine en configureer de ruisparameters voor de 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
}

Geef de optimalisatieoptie door wanneer u de taak indient:

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

Technische specificaties

Technische details voor de System Model H1- en H2- en System Model H1- en H2 Emulators vindt u in de productgegevensbladen van Quantinuum op de pagina System Model H1 en System Model H2 , naast koppelingen naar quantinuum-specificatie- en kwantumvolumegegevensopslagplaatsen en het citeren van het gebruik van Quantinuum-systemen.

Doel beschikbaarheid

De kwantumcomputers van de Quantinuum H-serie zijn ontworpen om continu te worden bijgewerkt, waardoor klanten toegang hebben tot de nieuwste hardwaremogelijkheden, omdat Quantinuum voortdurend de betrouwbaarheid van poorten, geheugenfouten en systeemsnelheid verbetert.

Quantinuum-hardware doorloopt commerciële perioden en ontwikkelingsperioden. Tijdens commerciële perioden is de hardware beschikbaar voor het verwerken van taken via een wachtrijsysteem. Tijdens ontwikkelingsperioden is de hardware offline wanneer upgrades worden toegepast.

Elke maand wordt een agenda verzonden naar Quantinuum-gebruikers met informatie over de commerciële en ontwikkelingsperioden. Als u deze agenda niet hebt ontvangen, kunt u een e-mail sturen QCsupport@quantinuum.com.

De status van een targetgebruiker geeft de huidige mogelijkheid aan om taken te verwerken. De mogelijke statussen van een target zijn:

Beschikbaar: Het target is online, het verwerken van ingediende taken en het accepteren van nieuwe taken.
Gedegradeerd: de target taken worden geaccepteerd, maar worden momenteel niet verwerkt.
Niet beschikbaar: het target is offline en accepteert geen nieuwe taakinzendingen.

Voor de Quantinuum-kwantumcomputer komen beschikbaar en gedegradeerd overeen met commerciële perioden, terwijl Niet beschikbaar overeenkomt met ontwikkelingsperioden waarin de machine offline is voor upgrades. targets

Huidige statusgegevens kunnen worden opgehaald op het tabblad Providers van een werkruimte in Azure Portal.

Prijzen

Als u de factureringsplannen van Quantinuum wilt bekijken, gaat u naar de prijzen van Azure Quantum.

Limieten en quota

De quota van Quantinuum worden bijgehouden op basis van de QPU-gebruikstegoedeenheid, H-System Quantum Credit (HQC) voor taken die zijn ingediend bij Quantinuum-kwantumcomputers en emulator-HQC's (HQC's) voor taken die worden verzonden naar emulators.

HQC's en eHQC's worden gebruikt om de kosten van het uitvoeren van een taak te berekenen en deze worden berekend op basis van de volgende formule:

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

waarbij geldt:

$N_{1q}$ is het aantal bewerkingen met één qubit in een circuit.
$N_{2q}$ is het aantal systeemeigen twee qubitbewerkingen in een circuit. Systeemeigen poort is gelijk aan CNOT tot meerdere poorten met één qubit.
$N_{m}$ is het aantal bewerkingen voor statusvoorbereiding en -meting (SPAM) in een circuit, inclusief initiële impliciete statusvoorbereiding en eventuele tussen- en eindmetingen en statusherstelbewerkingen.
$C$ is het aantal shots.

Notitie

De totale kosten in HQC's omvatten alle poorten en metingen in voorwaardelijke vertakkingen of controlestromen. Dit kan een hogere impact hebben op geïntegreerde hybride taken.

Quota zijn gebaseerd op de selectie van plannen en kunnen worden verhoogd met een ondersteuningsticket. Als u uw huidige limieten en quota wilt zien, gaat u naar de blade Tegoeden en quota en selecteert u het tabblad Quota van uw werkruimte in Azure Portal. Zie Azure Quantum-quota voor meer informatie.