Fornecedor Rigetti

Os processadores quânticos Rigetti são máquinas universais, modelo gate, baseadas em qubits supercondutores ajustáveis. Os recursos do sistema e as características do dispositivo incluem recursos de leitura aprimorados, uma aceleração nos tempos de processamento quântico, tempos de porta rápidos para várias famílias de portas emaranhadas, amostragem rápida por meio de redefinição ativa de registro e controle paramétrico.

• Editora: Rigetti
• ID do fornecedor: rigetti

O provedor Rigetti disponibiliza o seguinte targets :

Os de targets Rigetti correspondem a um QIR Base perfil. Para obter mais informações sobre esse target perfil e suas limitações, consulte Noções básicas target sobre tipos de perfil no Azure Quantum.

Simuladores

A Máquina Virtual Quântica (QVM) é um simulador de código aberto para Quil. O rigetti.sim.qvmtarget aceita um programa Quil como texto e executa esse programa na QVM hospedado na nuvem, retornando resultados simulados.

• Tipo de trabalho: Simulation
• Formatos de dados: rigetti.quil.v1, rigetti.qir.v1
• Target Identificação: rigetti.sim.qvm
• Target Perfil de Execução: QIR Base
• Preços: Grátis ($0)

Preços

Para ver o plano de faturamento da Rigetti, visite Preços do Azure Quantum.

Formato de entrada

Atualmente, todos os Rigetti targets aceitam dois formatos:

• rigetti.quil.v1, que é o texto de um programa Quil .
• rigetti.qir.v1, que é o código de bits QIR.

Todos targets também usam o parâmetro inteiro opcional count para definir o número de disparos a serem executados. Se omitido, o programa só é executado uma vez.

Quil

Todos os Rigetti targets aceitam o rigetti.quil.v1 formato de entrada, que é o texto de um programa Quil , que significa Quantum Instruction Language. Por padrão, os programas são compilados usando quilc antes de serem executados. No entanto, o quilc não suporta os recursos de controle de nível de pulso (Quil-T), portanto, se você quiser usar esses recursos, você deve fornecer um programa Quil nativo (também contendo Quil-T) como entrada e especificar o parâmetro skipQuilc: truede entrada.

Para facilitar a construção de um programa Quil, você pode usar pyQuil junto com o pyquil-for-azure-quantum pacote. Sem este pacote, pyQuil pode ser usado para construir programas Quil, mas não para enviá-los para o Azure Quantum.

QIR

Todo o hardware Rigetti suporta a execução de Quantum Intermediate Representation trabalhos compatíveis com (QIR) com o QIR Base Perfil, v1 como rigetti.qir.v1. O QIR fornece uma interface comum que suporta muitas linguagens e target plataformas quânticas para computação quântica e permite a comunicação entre linguagens e máquinas de alto nível. Por exemplo, você pode enviar trabalhos Q#, Quil ou Qiskit para hardware Rigetti, e o Azure Quantum manipula automaticamente a entrada para você. Para obter mais informações, veja Quantum Intermediate Representation.

Selecionando o formato de entrada correto

Você deve usar Quil ou outra linguagem compatível com QIR? Tudo se resume ao seu caso de uso final. QIR é mais acessível para muitos usuários, enquanto Quil é mais poderoso hoje.

Se você estiver usando Qiskit, Q# ou outro kit de ferramentas que ofereça suporte à geração de QIR, e seu aplicativo funcionar no Rigetti targets via Azure Quantum, o QIR é ideal para você! QIR tem uma especificação em rápida evolução, e Rigetti continua a aumentar o suporte para programas QIR mais avançados à medida que o tempo passa - o que não pode ser compilado hoje pode muito bem compilar amanhã.

Por outro lado, os programas Quil expressam o conjunto completo de funcionalidades disponíveis para os usuários de sistemas Rigetti de qualquer plataforma, incluindo o Azure Quantum. Se você está procurando personalizar a decomposição de seus portões quânticos ou escrever programas no nível de pulso, então você vai querer trabalhar em Quil, porque esses recursos ainda não estão disponíveis através do QIR.

Exemplos

A maneira mais fácil de enviar trabalhos Quil é usando o pyquil-for-azure-quantum pacote, pois ele permite que você use as ferramentas e a pyQuil documentação da biblioteca.

Você também pode construir programas Quil manualmente e enviá-los usando o azure-quantum pacote diretamente.

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