Quantinuum-provider

Artikel
03/21/2024

Tip

Nieuwe gebruikers krijgen automatisch gratis $ 500 (USD)Azure Quantum-tegoed voor gebruik met elke deelnemende kwantumhardwareprovider. Als u alle tegoeden hebt verbruikt en u meer nodig hebt, kunt u een aanvraag indienen voor het Azure Quantum-tegoedprogramma.

Quantinuum biedt toegang tot systemen met gevangen ionen met hoge kwaliteit, volledig verbonden qubits en de mogelijkheid om metingen met het middencircuit uit te voeren.

Uitgever: Quantinuum
Provider-id: quantinuum

Doelen

De volgende targets zijn beschikbaar bij deze provider:

Doelnaam	Doel-id	Aantal qubits	Description
H1-1-syntaxiscontrole	quantinuum.sim.h1-1sc	20 qubits	Gebruik dit om kwantumprogramma's te valideren op basis van de H1-1-compiler voordat ze worden ingediend bij hardware of emulators op het platform van Quantinuum. Gratis.
H2-1-syntaxiscontrole	quantinuum.sim.h2-1sc	32 qubits	Gebruik dit om kwantumprogramma's te valideren op basis van de H2-1-compiler voordat ze worden ingediend bij hardware of emulators 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	32 qubits	Maakt gebruik van een realistisch fysiek model en ruismodel van H2-1.
H1-1	quantinuum.qpu.h1-1	20 qubits	Het H1-1 gevangen ionenapparaat van Quantinuum.
H2-1	quantinuum.qpu.h2-1	32 qubits	Het H2-1 gevangen ionenapparaat van Quantinuum.

Quantinuum komt targets overeen met een Basic Measurement Feedback profiel. Zie Inzicht target in profieltypen in Azure Quantum voor meer informatie over dit target profiel en de bijbehorende beperkingen.

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 hun code eerst te valideren met behulp van een syntaxiscontrole. Dit is een hulpprogramma om de juiste syntaxis, voltooiing van compilatie en machinecompatibiliteit te controleren. Syntaxiscontrole gebruikt dezelfde compiler als de kwantumcomputer.target 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 de status Mislukt en wordt de geretourneerde fout geretourneerd om gebruikers te helpen fouten op te sporen in hun circuitsyntaxis. Met syntaxiscontrole kunnen ontwikkelaars hun code op elk gewenst moment valideren, zelfs wanneer computers 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: Feedback over basismeting

Syntaxiscontrole wordt gratis aangeboden.

System Model H1 Emulators

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

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

Taaktype: Simulation
Gegevensindeling: quantinuum.openqasm.v1
Doel-id:
- H1-1 Emulator: quantinuum.sim.h1-1e
Doeluitvoeringsprofiel: Basic Measurement Feedback

Het gebruik van System Model H1 Emulator wordt gratis aangeboden met een hardwareabonnement. Zie Prijzen van Azure Quantum voor meer informatie.

Emulator van de H-serie (op basis van de cloud)

De H-Serie Emulator is gratis beschikbaar op de pagina Code with 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 op statevector gebaseerde kwantumemulator die gebruikmaakt van een realistisch model voor fysieke ruis en gegeneraliseerde foutparameters op basis van de typische prestaties van een systeemmodel H1-kwantumcomputer. 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 generatie van kwantumcomputers van het systeemmodel H1, Powered by Honeywell, bestaat uit een kwantumladingsgekoppeld apparaat (QCCD) 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 systeemmodel H1 Emulator voordat ze naar de target computers worden ingediend.

De systeemmodel H1-machine wordt continu bijgewerkt 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 Systeemmodel H1 op de pagina Systeemmodel H1 .

Taaktype: Quantum Program
Gegevensindeling: honeywell.openqasm.v1, honeywell.qir.v1
Doel-id:
- H1-1: quantinuum.qpu.h1-1
Doeluitvoeringsprofiel: Basic Measurement Feedback

Systeemmodel H2 Emulator

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

Taaktype: Simulation
Gegevensindeling: quantinuum.openqasm.v1
Doel-id:
- H2-1 Emulator: quantinuum.sim.h2-1e
Doeluitvoeringsprofiel: Feedback over basismeting

Het gebruik van System Model H2 Emulator wordt gratis aangeboden bij een hardwareabonnement. Zie Prijzen van Azure Quantum voor meer informatie.

Systeemmodel H2

De Quantum System Model H2 generatie van kwantumcomputers, Powered by Honeywell, bestaat uit een Quantum charge-linked device (QCCD) met twee verbonden lineaire secties en heeft momenteel 1 machine, de H2-1. Meer informatie vindt u in het productgegevensblad Systeemmodel H2 op de pagina Systeemmodel 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 verzendt naar de H2-1-machine en de H2-1-machine niet beschikbaar is, blijft de taak in de wachtrij van die machine staan totdat de machine beschikbaar is.

Systeemmodel H2-hardware wordt continu geüpgraded gedurende de gehele 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: Feedback over basismeting

Technische specificaties van systeemmodel H1 en H2

