Provedor Quantinuum

O Quantinuum fornece acesso a sistemas de íons presos com alta fidelidade, qubits totalmente conectados e a capacidade de executar medida de meio-circuito.

• Publicador: Quantinuum
• ID do provedor: quantinuum

Targets

Os seguintes targets itens estão disponíveis neste provedor:

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

Todos os targets do Quantinuum agora fornecem suporte aos circuitos híbridos integrados. Para obter mais informações sobre como enviar trabalhos híbridos integrados, consulte Computação híbrida integrada.

Verificadores de sintaxe

Recomendamos que os usuários usem primeiro um Verificador de Sintaxe para validar seu código. Verificadores de sintaxe verificam a sintaxe adequada, a conclusão da compilação e a compatibilidade do computador. Verificadores de sintaxe usam o compilador do mesmo computador quântico que eles target. Por exemplo, o verificador de sintaxe H2-1 usa o mesmo compilador que H2-1. A pilha de compilação completa é executada, exceto pelas operações quânticas reais. Se o código for compilado, o verificador de sintaxe retornará um success status e um resultado de todos os 0s. Se o código não for compilado, o verificador de sintaxe retornará um status com falha e fornecerá uma mensagem de erro para ajudar os usuários a depurarem a sintaxe do circuito. Os verificadores de sintaxe permitem que os desenvolvedores validem seus códigos a qualquer momento, mesmo quando o computador está offline.

• Tipo de trabalho: Simulation
• Formatos de dados: honeywell.openqasm.v1, honeywell.qir.v1
• ID de destino:
  • Verificador de sintaxe H2-1: quantinuum.sim.h2-1sc
  • Verificador de sintaxe H2-2: quantinuum.sim.h2-2sc
• Perfil de execução de destino: QIR Adaptive RI

O uso de verificadores de sintaxe é oferecido gratuitamente.

Emulador Quantinuum (baseado em nuvem)

O Emulador Quantinuum está disponível gratuitamente na página Code com Azure Quantum no site do Azure Quantum, onde você pode escrever código Q# e enviar seus trabalhos para o Emulador Quantinuum sem uma conta do Azure. O Emulador de Quantinuum é um emulador quântico baseado em statevector que usa um modelo de ruído físico realista e parâmetros de erro generalizados com base no desempenho típico de um computador quântico do System Model H2. A simulação quântica executada é a mesma do Emulador do System Model H2, mas a rotina de otimização de circuito clássico é reduzida para aumentar a taxa de transferência. O suporte para computação híbrida integrada está planejado para uma data futura.

Emulador do Modelo de Sistema H2

Depois de validar a sintaxe de seu código com o H2-1 Syntax Checker, os usuários podem aproveitar as vantagens do System Model H2 Emulator da Quantinuum, uma ferramenta de emulação que contém um modelo físico detalhado e um modelo de ruído realista do hardware real do System Model H2. Mais informações sobre o modelo de ruído podem ser encontradas na Folha de Dados do Produto do Emulador de Modelo de Sistema H2 encontrada na página Modelo de Sistema H2. O Emulador System Model H2 utiliza uma API idêntica à do hardware System Model H2 para submissão de trabalhos, permitindo uma transição sem problemas da emulação para o hardware. Para ajudar a maximizar a produtividade e reduzir o tempo de desenvolvimento, o H2 Emulator está disponível mesmo quando o hardware está offline.

• Tipo de trabalho: Simulation
• Formato dos dados: quantinuum.openqasm.v1
• ID de destino:
  • Emulador H2-1: quantinuum.sim.h2-1e
  • Emulador H2-2: quantinuum.sim.h2-2e
• Perfil de execução de destino: QIR Adaptive RI

O uso do Emulador Modelo de Sistema H2 é oferecido gratuitamente com uma assinatura de hardware. Para ver detalhes, confira Preços do Azure Quantum.

Modelo do sistema H2

