Quantinuum-provider
Tip
Wanneer u een Azure Quantum-werkruimte maakt, krijgt u automatisch gratis Azure Quantum-tegoed van USD500 voor elke kwantumhardwareprovider. U kunt het Azure Quantum-tegoed gebruiken om uw eerste kwantumprogramma's naar echte kwantumhardware te verzenden.
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
Targets
De volgende targets zijn beschikbaar via deze provider:
| Target naam | Target-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 - Target LEGITIMATIEBEWIJS:
- H1-1 Syntaxiscontrole:
quantinuum.sim.h1-1sc - H2-1 Syntaxiscontrole:
quantinuum.sim.h2-1sc
- H1-1 Syntaxiscontrole:
- Target Uitvoeringsprofiel: 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 - Target LEGITIMATIEBEWIJS:
- H1-1 Emulator:
quantinuum.sim.h1-1e
- H1-1 Emulator:
- Target Uitvoeringsprofiel: 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 - Target LEGITIMATIEBEWIJS:
- H1-1:
quantinuum.qpu.h1-1
- H1-1:
- Target Uitvoeringsprofiel: 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 - Target LEGITIMATIEBEWIJS:
- H2-1 Emulator:
quantinuum.sim.h2-1e
- H2-1 Emulator:
- Target Uitvoeringsprofiel: 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 - Target LEGITIMATIEBEWIJS:
- H2-1:
quantinuum.qpu.h2-1
- H2-1:
- Target Uitvoeringsprofiel: 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.
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
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];
}
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.
In Q# wordt de willekeurige hoek-ZZ-poort geïmplementeerd met de Rzz bewerking.
%%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;
}
Algemene SU(4) Verstrengelingspoort
De systeemeigen poortset van Quantinuum bevat een algemene SU(4) verstrengelingspoort. Kwantumcircuits die naar de hardware worden verzonden, worden opnieuw gebaseerd op de volledig verstrengelende ZZ-poort en de willekeurige hoek RZZ-poort. Circuits worden alleen opnieuw gebaseerd op de Algemene SU(4) Verstrengelingspoort als gebruikers ervoor kiezen. Zie de productgegevensbladen van de H-serie op de pagina's Systeemmodel H1 en Systeemmodel H2 voor informatie over de General SU(4) Entangler in Quantinuum-systemen.
In Q# wordt de verstrengelingspoort General SU(4) geïmplementeerd via het QIR-profiel van Quantinuum. Als u deze functie wilt gebruiken, definieert u een functie met een aangepaste intrinsiek die overeenkomt met de QIR-profielhandtekening en gebruikt u deze functie in de SU4Example bewerking.
Om ervoor te zorgen dat het circuit wordt uitgevoerd met de General SU(4) Verstrengelingspoort, geeft u de volgende opties door in de H-seriestack:
nativetq: Rxxyyzzom te voorkomen dat andere systeemeigen poorten opnieuw worden ingesteld.noreduce: Trueom extra compileroptimalisaties te voorkomen (optioneel).
%%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)
}
Compileer nu 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 = {
"nativetq": `Rxxyyzz`,
"noreduce": True
}
Geef de noreduce optie door wanneer u de taak indient:
job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()
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.
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
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);
}
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"
}
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:
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
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);
}
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()
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.
Target 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.
Notitie
Als u een Azure Quantum Credits-abonnement gebruikt en geen factureringsplan, worden de quotagegevens toegewezen aan uw toegewezen tegoed. In dat geval vermeldt het quotum het totale aantal tegoed dat u hebt ontvangen.