Provider Rigetti

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

• Editore: Rigetti
• ID provider: rigetti

Il provider Rigetti rende disponibili quanto segue targets :

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

Computer quantistici

Tutti i QPU di Rigetti disponibili pubblicamente sono accessibili tramite Azure Quantum. Questo elenco è soggetto a modifiche senza preavviso.

Ankaa-3

Processore quantistico a 84 qubit.

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

Simulatori

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 lavoro: Simulation
• Formati di dati: rigetti.quil.v1, rigetti.qir.v1
• ID di destinazione: rigetti.sim.qvm
• Profilo di esecuzione di destinazione: QIR Base
• Prezzi: gratuito ($ 0)

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 sta per 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 lavori conformi a Quantum Intermediate Representation (QIR) con il profilo QIR Base 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? Dipende dal tuo 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 specifiche 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 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

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_3,  # 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}")