A geração de computadores quânticos Quantinuum System Model H2, alimentada pela Honeywell, é composta por um dispositivo de carga acoplada Quantum (QCCD) com duas seções lineares conectadas e atualmente possui 1 máquina, a H2-1. Mais informações podem ser encontradas na Folha de Dados do Produto do Modelo de Sistema H2 disponível na página do Modelo de Sistema H2. Os usuários são incentivados a testar a compatibilidade de seu código enviando trabalhos para um verificador de sintaxe e emulador do System Model H2 antes de enviá-los para os target computadores.

Se um usuário enviar um trabalho para a máquina H2-1 e a máquina H2-1 não estiver disponível, o trabalho permanecerá na fila dessa máquina até que a máquina fique disponível.

O hardware do modelo H2 do sistema é atualizado continuamente durante todo o ciclo de vida do produto. Os usuários recebem acesso aos hardwares mais atualizados, avançados e compatíveis disponíveis.

• Tipo de trabalho: Quantum Program
• Formato dos dados: quantinuum.openqasm.v1
• ID de destino:
  • H2-1: quantinuum.qpu.h2-1
  • H2-2: quantinuum.qpu.h2-2
• Perfil de execução de destino: QIR Adaptive RI

Especificações técnicas do modelo de sistema H2

Detalhes técnicos do System Model H2 podem ser encontrados nas folhas de dados do produto Quantinuum na página System Model H2 , juntamente com links para a especificação Quantinuum e repositórios de dados de volume quântico e como citar o uso de sistemas Quantinuum.

Recursos adicionais

Recursos adicionais disponíveis por meio da API Quantinuum estão listados aqui.

Os usuários podem aproveitar esses recursos adicionais por meio de funções de circuito ou parâmetros de passagem nos provedores Q# e Qiskit do Azure Quantum.

Medição e reinicialização do circuito intermediário

A medição e redefinição de circuito intermediário (MCMR) permite que os usuários meçam qubits no meio de um circuito e os redefinam. Isso permite a funcionalidade para correção de erros quânticos, bem como a capacidade de reutilizar qubits dentro do circuito.

Devido à estrutura de nível interno dos qubits de armadilhas de íons, uma medição de circuito intermediário pode deixar o qubit em um estado não computacional. Todas as medições de circuito intermediário devem ser seguidas por uma reinicialização se o qubit for usado novamente nesse circuito. Os exemplos de código a seguir demonstram isso.

Quando um subconjunto de qubits é medido no meio do circuito, as informações clássicas dessas medições podem ser usadas para condicionar elementos futuros do circuito. Os exemplos também destacam esse uso.

Para obter informações sobre MCMR em sistemas Quantinuum, consulte a página MCMR no Quantinuum Docs.

%%qsharp
import Std.Measurement.*;

operation ContinueComputationAfterReset() : Result[] {
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Perform Bell Test
    H(qubits[0]);
    CNOT(qubits[0], qubits[1]);

    // Measure Qubit 1 and reset it
    let res1 = MResetZ(qubits[1]);

    // Continue additional computation, conditioned on qubits[1] measurement outcome
    if res1 == One {
         X(qubits[0]);
    }
    CNOT(qubits[0], qubits[1]);

    // Measure qubits and return results
    let res2 = Measure([PauliZ, PauliZ], qubits);
    return [res1, res2];
}

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

# Set up quantum circuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.name = "MCMR Example with Conditional Logic"

# Perform Bell Test
circuit.h(q[0])
circuit.cx(q[0], q[1])

# Measure and reset Qubit 1
circuit.measure(q[1], c[1])
circuit.reset(q[1])

# Continue additional computation, conditioned on Qubit 1's measurement outcome
circuit.x(q[0]).c_if(c, 1)
circuit.cx(q[0], q[1])

# Measure all qubits
circuit.measure(q, c)

# Print out the circuit
circuit.draw()

Portas ZZ de ângulo arbitrário

O conjunto de portas nativas do Quantinuum inclui portas ZZ de ângulo arbitrário. Isso é benéfico para reduzir a contagem de portas de 2 qubits para muitos algoritmos de quantum e sequências de portas. Consulte a página Parameterized Angle ZZ Gates no Quantinuum Docs para obter informações sobre portões ZZ de Ângulo Arbitrário em sistemas Quantinuum.

