Rigetti-provider

Tip

Voor het eerst ontvangen gebruikers automatisch USD500 gratis Azure Quantum-tegoed voor gebruik bij elke deelnemende kwantumhardwareprovider. Als u alle tegoeden hebt verbruikt en u meer nodig hebt, kunt u van toepassing zijn op het Azure Quantum Credits-programma.

Rigetti-kwantumprocessors zijn universele, gate-modelmachines op basis van niet-supergeleidende qubits. Systeemfuncties en apparaatkenmerken omvatten verbeterde leesmogelijkheden, een versnelling in kwantumverwerkingstijden, snelle poorttijden voor meerdere verstrengelingspoortfamilies, snelle steekproeven via actieve registerherstel en parametrische controle.

• Uitgever: Rigetti
• Provider-id: rigetti

De Rigetti-provider maakt het volgende targets beschikbaar:

Doelnaam	Doel-id	Aantal qubits	Beschrijving
Kwantum-VM (QVM)	rigetti.sim.qvm	-	Opensource-simulator voor Quil-, Q#- en Qiskit-programma's. Gratis.
Ankaa-2	rigetti.qpu.ankaa-2	84 qubits	Rigetti's krachtigste beschikbare kwantumprocessor.

Notitie

Rigetti simulators en hardware targets bieden geen ondersteuning voor Cirq-programma's.

Rigetti komt targets overeen met een QIR Base profiel. Zie Profieltypen in Azure Quantum voor target meer informatie over dit target profiel en de beperkingen ervan.

Simulators

De Quantum Virtual Machine (QVM) is een opensource-simulator voor Quil. Het rigetti.sim.qvmtarget accepteert een Quil-programma als tekst en voert dat programma uit op QVM die wordt gehost in de cloud, waardoor gesimuleerde resultaten worden geretourneerd.

• Taaktype: Simulation
• Gegevensindelingen: rigetti.quil.v1, rigetti.qir.v1
• Doel-id: rigetti.sim.qvm
• Doeluitvoeringsprofiel: QIR Base
• Prijzen: Gratis ($ 0)

Kwantumcomputers

Alle openbaar beschikbare QPU's van Rigetti zijn beschikbaar via Azure Quantum. Deze lijst kan zonder voorafgaande kennisgeving worden gewijzigd.

Ankaa-2

Een multi-chip 84-qubit processor biedt een prestatieverbetering van 2,5X ten opzichte van andere Rigetti QPUs.

• Taaktype: Quantum Program
• Gegevensindeling: rigetti.quil.v1, rigetti.qir.v1
• Doel-id: rigetti.qpu.ankaa-2
• Doeluitvoeringsprofiel: QIR Base

Prijzen

Als u het factureringsplan van Rigetti wilt zien, gaat u naar de prijzen van Azure Quantum.

Invoerindeling

Alle Rigetti targets accepteren momenteel twee indelingen:

• rigetti.quil.v1, dat is de tekst van een Quil-programma .
• rigetti.qir.v1, wat QIR-bitcode is.

Alle targets nemen ook de optionele count integerparameter voor het definiëren van het aantal schermafbeeldingen dat moet worden uitgevoerd. Als u dit weglaat, wordt het programma slechts eenmaal uitgevoerd.

Quil

Alle Rigetti targets accepteren de rigetti.quil.v1 invoerindeling, de tekst van een Quil-programma , dat staat voor Quantum Instruction Language. Standaard worden programma's gecompileerd met quilc voordat ze worden uitgevoerd. Quilc biedt echter geen ondersteuning voor de pulsniveaubesturingsfuncties (Quil-T), dus als u deze functies wilt gebruiken, moet u een Systeemeigen Quil-programma (ook met Quil-T) als invoer opgeven en de invoerparameter skipQuilc: trueopgeven.

Als u het bouwen van een Quil-programma eenvoudiger wilt maken, kunt u dit samen met het pyquil-for-azure-quantum pakket gebruikenpyQuil. Zonder dit pakket kunt u Quil-programma's maken, pyQuil maar niet verzenden naar Azure Quantum.

QIR

Alle Rigetti-hardware ondersteunt de uitvoering van Quantum Intermediate Representation (QIR)-compatibele taken met het QIR Base profiel, v1 als rigetti.qir.v1. QIR biedt een algemene interface die ondersteuning biedt voor veel kwantumtalen en target -platforms voor kwantumberekeningen en maakt communicatie mogelijk tussen talen en computers op hoog niveau. U kunt bijvoorbeeld Q#-, Quil- of Qiskit-taken verzenden naar Rigetti-hardware en Azure Quantum verwerkt automatisch de invoer voor u. Zie Quantum Intermediate Representation voor meer informatie.

De juiste invoerindeling selecteren

Moet u Quil of een andere QIR-compatibele taal gebruiken? Het komt neer op uw end use case. QIR is toegankelijker voor veel gebruikers, terwijl Quil tegenwoordig krachtiger is.

Als u Qiskit, Q# of een andere toolkit gebruikt die QIR-generatie ondersteunt en uw toepassing werkt op Rigetti targets via Azure Quantum, is QIR geschikt voor u. QIR heeft een snel veranderende specificatie en Rigetti blijft de ondersteuning voor geavanceerdere QIR-programma's verhogen naarmate de tijd verstrijkt- wat vandaag niet vandaag kan worden gecompileerd, kan morgen goed worden gecompileerd.

Aan de andere kant tonen Quil-programma's de volledige set functionaliteiten die beschikbaar zijn voor gebruikers van Rigetti-systemen vanaf elk platform, waaronder Azure Quantum. Als u de ontleding van uw kwantumpoorten wilt aanpassen of programma's wilt schrijven op pulseniveau, wilt u werken in Quil, omdat deze mogelijkheden nog niet beschikbaar zijn via QIR.

Voorbeelden

De eenvoudigste manier om Quil-taken in te dienen, is door het pyquil-for-azure-quantum pakket te gebruiken, omdat u hiermee de hulpprogramma's en documentatie van de pyQuil bibliotheek kunt gebruiken.

U kunt Quil-programma's ook handmatig maken en verzenden met behulp van het azure-quantum pakket rechtstreeks.

Pyquil-for-azure-quantum gebruiken

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

Azure-quantum Python SDK gebruiken

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