Provider Quantinuum

Articolo
03/21/2024

Suggerimento

Gli utenti per la prima volta ottengono automaticamente $ 500 (USD)Crediti Quantistici di Azure per l'uso con ogni provider hardware quantistico partecipante. Se sono stati utilizzati tutti i crediti e sono necessari crediti aggiuntivi, è possibile candidarsi al programma Azure Quantum Credits.

Quantinuum fornisce l'accesso ai sistemi di ion intrappolati con alta fedeltà, con qubit completamente connessi e la possibilità di eseguire la misurazione del circuito intermedio.

Editore: Quantinuum
ID provider: quantinuum

Targets

Di seguito sono disponibili i seguenti targets provider:

Nome di destinazione	ID di destinazione	Numero di qubit	Descrizione
Controllo sintassi H1-1	quantinuum.sim.h1-1sc	20 qubit	Usare questa opzione per convalidare i programmi quantistici nel compilatore H1-1 prima di inviare all'hardware o agli emulatori nella piattaforma Quantinuum. Costo gratuito.
Controllo sintassi H2-1	quantinuum.sim.h2-1sc	32 qubit	Usare questa opzione per convalidare i programmi quantistici rispetto al compilatore H2-1 prima di inviare all'hardware o agli emulatori nella piattaforma Quantinuum. Costo gratuito.
Emulatore H1-1	quantinuum.sim.h1-1e	20 qubit	Usa un modello fisico realistico e un modello di rumore di H1-1.
Emulatore H2-1	quantinuum.sim.h2-1e	32 qubit	Usa un modello fisico realistico e un modello di rumore di H2-1.
H1-1	quantinuum.qpu.h1-1	20 qubit	Dispositivo di ion intrappolato H1-1 di Quantinuum.
H2-1	quantinuum.qpu.h2-1	32 qubit	Dispositivo di ion intrappolato H2-1 di Quantinuum.

Quantinuum targets corrisponde a un Basic Measurement Feedback profilo. Per altre informazioni su questo target profilo e sulle relative limitazioni, vedere Informazioni target sui tipi di profilo in Azure Quantum.

Tutti i quantinuum targets ora supportano circuiti ibridi integrati. Per altre informazioni sull'invio di processi ibridi integrati, vedere Elaborazione ibrida integrata.

Per iniziare a usare il provider Quantinuum in Azure Quantum, vedere Introduzione a Q# e un notebook di Azure Quantum.

Suggerimento

I processi quantistici inviati in una sessione hanno accesso esclusivo all'hardware Quantinuum purché i processi in coda entro un minuto dall'altro. In seguito, qualsiasi processo viene accettato e gestito con la logica di accodamento e priorità standard. Per altre informazioni, vedere Sessioni in Azure Quantum.

Controllo sintassi

È consigliabile prima che gli utenti convalidano il codice usando un controllo sintassi. Si tratta di uno strumento per verificare la sintassi appropriata, il completamento della compilazione e la compatibilità del computer. I controllori di sintassi usano lo stesso compilatore del computer quantistico.target Ad esempio, il controllo della sintassi H1-1 usa lo stesso compilatore di H1-1. Lo stack di compilazione completo viene eseguito con l'eccezione delle operazioni quantistice effettive. Se il codice viene compilato, il controllo della sintassi restituisce uno success stato e un risultato di tutti i 0. Se il codice non viene compilato, il controllo della sintassi restituisce uno stato non riuscito e restituisce l'errore restituito per consentire agli utenti di eseguire il debug della sintassi del circuito. I controllori di sintassi consentono agli sviluppatori di convalidare il codice in qualsiasi momento, anche quando i computer sono offline.

Tipo di processo: Simulation
Formati di dati: honeywell.openqasm.v1, honeywell.qir.v1
ID destinazione:
- Controllo sintassi H1-1: quantinuum.sim.h1-1sc
- Controllo sintassi H2-1: quantinuum.sim.h2-1sc
Profilo di esecuzione della destinazione: feedback sulle misurazioni di base

