Provider Quantinuum

Quantinuum consente di accedere ai sistemi a ioni intrappolati con qubit ad alta fedeltà, completamente connessi e la possibilità di eseguire la misurazione a metà circuito.

• Autore: Quantinuum
• ID provider: quantinuum

Targets

Di seguito sono disponibili i provider targets seguenti:

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

Tutti i quantinuum targets supportano ora circuiti ibridi integrati. Per altre informazioni sull'invio di processi ibridi integrati, vedere Integrated Hybrid Computing.For more information about submitting integrated hybrid jobs, see Integrated Hybrid Computing.

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

Controlli della sintassi

È consigliabile prima che gli utenti convalidino 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. Gli strumenti di controllo della 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 gli 0. Se il codice non viene compilato, il controllo della sintassi restituisce uno stato di errore e restituisce l'errore restituito per consentire agli utenti di eseguire il debug della sintassi del circuito. Gli strumenti di controllo della 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
• Target ID:
  • Controllo sintassi H1-1: quantinuum.sim.h1-1sc
  • Controllo sintassi H2-1: quantinuum.sim.h2-1sc
• Target Profilo di esecuzione: QIR Adaptive RI

L'utilizzo dei controlli della sintassi è gratuito.

Emulatori H1 del modello di sistema

Dopo aver convalidato la sintassi del codice con un controllo sintassi, gli utenti possono sfruttare gli emulatori del modello di sistema H1 di Quantinuum, gli strumenti di emulazione che contengono un modello fisico dettagliato e un modello di rumore realistico dell'hardware effettivo del modello di sistema 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 del modello di sistema H1, consentendo la transizione senza problemi dall'emulazione all'hardware. Per ottimizzare la produttività e ridurre il tempo di sviluppo, gli emulatori H1 del modello di sistema sono disponibili anche quando l'hardware è offline.

Altre informazioni sono disponibili nella pagina System Model H1 Emulator Product Data Sheet ( Modello di sistema H1 ).

• Tipo di processo: Simulation
• Formato dei dati: quantinuum.openqasm.v1
• Target ID:
  • Emulatore H1-1: quantinuum.sim.h1-1e
• Target Profilo di esecuzione: QIR Adaptive RI

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

Emulatore serie H (basato sul cloud)

L'emulatore serie H è disponibile gratuitamente nella pagina Code with Azure Quantum (Codice 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 disturbo fisico realistico e parametri di errore generalizzati in base alle prestazioni tipiche di un computer quantistico del modello di sistema 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 H1 del modello di sistema dei computer quantistici, basata su Honeywell, è costituita da un dispositivo ad accoppiamento a carica quantistico (QCCD) con una sezione lineare e attualmente include un computer targets: H1-1. Gli utenti sono invitati a testare la compatibilità del codice con H1-1 inviando processi a un controllo della 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 pagina System Model H1 Product Data Sheet (Modello di sistema H1).

• Tipo di processo: Quantum Program
• Formato dati: honeywell.openqasm.v1, honeywell.qir.v1
• Target ID:
  • H1-1: quantinuum.qpu.h1-1
• Target Profilo di esecuzione: QIR Adaptive RI

Emulatore H2 del modello di sistema

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

• Tipo di processo: Simulation
• Formato dei dati: quantinuum.openqasm.v1
• Target ID:
  • Emulatore H2-1: quantinuum.sim.h2-1e
• Target Profilo di esecuzione: QIR Adaptive RI

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 H2 del modello di sistema Quantinuum di computer quantistici, basata su Honeywell, è costituita da un dispositivo ad accoppiamento a carica quantistico (QCCD) con due sezioni lineari connesse e attualmente dispone di 1 computer, H2-1. Altre informazioni sono disponibili nella pagina System Model H2 Product Data Sheet (Modello di sistema H2). Gli utenti sono invitati a testare la compatibilità del codice inviando processi a un controllo della sintassi e all'emulatore System Model H2 prima di inviarli ai target 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 del modello di sistema H2 viene aggiornato continuamente 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
• Target ID:
  • H2-1: quantinuum.qpu.h2-1
• Target Profilo di esecuzione: QIR Adaptive RI

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 Modello di sistema H1 e Modello di sistema H2 insieme ai collegamenti alle specifiche quantinuum e ai repository di dati dei volumi quantistici e come citare l'utilizzo dei sistemi Quantinuum.

Altre funzionalità

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

Gli utenti possono sfruttare queste funzionalità aggiuntive tramite funzioni del 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 misurazione 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 operazione.

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 dei prodotti serie H nelle pagine System Model H1 e System Model H2 .

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

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

Cancelli ZZ angolo arbitrario

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 gate. Per informazioni sulle porte ZZ angle arbitrarie nei sistemi Quantinuum, vedere i fogli dati dei prodotti serie H nelle pagine System Model H1 e System Model H2 .

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

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

General SU(4) Entangling Gate

Il set di gate nativo di Quantinuum include un cancello generale di intangimento su(4). Si noti che i circuiti quantistici inviati all'hardware vengono ribasati sul gate ZZ completamente entangling e sul gate RZZ arbitrario angolo. I circuiti vengono ribasati solo sul gate Generale SU(4) Entangling se gli utenti lo acconsentono. Per informazioni sui sistemi General SU(4) Entangler nei sistemi Quantinuum, vedere i fogli dati del prodotto serie H nelle pagine System Model H1 e System Model H2 .

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

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

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
}

job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()

Parametri di disturbo dell'emulatore

Gli utenti hanno la possibilità di sperimentare i parametri di rumore 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 .

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

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

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

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

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

option_params = {
    "error-model": False 
}

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

option_params = {
    "error-model": False 
}

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 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 disattivare la compilazione TKET nello stack, un'opzione diversa, no-opt, può essere impostata su all'interno option_paramsdi True . Ad esempio: "no-opt": True.

Per altre informazioni su pytket, vedere i collegamenti seguenti:

• pytket
• pytket Manuale

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

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

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

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
}

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 il modello di sistema H1 e H2 e l'emulatore H1 e H2 sono disponibili nei fogli dati del prodotto Quantinuum nella pagina System Model H1 e System Model H2 insieme ai collegamenti ai repository di dati relativi alla specifica Quantinuum e ai repository di dati dei volumi quantistici e come citare l'utilizzo dei sistemi Quantinuum.

Target Disponibilità

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

Cicli hardware quantinuum 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 man mano che vengono applicati gli aggiornamenti.

Ogni mese, viene inviato un calendario agli utenti quantinuum con informazioni sui periodi commerciali e di sviluppo. Se il 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 oggetto includono:

• Disponibile: target è online, elabora i processi inviati e accetta quelli nuovi.
• Danneggiato: accetta target processi, ma attualmente non li elabora.
• Non disponibile: l'oggetto target è offline e non accetta nuovi invii di processi.

Per il computer targetsquantistico Quantinuum, Available e Degraded corrispondono ai periodi commerciali, mentre Non disponibile corrisponde ai periodi di sviluppo in cui il computer è 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 rilevate in base all'unità di credito di utilizzo QPU, H-System Quantum Credit (HQC), per i processi inviati ai computer quantistici Quantinuum e agli HQCS (eHQCs) dell'emulatore per i processi inviati agli emulatori.

Per calcolare il costo dell'esecuzione di un processo, vengono usati HQCs ed eHQC, che 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.

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.