Provider Rigetti

I processori quantistici Rigetti sono macchine universali e modello gate basate su qubit superconduttori ottimizzabili. Le funzionalità di sistema e le caratteristiche dei dispositivi includono funzionalità di lettura avanzate, un aumento dei tempi di elaborazione quantistica, tempi di gate rapidi per più famiglie di gate entangling, campionamento rapido tramite la reimpostazione del registro attiva e controllo parametrico.

• Editore: Rigetti
• ID provider: rigetti

Il provider Rigetti rende disponibili quanto segue targets :

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

Simulators

La macchina virtuale quantistica (QVM) è un simulatore open source per Quil. accetta rigetti.sim.qvmtarget un programma Quil come testo ed esegue il programma in QVM ospitato nel cloud, restituendo risultati simulati.

• Tipo di processo: Simulation
• Formati di dati: rigetti.quil.v1, rigetti.qir.v1
• ID destinazione: rigetti.sim.qvm
• Profilo di esecuzione di destinazione: QIR Base
• Prezzi: gratuito ($ 0)

Computer quantistici

Tutte le QPU disponibili pubblicamente di Rigetti sono disponibili tramite Azure Quantum. Questo elenco è soggetto a modifiche senza preavviso.

Ankaa-2

Un processore a 84 qubit multi chip che offre un miglioramento delle prestazioni 2,5X rispetto ad altre QPU di Rigetti.

• Tipo di processo: Quantum Program
• Formato dati: rigetti.quil.v1, rigetti.qir.v1
• ID destinazione: rigetti.qpu.ankaa-2
• Profilo di esecuzione di destinazione: QIR Base

Prezzi

Per visualizzare il piano di fatturazione di Rigetti, vedere Prezzi di Azure Quantum.

Formato di input

Tutti i Rigetti targets attualmente accettano due formati:

• rigetti.quil.v1, che è il testo di un programma Quil .
• rigetti.qir.v1, ovvero codice bit QIR.

Tutti targets accettano anche il parametro integer facoltativo count per definire il numero di scatti da eseguire. Se omesso, il programma viene eseguito una sola volta.

Quil

Tutti i Rigetti targets accettano il rigetti.quil.v1 formato di input, ovvero il testo di un programma Quil , che è l'acronimo di Quantum Instruction Language. Per impostazione predefinita, i programmi vengono compilati usando quilc prima dell'esecuzione. Tuttavia, quilc non supporta le funzionalità di controllo a livello di impulso (Quil-T), quindi se vuoi usare queste funzionalità devi fornire un programma Quil nativo (che contiene anche Quil-T) come input e specificare il parametro skipQuilc: truedi input .

Per semplificare la costruzione di un programma Quil, è possibile usare pyQuil insieme al pyquil-for-azure-quantum pacchetto. Senza questo pacchetto, pyQuil può essere usato per costruire programmi Quil, ma non per inviarli ad Azure Quantum.

QIR

Tutto l'hardware Rigetti supporta l'esecuzione di Quantum Intermediate Representation processi conformi (QIR) con il QIR Base profilo v1 come rigetti.qir.v1. QIR offre un'interfaccia comune che supporta molti linguaggi quantistici e target piattaforme per il calcolo quantistico e consente la comunicazione tra linguaggi e computer di alto livello. Ad esempio, è possibile inviare processi Q#, Quil o Qiskit all'hardware Rigetti e Azure Quantum gestisce automaticamente l'input. Per ulteriori informazioni, vedere Quantum Intermediate Representation.

Selezione del formato di input corretto

È consigliabile usare Quil o un altro linguaggio conforme a QIR? Si tratta del caso d'uso finale. QIR è più accessibile per molti utenti, mentre Quil è oggi più potente.

Se si usa Qiskit, Q# o un altro toolkit che supporta la generazione di QIR e l'applicazione funziona su Rigetti targets tramite Azure Quantum, QIR è ideale per l'utente. QIR ha una specifica in rapida evoluzione e Rigetti continua ad aumentare il supporto per i programmi QIR più avanzati man mano che passa il tempo- ciò che non può essere compilato oggi potrebbe essere ben compilato domani.

D'altra parte, i programmi Quil esprimono il set completo di funzionalità disponibili per gli utenti dei sistemi Rigetti da qualsiasi piattaforma, tra cui Azure Quantum. Se si sta cercando di personalizzare la scomposizione dei cancelli quantistici o scrivere programmi a livello di impulso, è consigliabile lavorare in Quil, perché queste funzionalità non sono ancora disponibili tramite QIR.

Esempi

Il modo più semplice per inviare processi Quil consiste nell'usare il pyquil-for-azure-quantum pacchetto, in quanto consente di usare gli strumenti e la documentazione della pyQuil libreria.

È anche possibile costruire manualmente i programmi Quil e inviarli usando direttamente il azure-quantum pacchetto.

from pyquil.gates import CNOT, MEASURE, H
from pyquil.quil import Program
from pyquil.quilbase import Declare
from pyquil_for_azure_quantum import get_qpu, get_qvm

# Note that some environment variables must be set to authenticate with Azure Quantum
qc = get_qvm()  # For simulation
# qc = get_qpu("Ankaa-2") for submitting to a QPU

program = Program(
    Declare("ro", "BIT", 2),
    H(0),
    CNOT(0, 1),
    MEASURE(0, ("ro", 0)),
    MEASURE(1, ("ro", 1)),
).wrap_in_numshots_loop(5)

# Optionally pass to_native_gates=False to .compile() to skip the compilation stage
result = qc.run(qc.compile(program))
data_per_shot = result.readout_data["ro"]
# Here, data_per_shot is a numpy array, so you can use numpy methods
assert data_per_shot.shape == (5, 2)
ro_data_first_shot = data_per_shot[0]
assert ro_data_first_shot[0] == 1 or ro_data_first_shot[0] == 0

# Let's print out all the data
print("Data from 'ro' register:")
for i, shot in enumerate(data_per_shot):
    print(f"Shot {i}: {shot}")

from azure.quantum import Workspace
from azure.quantum.target.rigetti import Result, Rigetti, RigettiTarget, InputParams

workspace = Workspace(
    # TODO: Fill in your details here
    resource_id="",
    location=""
)

target = Rigetti(
    workspace=workspace,
    name=RigettiTarget.ANKAA_2,  # Defaults to RigettiTarget.QVM for simulation
)

# Any valid Quil program is accepted, but the readout must be named `ro`
readout = "ro"
bell_state_quil = f"""
DECLARE {readout} BIT[2]

H 0
CNOT 0 1

MEASURE 0 {readout}[0]
MEASURE 1 {readout}[1]
"""

num_shots = 5
job = target.submit(
    input_data=bell_state_quil, 
    name="bell state", 
    shots=100, 
    input_params=InputParams(skip_quilc=False)
)

print(f"Queued job: {job.id}")
job.wait_until_completed()

print(f"Job completed with state: {job.details.status}")
result = Result(job)  # This throws an exception if the job failed
# You can index a Result with the name of the readout. In this case, `ro`
data_per_shot = result[readout]
# Here, data_per_shot is a list of length num_shots, each entry is a list containing the data for the register for that shot
ro_data_first_shot = data_per_shot[0]
# In this case, because the type of the register is BIT, the type will be integer and the value either 0 or 1
assert isinstance(ro_data_first_shot[0], int)
assert ro_data_first_shot[0] == 1 or ro_data_first_shot[0] == 0

# Let's print out all the data
print(f"Data from '{readout}' register:")
for i, shot in enumerate(data_per_shot):
    print(f"Shot {i}: {shot}")