Rigetti-szolgáltató

A Rigetti kvantumprocesszorok univerzális, kapumodelles gépek, amelyek tonhalható szupravezető qubiteken alapulnak. A rendszerfunkciók és az eszköz jellemzői közé tartoznak a fokozott olvasási képességek, a kvantumfeldolgozási idők felgyorsítása, a több összefonódó kapucsalád gyors kapuideje, a gyors mintavételezés aktív regiszter alaphelyzetbe állítással és a parametrikus vezérléssel.

• Kiadó: Rigetti
• Szolgáltató azonosítója: rigetti

A Rigetti-szolgáltató a következőket targets teszi elérhetővé:

Célnév	Célazonosító	Qubitek száma	Leírás
Kvantum virtuális gép (QVM)	rigetti.sim.qvm	-	Nyílt forráskódú szimulátor Quil-, Q#- és Qiskit-programokhoz. Ingyenes.
Ankaa-3	rigetti.qpu.ankaa-3	84 qubit

Megjegyzés

A Rigetti-szimulátorok és a hardverek targets nem támogatják a Cirq-programokat.

Rigetti targets egy QIR Base profilnak felel meg. A profilról és annak korlátairól target további információt az Azure Quantum profiltípusainak ismertetése target című témakörben talál.

Kvantumszámítógépek

A Rigetti összes nyilvánosan elérhető QPU- az Azure Quantumon keresztül érhető el. A lista előzetes értesítés nélkül változhat.

Ankaa-3

Egy 84 qubites kvantumprocesszor.

• Feladat típusa: Quantum Program
• Adatformátum: rigetti.quil.v1, rigetti.qir.v1
• Célazonosító: rigetti.qpu.ankaa-3
• Célvégrehajtási profil: QIR Base

Szimulátorok

A Quantum Virtual Machine (QVM) a Quil nyílt forráskódú szimulátora. A rigetti.sim.qvmtarget Quil-programot szövegként fogadja el, és a programot a felhőben üzemeltetett QVM-en futtatja, szimulált eredményeket ad vissza.

• Feladat típusa: Simulation
• Adatformátumok: rigetti.quil.v1, rigetti.qir.v1
• Célazonosító: rigetti.sim.qvm
• Célvégrehajtási profil: QIR Base
• Díjszabás: Ingyenes (0 USD)

Díjszabás

A Rigetti számlázási csomagjának megtekintéséhez látogasson el az Azure Quantum díjszabására.

Bemeneti formátum

Az összes Rigetti targets jelenleg két formátumot fogad el:

• rigetti.quil.v1, amely egy Quil-program szövege.
• rigetti.qir.v1, amely a QIR-bitkód.

A targets mindegyike opcionálisan fogadhat egy count egész szám típusú paramétert, amely meghatározza a futtatandó felvételek számát. Ha nincs megadva, a program csak egyszer fut.

Quil

Minden Rigetti targets elfogadja a rigetti.quil.v1 bemeneti formátumot, amely egy Quil-program szövege, amely a Quantum Instruction Language nevet jelenti. Alapértelmezés szerint a programok a quilc használatával vannak lefordítva a futtatás előtt. A quilc azonban nem támogatja az impulzusszint-vezérlési funkciókat (Quil-T), ezért ha használni szeretné ezeket a funkciókat, meg kell adnia egy natív Quil-programot (amely a Quil-T-t is tartalmazza) bemenetként, és meg kell adnia a bemeneti paramétert skipQuilc: true.

A Quil-program létrehozásának megkönnyítése érdekében a csomaggal együtt használhatjapyQuil.pyquil-for-azure-quantum A csomag nélkül a pyQuil használható Quil programok létrehozására, de nem küldhetők el az Azure Quantumba.

QIR

Minden Rigetti hardver támogatja a Quantum Intermediate Representation(QIR) megfelelő feladatok végrehajtását, a QIR Base profil v1 formátumbanrigetti.qir.v1. A QIR egy közös felületet biztosít, amely számos kvantumnyelvet és target platformot támogat a kvantumszámításhoz, és lehetővé teszi a magas szintű nyelvek és gépek közötti kommunikációt. Beküldheti például a Q#, Quil vagy Qiskit feladatokat a Rigetti hardverbe, és az Azure Quantum automatikusan kezeli a bemenetet. További információ: Quantum Intermediate Representation.

A megfelelő bemeneti formátum kiválasztása

Használjon Quil-t vagy más QIR-kompatibilis nyelvet? Ez a végfelhasználási ügyön múlik. A QIR sok felhasználó számára elérhetőbb, míg a Quil ma még hatékonyabb.

Ha Qiskitet, Q#-ot vagy más olyan eszközkészletet használ, amely támogatja a QIR-generációt, és az alkalmazás az Azure Quantumon keresztül működik a Rigettien targets , akkor a QIR önnek megfelelő! A QIR gyorsan fejlődő specifikációval rendelkezik, és a Rigetti folyamatosan növeli a fejlettebb QIR-programok támogatását az idő múlásával – ami ma nem fordítható le, holnap már jól fordítható.

Másrészt a Quil-programok a Rigetti-rendszerek felhasználói számára elérhető funkciók teljes készletét fejezik ki bármely platformról, beleértve az Azure Quantumot is. Ha a kvantumkapuk felbontását szeretné testre szabni, vagy impulzusszinten szeretné írni a programokat, akkor érdemes a Quilben dolgoznia, mert ezek a képességek még nem érhetők el a QIR-en keresztül.

Példák

A Quil-feladatok elküldésének legegyszerűbb módja a pyquil-for-azure-quantum csomag használata, mivel lehetővé teszi a pyQuil kódtár eszközeinek és dokumentációjának használatát.

A Quil-programokat manuálisan is létrehozhatja, és közvetlenül a azure-quantum csomag használatával küldheti el őket.

Pyquil-for-azure-quantum használata

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

Az Azure-quantum Python SDK használata

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