%%qsharp
import Std.Intrinsic.*;
import Std.Measurement.*;
import Std.Arrays.*;

operation ArbitraryAngleZZExample(theta : Double) : Result[] {
    
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Create array for measurement results
    mutable resultArray = [Zero, size = 2];

    H(qubits[0]);
    Rz(theta, qubits[0]);
    Rz(theta, qubits[1]);
    X(qubits[1]);

    // Add Arbitrary Angle ZZ gate
    Rzz(theta, qubits[0], qubits[1]);  

    // Measure qubits and return results
    for i in IndexRange(qubits) {
        resultArray w/= i <- M(qubits[i]);  
    }
    
    return resultArray;
}

from qiskit import QuantumCircuit

theta = 0.25

# Set up quantum circuit
circuit = QuantumCircuit(2, 2)
circuit.name = "Arbitrary Angle ZZ Gate Example"

circuit.h(0)
circuit.rz(theta, 0)
circuit.rz(theta, 1)
circuit.x(1)

# Add arbitrary angle ZZ gate
circuit.rzz(theta, 0, 1)

circuit.measure_all()

Porta de Entrelaçamento Geral UA(4)

O conjunto de portas nativas do Quantinuum inclui uma porta de emaranhamento UA(4) geral. Observe que os circuitos de quantum enviados ao hardware são rebaseados na porta ZZ totalmente emaranhada e na porta RZZ de ângulo arbitrário. Os circuitos só são rebaseados para a porta UA(4) de emaranhamento geral se os usuários optarem por isso. Para obter informações sobre o SU(4) Entangler geral em sistemas Quantinuum, consulte a página Portões SU(4) com Ângulo Parametrizado no Quantinuum Docs.

%%qsharp
import Std.Math.*;

operation __quantum__qis__rxxyyzz__body(a1 : Double, a2 : Double, a3 : Double, q1 : Qubit, q2 : Qubit) : Unit {
    body intrinsic;
}

operation SU4Example() : Result[] {
    use qs = Qubit[2];
    
    // Add SU(4) gate
    __quantum__qis__rxxyyzz__body(PI(), PI(), PI(), qs[0], qs[1]);
    
    MResetEachZ(qs)
}

from qdk import qsharp

MyProgram = qsharp.compile("GenerateRandomBit()")

from qdk.azure import Workspace

MyWorkspace = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "nativetq": `Rxxyyzz`,
    "noreduce": True
}

job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()

Parâmetros de ruído do emulador

Os usuários têm a opção de experimentar os parâmetros de ruído dos emuladores Quantinuum. Apenas alguns dos parâmetros de ruído disponíveis são realçados aqui, demonstrando como passar pelos parâmetros nos provedores do Azure Quantum.

Para obter mais informações sobre o conjunto completo de parâmetros de ruído disponíveis, consulte a página Quantinuum Emulators em documentos do Quantinuum.

from qdk import qsharp
from qdk.azure import Workspace

qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulators page
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}

job = MyTarget.submit(MyProgram, "Experiment with Emulator Noise Parameters", 
                      shots = 10, 
                      input_params = option_params)
job.get_results()

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

# Specify the emulator backend target to submit to
backend = provider.get_backend("quantinuum.sim.h2-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the Quantinuum Emulator page
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

Compilação de TKET na pilha Quantinuum

Os circuitos enviados aos sistemas Quantinuum, exceto para envios híbridos integrados, são executados automaticamente por meio de passagens de compilação do TKET para hardware Quantinuum. Isso permite que os circuitos sejam otimizados automaticamente para sistemas Quantinuum e executados com mais eficiência.

Mais informações sobre os passos de compilação específicos aplicados podem ser encontrados na pytket-quantinuum documentação, especificamente na pytket-quantinuum seção Passos de compilação .

Na pilha de software Quantinuum, o nível de otimização aplicado é definido com o parâmetro tket-opt-level. A configuração da compilação padrão para todos os circuitos enviados aos sistemas Quantinuum é o nível de otimização 2.

Usuários que gostariam de experimentar os passes de compilação do TKET e verificar quais otimizações se aplicariam aos seus circuitos antes de enviar qualquer trabalho podem consultar o caderno de anotações Quantinuum_compile_without_api.ipynb na pytket-quantinuum pasta Exemplos.

Para desativar a compilação TKET na pilha, uma opção diferente, no-opt, pode ser definida como True dentro de option_params. Por exemplo, "no-opt": True.

Para obter mais informações sobe pytket, consulte os seguintes links:

• pytket
• pytket Manual do usuário

from qdk import qsharp
from qdk.azure import Workspace
qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}