Technische details voor Systeemmodel H1 en Systeemmodel H2 zijn te vinden in de productgegevensbladen van Quantinuum op de pagina's Systeemmodel H1 en Systeemmodel H2 , naast koppelingen naar Quantinuum-specificatie en kwantumvolumegegevensopslagplaatsen en hoe u het gebruik van Quantinuum-systemen kunt citeren.

Aanvullende mogelijkheden

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

Mogelijkheid	Beschrijving
Middencircuit meten en opnieuw instellen (MCMR)	Qubits in het midden van een circuit meten en opnieuw gebruiken
Willekeurige hoek ZZ-poorten	Rechtstreeks willekeurige hoekpoortrotaties van 2 qubits uitvoeren
Parameters voor emulatorruis	Experimenteren met de ruisparameters die worden gebruikt in de Emulators van de Quantinuum H-serie
TKET-optimalisaties in H-seriestack	Experimenteren met het inschakelen van verschillende niveaus van TKET-optimalisaties in de stack van de H-serie

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

Mid-circuit meten en opnieuw instellen

Mid-circuit Measurement and Reset (MCMR) stelt gebruikers in staat om qubits in het midden van een circuit te meten en opnieuw in te stellen. Dit biedt functionaliteit voor kwantumfoutcorrectie en de mogelijkheid om qubits binnen het circuit opnieuw te gebruiken.

Vanwege de interne niveaustructuur van opgesloten ionen qubits, kan een meting van het middencircuit de qubit in een niet-rekenkundige toestand achterlaten. Alle metingen in het middencircuit moeten worden gevolgd door een reset als de qubit opnieuw in dat circuit moet worden gebruikt. De volgende codevoorbeelden laten dit zien.

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 bepalen. In de voorbeelden wordt dit gebruik ook benadrukt.

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

MCMR met Q#-provider
MCMR met Qiskit-provider

In Q# kan de MResetZ functie zowel worden gebruikt om een qubit te meten als om deze 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 nuttig voor het verminderen van het aantal 2-qubitpoorten voor veel kwantumalgoritmen en poortreeksen. Zie de productgegevensbladen van de H-serie op de pagina's Systeemmodel H1 en Systeemmodel H2 voor informatie over ZZ-poorten met willekeurige hoek 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()

Parameters voor emulatorruis

Gebruikers kunnen experimenteren met de ruisparameters van de Quantinuum-emulators. Slechts enkele van de beschikbare ruisparameters worden hier gemarkeerd om te laten zien hoe u de parameters in de Azure Quantum-providers kunt doorgeven.

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

Ruisparameters van de emulator met Q#-provider
Parameters voor emulatorruis met Qiskit-provider

Importeer eerst de vereiste pakketten en start 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 opties voor emulatorruis 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-seriestack

Circuits die worden verzonden naar systemen uit de Quantinuum H-serie, 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 standaardinstelling voor compilatie voor alle circuits die worden verzonden naar systemen uit de H-serie is optimalisatieniveau 2.

Gebruikers die willen experimenteren met de TKET-compilatie en willen zien welke optimalisaties op hun circuits worden toegepast voordat ze taken indienen, kunnen het notitieblok Quantinuum_compile_without_api.ipynb zien in de pytket-quantinuum map Voorbeelden .

Zie de volgende koppelingen voor meer informatie over pytket:

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

Importeer eerst de vereiste pakketten en start 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 otimization-optie door bij het verzenden van de taak:

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 het systeemmodel H1 en H2 en systeemmodel H1 en H2 Emulators vindt u in de productgegevensbladen van Quantinuum op de pagina Systeemmodel H1 en Systeemmodel H2 , naast koppelingen naar quantinuum-specificatie en opslagplaatsen voor kwantumvolumegegevens en hoe u het gebruik van Quantinuum-systemen kunt citeren.

Doel beschikbaarheid

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

Quantinuum hardwarecycli 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 als er upgrades worden toegepast.

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

De status van een targetgeeft de huidige mogelijkheid aan om taken te verwerken. De mogelijke statussen van een target omvatten:

Beschikbaar: de target is online, verwerkt verzonden taken en accepteert nieuwe.
Gedegradeerd: de target accepteert taken, maar verwerkt deze momenteel niet.
Niet beschikbaar: de target is offline en accepteert geen nieuwe taakinzendingen.

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

De huidige statusgegevens kunnen worden opgehaald op het tabblad Providers van een werkruimte op de Azure Portal.

Prijzen

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

Limieten en quota

De quota van Quantinuum worden bijgehouden op basis van de QPU-gebruikstegoedeenheid H-System Quantum Credit (HQC) voor taken die worden verzonden naar Quantinuum-kwantumcomputers en emulator HQCs (eHQCs) 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 ze worden berekend op basis van de volgende formule:

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

Hierbij

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

Notitie

De totale kosten in HQCs omvatten alle poorten en metingen voor voorwaardelijke vertakkingen of controlestromen. Dit kan een grotere 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 op de Azure Portal. Zie Azure Quantum-quota voor meer informatie.