Fornecedor do Rigetti

Dica

Os utilizadores pela primeira vez recebem automaticamente 500 USD (USD)Créditos do Azure Quantum gratuitos para utilização com cada fornecedor de hardware quântico participante. Se tiver consumido todos os créditos e precisar de mais, pode aplicar-se ao programa créditos do Azure Quantum.

Os processadores quânticos rigetti são máquinas universais de modelo de porta baseadas em qubits supercondutores ajustáveis. As funcionalidades do sistema e as características do dispositivo incluem capacidades de leitura melhoradas, uma aceleração nos tempos de processamento quântico, tempos de porta rápida para múltiplas famílias de portas de entrelaçamento, amostragem rápida através da reposição de registo ativa e controlo paramétrico.

• Publisher: Rigetti
• ID do Fornecedor: rigetti

O fornecedor rigetti disponibiliza o seguinte targets :

Nome do destino	ID de Destino	Número de qubits	Description
Máquina Virtual Quântica (QVM)	rigetti.sim.qvm	-	Simulador open source para programas Quil, Q#e Qiskit. Sem custos.
Ankaa-2	rigetti.qpu.ankaa-2	84 qubits	O processador quântico disponível mais potente do Rigetti.

Nota

Os simuladores e hardware targets rigetti não suportam programas Cirq.

Rigetti targets corresponde a um No Control Flow perfil. Para obter mais informações sobre este target perfil e as suas limitações, veja Compreender target os tipos de perfil no Azure Quantum.

Simuladores

A Máquina Virtual Quântica (QVM) é um simulador open source para o Quil. O rigetti.sim.qvmtarget aceita um programa Quil como texto e executa esse programa na QVM alojada na cloud, devolvendo resultados simulados.

• Tipo de Tarefa: Simulation
• Formatos de Dados: rigetti.quil.v1, rigetti.qir.v1
• ID de Destino: rigetti.sim.qvm
• Perfil de Execução de Destino: No Control Flow
• Preços: Gratuito ($0)

Computadores quânticos

Todas as QPUs disponíveis publicamente do Rigetti estão disponíveis através do Azure Quantum. Esta lista está sujeita a alterações sem aviso prévio.

Ankaa-2

Um processador multi-chip de 84 qubits que oferece uma melhoria de desempenho de 2,5X em vez de outras QPUs do Rigetti.

• Tipo de Tarefa: Quantum Program
• Formato de Dados: rigetti.quil.v1, rigetti.qir.v1
• ID de Destino: rigetti.qpu.ankaa-2
• Perfil de Execução de Destino: No Control Flow

Preços

Para ver o plano de faturação do Rigetti, veja Preços do Azure Quantum.

Formato de entrada

Todos os Rigetti targets aceitam atualmente dois formatos:

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

Todos targets também assumem o parâmetro de número inteiro opcional count para definir o número de capturas a executar. Se for 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 predefinição, os programas são compilados com quilc antes de serem executados. No entanto, o quilc não suporta as funcionalidades de controlo de nível de impulso (Quil-T), por isso, se quiser utilizar essas funcionalidades, tem de fornecer um programa Quil Nativo (também com Quil-T) como entrada e especificar o parâmetro skipQuilc: truede entrada .

Para facilitar a construção de um programa Quil, pode utilizar pyQuil juntamente com o pyquil-for-azure-quantum pacote. Sem este pacote, pyQuil pode ser utilizado para construir programas Quil, mas não para os submeter ao Azure Quantum.

QIR

Todo o hardware rigetti suporta a execução de Quantum Intermediate Representation trabalhos em conformidade (QIR) com o Perfil Base QIR, v1 como rigetti.qir.v1. A 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 idiomas e máquinas de alto nível. Por exemplo, pode submeter tarefas Q#, Quil ou Qiskit para hardware rigetti e o Azure Quantum processa automaticamente a entrada por si. Para obter mais informações, consulte Quantum Intermediate Representation.

Selecionar o formato de entrada correto

Deve utilizar o Quil ou outra linguagem compatível com QIR? Resume-se ao seu caso de utilização final. A QIR é mais acessível para muitos utilizadores, enquanto o Quil é hoje mais poderoso.

Se estiver a utilizar o Qiskit, q#, ou outro toolkit que suporte a geração de QIR e a sua aplicação funcionar no Rigetti targets através do Azure Quantum, a QIR é adequada para si! A 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 utilizadores de sistemas Rigetti a partir de qualquer plataforma, incluindo o Azure Quantum. Se quiser personalizar a decomposição das portas quânticas ou escrever programas ao nível do pulso, é recomendável trabalhar no Quil, uma vez que essas capacidades ainda não estão disponíveis através do QIR.

Exemplos

A forma mais fácil de submeter tarefas do Quil é através do pyquil-for-azure-quantum pacote, pois permite-lhe utilizar as ferramentas e a documentação da pyQuil biblioteca.

Também pode construir programas Quil manualmente e submetê-los diretamente com o azure-quantum pacote.

Utilizar pyquil-for-azure-quantum

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
# qc = get_qpu("Ankaa-2") for submitting to a QPU

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

Utilizar o SDK Python azure-quantum

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