Dostawca Rigetti

Procesory kwantowe Rigetti to uniwersalne maszyny modelu bramkowego oparte na strojonym kubitom nadprzewodzącym. Funkcje systemu i cechy urządzeń obejmują ulepszone możliwości odczytu, przyspieszenie przetwarzania kwantowego, szybkie czasy bramowania dla wielu rodzin bram splątanych, szybkie próbkowanie dzięki aktywnemu resetowaniu rejestru i sterowanie parametryczne.

• Wydawca: Rigetti
• Identyfikator dostawcy: rigetti

Dostawca Rigetti udostępnia następujące targets informacje:

Rigetti odpowiada targets profilowi QIR Base . Aby uzyskać więcej informacji na temat tego target profilu i jego ograniczeń, zobacz Opis target typów profilów w usłudze Azure Quantum.

Komputery kwantowe

Wszystkie publicznie dostępne QPU Rigetti są dostępne za pośrednictwem usługi Azure Quantum. Ta lista może ulec zmianie bez wcześniejszego powiadomienia.

Ankaa-3

84-kubitowy procesor kwantowy.

• Typ zadania: Quantum Program
• Format danych: rigetti.quil.v1, rigetti.qir.v1
• Identyfikator docelowy: rigetti.qpu.ankaa-3
• Docelowy profil wykonywania: QIR Base

Cepheus-1-36Q

36-kubitowy procesor kwantowy zbudowany z uporządkowanej struktury mikroukładów 9-kubitowych, ułożonych razem.

• Typ zadania: Quantum Program
• Format danych: rigetti.quil.v1, rigetti.qir.v1
• Identyfikator docelowy: rigetti.qpu.cepheus-1-36q
• Docelowy profil wykonywania: QIR Base

Symulatory

Maszyna wirtualna Quantum (QVM) to otwartoźródłowy symulator dla Quil. Element rigetti.sim.qvmtarget akceptuje program Quil jako tekst i uruchamia ten program na maszynie QVM hostowanej w chmurze, zwracając symulowane wyniki.

• Typ zadania: Simulation
• Formaty danych: rigetti.quil.v1, rigetti.qir.v1
• Identyfikator docelowy: rigetti.sim.qvm
• Docelowy profil wykonywania: QIR Base
• Cennik: Bezpłatna ($0)

Cennik

Aby wyświetlić plan rozliczeniowy usługi Rigetti, odwiedź stronę Cennik usługi Azure Quantum.

Format danych wejściowych

Wszystkie Rigetti targets obecnie akceptują dwa formaty:

• rigetti.quil.v1, czyli tekst programu Quil .
• rigetti.qir.v1, czyli kod bitowy QIR.

Wszystkie targets przyjmują również opcjonalny count parametr liczby całkowitej służący do definiowania liczby uruchamianych zdjęć. W przypadku pominięcia program jest uruchamiany tylko raz.

Quil

Wszystkie Rigetti targets akceptują rigetti.quil.v1 format wejściowy, który jest tekstem programu Quil oznaczającego język instrukcji kwantowych. Domyślnie programy są kompilowane przy użyciu quilc przed uruchomieniem. Jednak quilc nie obsługuje funkcji sterowania poziomem pulsu (Quil-T), więc jeśli chcesz użyć tych funkcji, musisz podać natywnyprogram Quil (zawierający również Quil-T) jako dane wejściowe i określić parametr skipQuilc: truewejściowy .

Aby ułatwić konstruowanie programu Quil, możesz użyć pyQuil wraz z pakietem pyquil-for-azure-quantum. Bez tego pakietu pyQuil programów Quil, ale ich przesyłanie do usługi Azure Quantum nie jest możliwe.

QIR

Cały sprzęt Rigetti obsługuje wykonywanie zadań zgodnych z Quantum Intermediate Representation (QIR) przy użyciu profilu QIR Base w wersji 1 jako rigetti.qir.v1. QIR udostępnia wspólny interfejs, który obsługuje wiele języków kwantowych i target platform na potrzeby obliczeń kwantowych i umożliwia komunikację między językami wysokiego poziomu i maszynami. Możesz na przykład przesłać zadania języka Q#, Quil lub Qiskit do sprzętu Rigetti, a usługa Azure Quantum automatycznie obsługuje dane wejściowe. Aby uzyskać więcej informacji, zobacz Quantum Intermediate Representation.

Wybieranie odpowiedniego formatu wejściowego

Czy należy używać Quil lub innego języka zgodnego z językiem QIR? Sprowadza się to do tego, w jaki sposób zamierzasz to używać. QIR jest bardziej dostępny dla wielu użytkowników, podczas gdy Quil jest obecnie bardziej zaawansowany.

Jeśli używasz zestawu Qiskit, Q# lub innego zestawu narzędzi obsługującego generowanie QIR, a aplikacja działa na platformie Rigetti targets za pośrednictwem usługi Azure Quantum, technologia QIR jest odpowiednia dla Ciebie! QIR ma szybko rozwijającą się specyfikację, a Rigetti nadal zwiększa obsługę bardziej zaawansowanych programów QIR w miarę upływu czasu - czego nie można skompilować dzisiaj, może być skompilowane jutro.

Z drugiej strony programy Quil wyrażają pełny zestaw funkcji dostępnych dla użytkowników systemów Rigetti z dowolnej platformy, w tym Azure Quantum. Jeśli chcesz dostosować dekompozycję bram kwantowych lub pisać programy na poziomie impulsu, warto pracować w Quil, ponieważ te możliwości nie są jeszcze dostępne za pośrednictwem QIR.

Przykłady

Najprostszym sposobem przesyłania zadań Quil jest użycie pyquil-for-azure-quantum pakietu, ponieważ umożliwia korzystanie z narzędzi i dokumentacji pyQuil biblioteki.

Można również tworzyć programy Quil ręcznie i przesyłać je bezpośrednio przy użyciu azure-quantum pakietu.

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