Rigetti-leverantör

Dricks

Förstagångsanvändare får automatiskt 500 USD kostnadsfria Azure Quantum-krediter för användning med varje deltagande kvantmaskinvaruleverantör.

Rigetti kvantprocessorer är universella, gate-modell maskiner baserade på tunable superconducting qubits. Systemfunktioner och enhetsegenskaper omfattar förbättrade avläsningsfunktioner, snabbare kvantbearbetningstider, snabba grindtider för flera sammanflätade grindfamiljer, snabb sampling via aktiv registeråterställning och parametrisk kontroll.

• Utgivare: Rigetti
• Provider-ID: rigetti

Rigetti-providern gör följande targets tillgängligt:

Målnamn	Mål-ID	Antal kvantbitar	beskrivning
Virtuell kvantdator (QVM)	rigetti.sim.qvm	-	Simulator med öppen källkod för Quil-, Q#- och Qiskit-program. Kostnadsfritt.
Ankaa-2	rigetti.qpu.ankaa-2	84 kvantbitar	Rigettis mest kraftfulla tillgängliga kvantprocessor.

Kommentar

Rigetti-simulatorer och maskinvara targets stöder inte Cirq-program.

Rigetti motsvarar targets en QIR Base profil. Mer information om den här target profilen och dess begränsningar finns i Förstå target profiltyper i Azure Quantum.

Simulatorer

Quantum Virtual Machine (QVM) är en simulator med öppen källkod för Quil. Accepterar rigetti.sim.qvmtarget ett Quil-program som text och kör det programmet på QVM som finns i molnet och returnerar simulerade resultat.

• Jobbtyp: Simulation
• Dataformat: rigetti.quil.v1, rigetti.qir.v1
• Mål-ID: rigetti.sim.qvm
• Målkörningsprofil: QIR Base
• Priser: Kostnadsfri ($0)

Kvantdatorer

Alla Rigettis offentligt tillgängliga QPU:er är tillgängliga via Azure Quantum. Den här listan kan komma att ändras utan förvarning.

Ankaa-2

En 84-qubit-processor med flera chip som erbjuder en prestandaförbättring på 2,5 X jämfört med andra Rigetti QPU:er.

• Jobbtyp: Quantum Program
• Dataformat: rigetti.quil.v1, rigetti.qir.v1
• Mål-ID: rigetti.qpu.ankaa-2
• Målkörningsprofil: QIR Base

Prissättning

Om du vill se Rigettis faktureringsplan går du till Priser för Azure Quantum.

Indataformat

Alla Rigetti targets accepterar för närvarande två format:

• rigetti.quil.v1, som är texten i ett Quil-program .
• rigetti.qir.v1, som är QIR-bitkod.

Alla targets tar också den valfria heltalsparametern count för att definiera antalet skott som ska köras. Om det utelämnas körs programmet bara en gång.

Quil

Alla Rigetti targets accepterar rigetti.quil.v1 indataformatet, som är texten i ett Quil-program , som står för Quantum Instruction Language. Som standard kompileras program med quilc innan de körs. Quilc stöder dock inte funktionerna för pulsnivåkontroll (Quil-T), så om du vill använda dessa funktioner måste du ange ett internt Quil-program (som även innehåller Quil-T) som indata och ange indataparametern skipQuilc: true.

För att göra det enklare att skapa ett Quil-program kan du använda pyQuil tillsammans med pyquil-for-azure-quantum paketet. Utan det här paketet pyQuil kan användas för att skapa Quil-program men inte för att skicka dem till Azure Quantum.

QIR

All Rigetti-maskinvara stöder körning av Quantum Intermediate Representation (QIR) kompatibla jobb med profilen QIR Base , v1 som rigetti.qir.v1. QIR tillhandahåller ett gemensamt gränssnitt som stöder många kvantspråk och target plattformar för kvantberäkning och möjliggör kommunikation mellan högnivåspråk och datorer. Du kan till exempel skicka Q#-, Quil- eller Qiskit-jobb till Rigetti-maskinvara, och Azure Quantum hanterar automatiskt indata åt dig. Mer information finns i Quantum Intermediate Representation.

Välja rätt indataformat

Ska du använda Quil eller ett annat QIR-kompatibelt språk? Det handlar om ditt slutanvändningsfall. QIR är mer tillgängligt för många användare, medan Quil är kraftfullare idag.

Om du använder Qiskit, Q#eller en annan verktygslåda som stöder QIR-generering, och ditt program fungerar på Rigetti targets via Azure Quantum, är QIR rätt för dig! QIR har en snabbt växande specifikation, och Rigetti fortsätter att öka stödet för mer avancerade QIR-program när tiden går - det som inte kan kompileras idag kan mycket väl kompileras i morgon.

Å andra sidan uttrycker Quil-program hela uppsättningen funktioner som är tillgängliga för användare av Rigetti-system från valfri plattform, inklusive Azure Quantum. Om du vill skräddarsy nedbrytningen av dina kvantgrindar eller skriva program på pulsnivå vill du arbeta i Quil, eftersom dessa funktioner ännu inte är tillgängliga via QIR.

Exempel

Det enklaste sättet att skicka Quil-jobb är att använda pyquil-for-azure-quantum paketet, eftersom du kan använda bibliotekets pyQuil verktyg och dokumentation.

Du kan också skapa Quil-program manuellt och skicka dem direkt med paketet azure-quantum .

Använda pyquil-for-azure-quantum

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

Använda Azure-quantum Python SDK

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