L'utilizzo dei checker della sintassi è disponibile gratuitamente.

Emulatori del modello di sistema H1

Dopo aver convalidato la sintassi del codice con un controllo sintassi, gli utenti possono sfruttare gli emulatori system model H1 di Quantinuum, gli strumenti di emulazione che contengono un modello fisico dettagliato e un modello di rumore realistico dell'hardware del modello di sistema effettivo H1. I modelli di rumore sono derivati da una caratterizzazione dettagliata dell'hardware. Gli emulatori del modello di sistema H1 usano un'API identica per l'invio di processi come hardware System Model H1, consentendo la transizione senza problemi dall'emulazione all'hardware. Per ottimizzare la produttività e ridurre il tempo di sviluppo, gli emulatori di System Model H1 sono disponibili anche quando l'hardware è offline.

Altre informazioni sono disponibili nella pagina Modello di sistema H1 Emulator Product Data Sheet nella pagina Modello di sistema H1 .

Tipo di processo: Simulation
Formato dei dati: quantinuum.openqasm.v1
ID destinazione:
- Emulatore H1-1: quantinuum.sim.h1-1e
Profilo di esecuzione di destinazione: Basic Measurement Feedback

L'utilizzo dell'emulatore modello di sistema H1 viene offerto gratuitamente con una sottoscrizione hardware. Per informazioni dettagliate, vedere Prezzi di Azure Quantum.

Emulatore H-Series (basato sul cloud)

L'emulatore H-Series è disponibile gratuitamente nella pagina Code con Azure Quantum nel sito Web di Azure Quantum, in cui è possibile scrivere codice Q# e inviare i processi all'emulatore Quantinuum H-Series senza un account Azure. L'emulatore H-Series è un emulatore quantistico basato su statevector che usa un modello di rumore fisico realistico e parametri di errore generalizzati in base alle prestazioni tipiche di un computer quantistico System Model H1. La simulazione quantistica eseguita è uguale all'emulatore System Model H1 , ma la routine di ottimizzazione del circuito classica viene ridotta per aumentare la velocità effettiva. Il supporto per il calcolo ibrido integrato è previsto per una data futura.

Modello di sistema H1

La generazione di System Model H1 dei computer quantistici, Basata su Honeywell, è costituita da un dispositivo con carica quantistica (QCCD) con una sezione lineare e attualmente include una macchina targets: H1-1. Gli utenti sono invitati a testare la compatibilità del codice con H1-1 inviando processi a un controllo sintassi e all'emulatore system model H1 prima di inviarli ai target computer.

Il computer System Model H1 viene aggiornato continuamente durante il ciclo di vita del prodotto. Agli utenti viene concesso l'accesso all'hardware più aggiornato, avanzato e idoneo disponibile.

Altre informazioni sono disponibili nella scheda dati del prodotto Modello di sistema H1 disponibile nella pagina Modello di sistema H1 .

Tipo di processo: Quantum Program
Formato dati: honeywell.openqasm.v1, honeywell.qir.v1
ID destinazione:
- H1-1: quantinuum.qpu.h1-1
Profilo di esecuzione di destinazione: Basic Measurement Feedback

Emulatore del modello di sistema H2

Dopo aver convalidato la sintassi del codice con il controllo sintassi H2-1, gli utenti possono sfruttare quantinuum's System Model H2 Emulator, uno strumento di emulazione che contiene un modello fisico dettagliato e un modello di rumore realistico dell'hardware System Model H2 effettivo. Altre informazioni sul modello di rumore sono disponibili nella scheda dati del prodotto System Model H2 Emulator Product Data Sheet nella pagina System Model H2. L'emulatore System Model H2 usa un'API identica per l'invio di processi come hardware System Model H2, consentendo la transizione senza problemi dall'emulazione all'hardware. Per ottimizzare la produttività e ridurre i tempi di sviluppo, l'emulatore H2 è disponibile anche quando l'hardware è offline.

