Poskytovatel Rigetti

Kvantové procesory Rigetti jsou univerzální počítače s vrátným modelem založené na vyladěných superkondukčních qubitech. Mezi systémové funkce a charakteristiky zařízení patří vylepšené možnosti čtení, zrychlení v časech kvantového zpracování, rychlé doby bran pro více propletených rodin bran, rychlé vzorkování prostřednictvím aktivního resetování registru a parametrické řízení.

• Vydavatel: Rigetti
• ID zprostředkovatele: rigetti

Poskytovatel Rigetti zpřístupňuje následující targets :

Rigetti targets odpovídá QIR Base profilu. Další informace o tomto target profilu a jeho omezeních najdete v tématu Principy target typů profilů ve službě Azure Quantum.

Simulátory

Kvantový virtuální počítač (QVM) je opensourcový simulátor pro Quil. Akceptuje rigetti.sim.qvmtarget program Quil jako text a spustí tento program na QVM hostovaném v cloudu a vrátí simulované výsledky.

• Typ úlohy: Simulation
• Formáty dat: rigetti.quil.v1, rigetti.qir.v1
• Target ID: rigetti.sim.qvm
• Target Profil spuštění: QIR Base
• Ceny: Free (0 USD)

Ceny

Pokud chcete zobrazit fakturační plán Rigetti, navštivte ceny Azure Quantum.

Vstupní formát

Všechny Rigetti targets aktuálně přijímají dva formáty:

• rigetti.quil.v1, což je text programu Quil .
• rigetti.qir.v1, což je QIR bitcode.

Všechny targets také přebírají volitelný count celočíselnou parametr pro definování počtu snímků, které se mají spustit. Pokud tento parametr vynecháte, program se spustí jenom jednou.

Quil

Všechny Rigetti targets přijímají rigetti.quil.v1 vstupní formát, což je text programu Quil , který je zkratkou pro Quantum Instruction Language. Ve výchozím nastavení se programy před spuštěním kompilují pomocí nástroje quilc . quilc však nepodporuje funkce řízení na úrovni impulsu (Quil-T), takže pokud chcete tyto funkce použít, musíte jako vstup zadat nativní program Quil (také obsahující Quil-T) a zadat vstupní parametr skipQuilc: true.

Chcete-li zjednodušit vytváření programu Quil, můžete použít pyQuil společně s balíčkem pyquil-for-azure-quantum . Bez tohoto balíčku pyQuil je možné použít k vytváření programů Quil, ale ne k jejich odeslání do Azure Quantum.

QIR

Veškerý hardware Rigetti podporuje provádění úloh kompatibilních Quantum Intermediate Representation s technologií QIR s profilem QIR Base v1 jako rigetti.qir.v1. QIR poskytuje společné rozhraní, které podporuje mnoho kvantových jazyků a target platforem pro kvantové výpočty a umožňuje komunikaci mezi jazyky vysoké úrovně a počítači. Můžete například odeslat úlohy Q#, Quil nebo Qiskit do hardwaru Rigetti a Azure Quantum automaticky zpracuje vstup za vás. Další informace najdete na webu Quantum Intermediate Representation.

Výběr správného formátu vstupu

Měli byste použít Quil nebo jiný jazyk kompatibilní s QIR? Jde o váš případ koncového použití. QIR je pro mnoho uživatelů přístupnější, zatímco Quil je dnes výkonnější.

Pokud používáte Qiskit, Q# nebo jinou sadu nástrojů, která podporuje generování QIR, a vaše aplikace funguje na Rigetti targets přes Azure Quantum, je pro vás QIR nejvhodnější! QIR má rychle se vyvíjející specifikaci a Rigetti i nadále zvyšuje podporu pokročilejších programů QIR během časového časového limitu – to, co dnes nejde zkompilovat, může dobře zkompilovat zítra.

Na druhou stranu programy Quil vyjadřují úplnou sadu funkcí dostupných uživatelům systémů Rigetti z libovolné platformy, včetně Azure Quantum. Pokud chcete přizpůsobit rozklad kvantových bran nebo psát programy na úrovni impulsu, budete chtít pracovat v Quilu, protože tyto funkce ještě nejsou dostupné prostřednictvím QIR.

Příklady

Nejjednodušší způsob, jak odeslat úlohy Quil, je použít pyquil-for-azure-quantum balíček, protože umožňuje používat nástroje a dokumentaci pyQuil knihovny.

Programy Quil můžete také sestavit ručně a odeslat je přímo pomocí azure-quantum balíčku.

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