job = MyTarget.submit(MyProgram, "Experiment with TKET Compilation", shots = 10, input_params = option_params)
job.get_results()

# Specify the backend target to submit to
backend = provider.get_backend("quantinuum.sim.h2-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

Especificações técnicas

Detalhes técnicos do Modelo de Sistema H2 e dos Emuladores do Modelo de Sistema H2 podem ser encontrados na página Guia do Usuário de Hardware, juntamente com a especificação Quantinuum, repositórios de dados de volume de quântico, e em Como citar os Sistemas Quantinuum.

Disponibilidade de destino

Os computadores quânticos do Quantinuum foram projetados para serem atualizados continuamente, o que permite que os clientes tenham acesso aos recursos de hardware mais recentes, pois o Quantinuum aprimora continuamente as fidelidades de portão, os erros de memória e a velocidade do sistema.

O hardware Quantinuum percorre períodos comerciais e períodos de desenvolvimento. Durante períodos comerciais, o hardware está disponível para processar trabalhos por meio de um sistema de filas. Durante os períodos de desenvolvimento, o hardware fica offline à medida que as atualizações são aplicadas.

Todos os meses, um calendário é enviado aos usuários do Quantinuum com informações sobre os períodos comerciais e de desenvolvimento. Se você não recebeu esse calendário, envie um email para QCsupport@quantinuum.com.

O status de A target indica sua capacidade atual de processar tarefas. Os estados possíveis de um target incluem:

• Disponível: o target está online, processando trabalhos enviados e aceitando novos.
• Degradado: o target está aceitando trabalhos, mas não os processando no momento.
• Indisponível: o target está offline, não aceitando novos envios de trabalho.

Para o computador targetsquântico Quantinuum, disponível e degradado corresponde a períodos comerciais, enquanto Não disponível corresponde a períodos de desenvolvimento em que o computador está offline para atualizações.

As informações de status atuais podem ser recuperadas da guia Provedores de um workspace no portal do Azure.

Pricing

Para ver os planos de cobrança do Quantinuum, visite os Preços do Azure Quantum.

Limites e cotas

As cotas do Quantinuum são rastreadas com base na unidade de crédito de uso do QPU, Crédito Quantum de Hardware (HQC), para trabalhos enviados aos computadores quânticos Quantinuum e HQCs de emulador (eHQCs) para trabalhos enviados aos emuladores.

Os HQCs e o eHQCs são usados para calcular o custo da execução de um trabalho e são calculados com base na seguinte fórmula:

$$ HQC = 5 + C(N_{1q} + 10 N_{2q} + 5 N_m)/5000 $$

where:

• $N_{1Q}$ é o número de operações de um qubit em um circuito.
• $N_{2Q}$ é o número de operações nativas de dois qubits em um circuito. O portão nativo é equivalente a CNOT até vários portões de um qubit.
• $N_{m}$ é o número de operações de preparação e medição de estado (SPAM) em um circuito, incluindo a preparação de estado implícita inicial e quaisquer medidas intermediárias e finais e redefinições de estado.
• $C$ é a contagem de captura.

As cotas são baseadas na seleção do plano e podem ser aumentadas com um tíquete de suporte. Para ver seus limites e cotas atuais, vá para a seção Operações e selecione a folha Cotas do seu workspace no portal do Azure. Para obter mais informações, confira Cotas do Azure Quantum.