Tipo di processo: Simulation
Formato dei dati: quantinuum.openqasm.v1
ID destinazione:
- Emulatore H2-1: quantinuum.sim.h2-1e
Profilo di esecuzione della destinazione: feedback sulle misurazioni di base

L'utilizzo dell'emulatore H2 del modello di sistema è gratuito con una sottoscrizione hardware. Per informazioni dettagliate, vedere Prezzi di Azure Quantum.

Modello di sistema H2

La generazione di Quantinuum System Model H2 dei computer quantistici, con tecnologia Honeywell, è costituita da un dispositivo ad accoppiamento a carica quantistico (QCCD) con due sezioni lineari connesse e attualmente ha 1 computer, il H2-1. Per altre informazioni, vedere il foglio dati del prodotto System Model H2 disponibile nella pagina System Model H2 (Modello di sistema H2 ). Gli utenti sono invitati a testare la compatibilità del codice inviando processi a un controllo della sintassi e all'emulatore targetSystem Model H2 prima di inviarli ai computer.

Se un utente invia un processo al computer H2-1 e il computer H2-1 non è disponibile, il processo rimane nella coda del computer fino a quando il computer non diventa disponibile.

L'hardware H2 del modello di sistema viene costantemente aggiornato durante tutto il ciclo di vita del prodotto. Agli utenti viene concesso l'accesso all'hardware più aggiornato, avanzato e idoneo disponibile.

Tipo di processo: Quantum Program
Formato dei dati: quantinuum.openqasm.v1
ID destinazione:
- H2-1: quantinuum.qpu.h2-1
Profilo di esecuzione della destinazione: feedback sulle misurazioni di base

Specifiche tecniche del modello di sistema H1 e H2

I dettagli tecnici per il modello di sistema H1 e il modello di sistema H2 sono disponibili nei fogli dati del prodotto Quantinuum nelle pagine System Model H1 e System Model H2 insieme ai collegamenti alle specifiche quantinuum e ai repository di dati del volume quantistico e come citare l'utilizzo dei sistemi Quantinuum.

Altre funzionalità

Le funzionalità aggiuntive disponibili tramite l'API Quantinuum sono elencate qui.

Funzionalità	Descrizione
Misurazione e reimpostazione del circuito intermedio (MCMR)	Misurare i qubit al centro di un circuito e riutilizzarli
Porte ZZ ZZ arbitrarie	Eseguire direttamente rotazioni arbitrarie degli angoli a 2 qubit
Parametri di disturbo dell'emulatore	Sperimentare i parametri di disturbo usati negli emulatori Quantinuum H-Series
Ottimizzazioni TKET nello stack serie H	Sperimentare l'attivazione di diversi livelli di ottimizzazioni TKET nello stack H-Series

Gli utenti possono sfruttare queste funzionalità aggiuntive tramite funzioni di circuito o parametri pass-through nei provider Q# e Qiskit di Azure Quantum.

Misurazione e reimpostazione del circuito intermedio

La misurazione e la reimpostazione del circuito intermedio (MCMR) consentono agli utenti di misurare i qubit al centro di un circuito e reimpostarli. In questo modo è possibile abilitare la funzionalità per la correzione degli errori quantistici e la possibilità di riutilizzare i qubit all'interno del circuito.

A causa della struttura a livello interno di qubit a ioni intrappolati, una misura a circuito intermedio può lasciare il qubit in uno stato non computazionale. Tutte le misurazioni del circuito intermedio devono essere seguite da una reimpostazione se il qubit deve essere usato di nuovo in tale circuito. Gli esempi di codice seguenti illustrano questa situazione.

Quando un subset di qubit viene misurato al centro del circuito, le informazioni classiche di queste misurazioni possono essere usate per definire gli elementi futuri del circuito. Gli esempi evidenziano anche questo utilizzo.

Per informazioni su MCMR nei sistemi Quantinuum, vedere i fogli dati del prodotto serie H nelle pagine System Model H1 e System Model H2 .

