Penyedia Rigetti

Prosesor kuantum Rigetti adalah mesin universal model gerbang berdasarkan kubit superkonduktor yang dapat disetel. Fitur sistem dan karakteristik perangkat termasuk kemampuan baca-baca yang ditingkatkan, kecepatan dalam waktu pemrosesan kuantum, waktu gerbang cepat untuk beberapa keluarga gerbang yang menjerat, pengambilan sampel cepat melalui pengaturan ulang register aktif, dan kontrol parametrik.

• Penerbit: Rigetti
• ID Penyedia: rigetti

Penyedia Rigetti menyediakan hal berikut targets :

Rigetti targets sesuai dengan QIR Base profil. Untuk informasi selengkapnya tentang profil ini target dan batasannya, lihat Memahami target jenis profil di Azure Quantum.

Komputer quantum

Semua QPU Rigetti yang tersedia untuk umum tersedia melalui Azure Quantum. Daftar ini dapat berubah tanpa pemberitahuan terlebih dahulu.

Ankaa-3

Prosesor kuantum 84 qubit.

• Jenis Pekerjaan: Quantum Program
• Format Data: rigetti.quil.v1, rigetti.qir.v1
• ID target: rigetti.qpu.ankaa-3
• Profil Eksekusi Target: QIR Base

Ankaa-9Q-3

Prosesor kuantum 9 qubit.

• Jenis Pekerjaan: Quantum Program
• Format Data: rigetti.quil.v1, rigetti.qir.v1
• ID target: rigetti.qpu.ankaa-9q-3
• Profil Eksekusi Target: QIR Base

Simulator

Quantum Virtual Machine (QVM) adalah simulator sumber terbuka untuk Quil. menerima rigetti.sim.qvmtargetprogram Quil sebagai teks dan menjalankan program tersebut di QVM yang dihosting di cloud, mengembalikan hasil yang disimulasikan.

• Jenis Pekerjaan: Simulation
• Format Data: rigetti.quil.v1, rigetti.qir.v1
• ID target: rigetti.sim.qvm
• Profil Eksekusi Target: QIR Base
• Harga: Gratis ($0)

Harga

Untuk melihat paket penagihan Rigetti, kunjungi Harga Azure Quantum.

Format input

Semua Rigetti targets saat ini menerima dua format:

• rigetti.quil.v1, yang merupakan teks dari program Quil .
• rigetti.qir.v1, yang merupakan kode bit QIR.

Semua targets juga mengambil parameter bilangan bulat opsional count untuk menentukan jumlah bidikan yang akan dijalankan. Jika dihilangkan, program hanya berjalan sekali.

Quil

Semua Rigetti targets menerima rigetti.quil.v1 format input, yang merupakan teks dari program Quil, yang merupakan singkatan dari Quantum Instruction Language. Secara default, program dikompilasi menggunakan quilc sebelum berjalan. Namun, quilc tidak mendukung fitur kontrol tingkat pulsa (Quil-T), jadi jika Anda ingin menggunakan fitur tersebut, Anda harus menyediakan program Native Quil (juga berisi Quil-T) sebagai input dan menentukan parameter skipQuilc: trueinput .

Untuk membuat pembuatan program Quil lebih mudah, Anda dapat menggunakan pyQuil bersama dengan pyquil-for-azure-quantum paket. Tanpa paket ini, pyQuil dapat digunakan untuk membuat program Quil tetapi tidak untuk mengirimkannya ke Azure Quantum.

QIR

Semua perangkat keras Rigetti mendukung eksekusi Quantum Intermediate Representation pekerjaan yang sesuai (QIR) dengan QIR Base Profil, v1 sebagai rigetti.qir.v1. QIR menyediakan antarmuka umum yang mendukung banyak bahasa dan target platform kuantum untuk komputasi kuantum dan memungkinkan komunikasi antara bahasa dan mesin tingkat tinggi. Misalnya, Anda dapat mengirimkan pekerjaan Q#, Quil, atau Qiskit ke perangkat keras Rigetti, dan Azure Quantum secara otomatis menangani input untuk Anda. Untuk informasi selengkapnya, lihat Quantum Intermediate Representation .

Memilih format input yang tepat

Haruskah Anda menggunakan Quil atau bahasa lain yang sesuai dengan QIR? Ini datang ke kasus penggunaan akhir Anda. QIR lebih mudah diakses oleh banyak pengguna, sementara Quil lebih kuat saat ini.

Jika Anda menggunakan Qiskit, Q#, atau toolkit lain yang mendukung generasi QIR, dan aplikasi Anda berfungsi di Rigetti targets melalui Azure Quantum, maka QIR tepat untuk Anda! QIR memiliki spesifikasi yang berkembang pesat, dan Rigetti terus meningkatkan dukungan untuk program QIR yang lebih canggih seiring berjalannya waktu - apa yang tidak dapat dikompilasi hari ini mungkin akan dikompilasi besok.

Di sisi lain, program Quil mengekspresikan serangkaian fungsionalitas lengkap yang tersedia untuk pengguna sistem Rigetti dari platform apa pun termasuk Azure Quantum. Jika Anda ingin menyesuaikan penguraian gerbang kuantum atau program tulis Anda di tingkat pulsa, maka Anda harus bekerja di Quil, karena kemampuan tersebut belum tersedia melalui QIR.

Contoh

Cara term mudah untuk mengirimkan pekerjaan Quil adalah menggunakan pyquil-for-azure-quantum paket, karena memungkinkan Anda untuk menggunakan alat dan dokumentasi pyQuil pustaka.

Anda juga dapat membuat program Quil secara manual dan mengirimkannya menggunakan paket secara azure-quantum langsung.

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