MCMR con provider Q#
MCMR con provider Qiskit

In Q#, la MResetZ funzione può essere usata per misurare un qubit e reimpostarla. Per altre informazioni su questa funzione, vedere MResetZ la documentazione di Q#.

%%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 i qubit vengono misurati e reimpostati in modo esplicito. Le operazioni condizionali possono essere specificate usando la c_if funzione che segue un gate.

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

Porte ZZ ZZ arbitrarie

Il set di cancelli nativi di Quantinuum include cancelli ZZ arbitrari. Ciò è utile per ridurre il numero di gate a 2 qubit per molti algoritmi quantistici e sequenze di controllo. Per informazioni sulle porte ZZ Arbitrarie Angle nei sistemi Quantinuum, vedere i fogli dati del prodotto serie H nelle pagine System Model H1 e System Model H2 .

Porte ZZ arbitrarie con provider Q#
Porte ZZ ZZ arbitrarie con provider Qiskit

In Q#, il gate ZZ dell'angolo arbitrario viene implementato con l'operazione Rzz .

%%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, il gate ZZ dell'angolo arbitrario viene implementato con il rzz metodo .

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

Parametri di disturbo dell'emulatore

Gli utenti hanno la possibilità di sperimentare con i parametri di disturbo degli emulatori Quantinuum. Di seguito sono evidenziati solo alcuni dei parametri di disturbo disponibili che illustrano come passare i parametri nei provider di Azure Quantum.

Per altre informazioni sul set completo di parametri di disturbo disponibili, vedere i fogli dati del prodotto dell'emulatore serie H nelle pagine System Model H1 e System Model H2 .

Parametri di disturbo dell'emulatore con provider Q#
Parametri di disturbo dell'emulatore con provider Qiskit

Prima di tutto, importare i pacchetti necessari e avviare il profilo di base:

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

Definire quindi la funzione .

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

e compilare l'operazione:

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

Connettersi ad Azure Quantum, selezionare il target computer e configurare i parametri di disturbo per l'emulatore:

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

Passare le opzioni di disturbo dell'emulatore durante l'invio del processo:

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

Per disattivare il modello di disturbo dell'emulatore, impostare l'opzione error-model su False. L'impostazione predefinita è True.

option_params = {
    "error-model": False 
}

Per usare l'emulatore di stabilizzatore, impostare l'opzione simulator su stabilizer. L'impostazione predefinita è 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())

Per disattivare il modello di disturbo dell'emulatore, impostare l'opzione error-model su False. L'impostazione predefinita è True.

option_params = {
    "error-model": False 
}

Per usare l'emulatore di stabilizzatore, impostare l'opzione simulator su stabilizer. L'impostazione predefinita è state-vector.

option_params = {
    "simulator": "stabilizer" 
}

Compilazione TKET nello stack serie H

I circuiti inviati ai sistemi Quantinuum H-Series, ad eccezione degli invii ibridi integrati, vengono eseguiti automaticamente tramite i passaggi di compilazione TKET per l'hardware della serie H. In questo modo i circuiti possono essere ottimizzati automaticamente per i sistemi serie H ed essere eseguiti in modo più efficiente.

Altre informazioni sui passaggi di compilazione specifici applicati sono disponibili nella pytket-quantinuum documentazione, in particolare nella pytket-quantinuum sezione Passaggi di compilazione .

Nello stack software della serie H il livello di ottimizzazione applicato viene impostato con il tket-opt-level parametro . L'impostazione di compilazione predefinita per tutti i circuiti inviati ai sistemi serie H è il livello di ottimizzazione 2.

Gli utenti che vogliono sperimentare i passaggi di compilazione TKET e vedere quali ottimizzazioni si applicano ai circuiti prima di inviare qualsiasi processo possono visualizzare il notebook Quantinuum_compile_without_api.ipynb nella pytket-quantinuum cartella Esempi .

Per altre informazioni su pytket, vedere i collegamenti seguenti:

Compilazione TKET con provider Q#
Compilazione TKET con provider Qiskit

Prima di tutto, importare i pacchetti necessari e avviare il profilo di base:

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

Definire quindi la funzione .

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

e compilare l'operazione:

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

Connettersi ad Azure Quantum, selezionare il target computer e configurare i parametri di disturbo per l'emulatore:

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
}

Passare l'opzione di otimizzazione durante l'invio del processo:

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

Specifiche tecniche

I dettagli tecnici per gli emulatori System Model H1 e H2 e System Model H1 e H2 sono disponibili nei fogli dati del prodotto Quantinuum nella pagina System Model H1 e System Model H2 insieme ai collegamenti alle specifiche quantinuum e ai repository di dati del volume quantistico e come citare l'utilizzo dei sistemi Quantinuum.

Disponibilità delle destinazioni

I computer quantistici Quantinuum serie H sono progettati per essere aggiornati continuamente, consentendo ai clienti di accedere alle funzionalità hardware più recenti, poiché Quantinuum migliora continuamente le fidelità di controllo, gli errori di memoria e la velocità del sistema.

Quantinuum hardware cicli attraverso periodi commerciali e periodi di sviluppo. Durante i periodi commerciali, l'hardware è disponibile per elaborare i processi tramite un sistema di accodamento. Durante i periodi di sviluppo, l'hardware è offline quando vengono applicati gli aggiornamenti.

Ogni mese, un calendario viene inviato agli utenti Quantinuum con informazioni sui periodi di sviluppo e commerciali. Se questo calendario non è stato ricevuto, inviare un messaggio di posta elettronica QCsupport@quantinuum.com.

Lo stato di un targetoggetto indica la capacità corrente di elaborare i processi. Gli stati possibili di un target include:

Disponibile: è target online, elabora i processi inviati e accetta quelli nuovi.
Degradato: accetta target i processi, ma non li elabora.
Non disponibile: non target è offline, non accettando nuovi invii di processi.

Per il computer quantistico Quantinuum , Disponibile e Degradato corrispondono a periodi commerciali, mentre non è disponibile corrisponde ai periodi di sviluppo in cui il computer targetsè offline per gli aggiornamenti.

Le informazioni sullo stato corrente possono essere recuperate dalla scheda Provider di un'area di lavoro nel portale di Azure.

Prezzi

Per visualizzare i piani di fatturazione di Quantinuum, visitare i prezzi di Azure Quantum.

Limiti e quote

Le quote di Quantinuum vengono monitorate in base all'unità di credito di utilizzo QPU, H-System Quantum Credit (HQC), per i processi inviati ai computer quantistici Quantinuum e agli emulatori HQCs (eHQCs) per i processi inviati agli emulatori.

Per calcolare il costo dell'esecuzione di un processo, vengono usati HQCs e EHQC e vengono calcolati in base alla formula seguente:

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

dove:

$N_{1q}$ è il numero di operazioni a un qubit in un circuito.
$N_{2q}$ è il numero di operazioni a due qubit native in un circuito. La porta nativa equivale a CNOT fino ad alcune porte da un qubit.
$N_{m}$ è il numero di operazioni di preparazione e misurazione dello stato (SPAM, State Preparation and Measurement) in un circuito, inclusa la preparazione dello stato implicito iniziale ed eventuali misurazioni intermedie e finali e reimpostazioni dello stato.
$C$ è il numero di spari.

Nota

Il costo totale in HQCs include tutti i cancelli e le misurazioni in tutti i rami condizionali o i flussi di controllo. Ciò potrebbe avere un impatto maggiore sui processi ibridi integrati.

Le quote sono basate sulla selezione del piano e possono essere aumentate con un ticket di supporto. Per visualizzare i limiti e le quote correnti, passare al pannello Crediti e quote e selezionare la scheda Quote dell'area di lavoro nel portale di Azure. Per altre informazioni, vedere Quote di Azure Quantum.