Compartilhar via

Provedor de Quantinuum

  • Artigo

Dica

Ao criar um workspace do Azure Quantum, você recebe automaticamente US$ 500 gratuitos em Créditos do Azure Quantum para cada provedor de hardware quântico. Você pode usar os Créditos do Azure Quantum para enviar seus primeiros programas quânticos para hardware quântico real.

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

  • Distribuidor: Quantinuum
  • ID do provedor: quantinuum

Targets

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

nome de Target ID do Target Número de qubits Descrição
Verificador de sintaxe H1-1 quantinuum.sim.h1-1sc 20 qubits Use isso para validar os programas quânticos no compilador H1-1 antes do envio para hardware ou para os emuladores na plataforma da Quantinuum. Sem custo.
Verificador de sintaxe H2-1 quantinuum.sim.h2-1sc 56 qubits Use isso para validar programas quânticos em relação ao compilador H2-1 antes de enviar para hardware ou emuladores na plataforma da Quantinuum. Sem custo.
Emulador H1-1 quantinuum.sim.h1-1e 20 qubits Usa um modelo físico realista e um modelo de ruído do H1-1.
Emulador H2-1 quantinuum.sim.h2-1e 56/32 qubits Usa um modelo físico realista e um modelo de ruído de H2-1. A simulação de 56 qubits está disponível apenas como uma simulação de stabalizer
H1-1 quantinuum.qpu.h1-1 20 qubits O dispositivo de íons presos H1-1 da Quantinuum.
H2-1 quantinuum.qpu.h2-1 56 qubits Dispositivo de íons aprisionados H2-1 da Quantinuum.

Os targets Quantinuum correspondem a um QIR Adaptive RI perfil. 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 Quantinuum agora suportam circuitos híbridos targets integrados. Para obter mais informações sobre como enviar trabalhos híbridos integrados, consulte Computação híbrida integrada.

Para começar a usar o provedor Quantinuum no Azure Quantum, confira Introdução ao Q# e a um notebook do Azure Quantum.

Dica

Os trabalhos quânticos enviados em uma sessão têm acesso exclusivo ao hardware Quantinuum, desde que você enfileire os trabalhos dentro de um minuto um do outro. Depois disso, qualquer trabalho é aceito e tratado com a lógica padrão de enfileiramento e priorização. Para obter mais informações, consulte sessões no Azure Quantum.

Verificadores de sintaxe

Recomendamos que os usuários validem primeiro o código usando nosso verificador de sintaxe. Essa é uma ferramenta para verificar a sintaxe correta, a conclusão da compilação e a compatibilidade do computador. Os verificadores de sintaxe usam o mesmo compilador que o computador quântico que eles target. Por exemplo, o verificador de sintaxe H1-1 usa o mesmo compilador que H1-1. A pilha de compilação completa é executada com exceção das 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 de falha e fornecerá o erro retornado para ajudar os usuários a depurar 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
  • Target ID:
    • Verificador de sintaxe H1-1: quantinuum.sim.h1-1sc
    • Verificador de sintaxe H2-1: quantinuum.sim.h2-1sc
  • Target Perfil de execução: QIR Adaptive RI

O uso de verificadores de sintaxe é oferecido gratuitamente.

Emuladores de modelo de sistema H1

Depois de validar a sintaxe de seu código com um verificador de sintaxe, os usuários podem aproveitar os emuladores System Model H1 da Quantinuum, ferramentas de emulação que contêm um modelo físico detalhado e um modelo de ruído realista do hardware real do System Model H1. Os modelos de ruído são derivados de uma caracterização detalhada do hardware. Os emuladores do modelo de sistema H1 usam uma API idêntica para envio de trabalho que o hardware do modelo de sistema H1, permitindo uma transição perfeita da emulação para o hardware. Para ajudar a maximizar a produtividade e reduzir o tempo de desenvolvimento, os emuladores do modelo de sistema H1 estão disponíveis mesmo quando o hardware está offline.

Mais informações podem ser encontradas na Folha de dados do produto do emulador do modelo de sistema H1 encontrada na página Modelo de sistema H1.

  • Tipo de trabalho: Simulation
  • Formato dos dados: quantinuum.openqasm.v1
  • Target ID:
    • Emulador H1-1: quantinuum.sim.h1-1e
  • Target Perfil de execução: QIR Adaptive RI

O uso do emulador H1 do modelo do sistema é oferecido gratuitamente com uma assinatura de hardware. Para ver detalhes, confira Preços do Azure Quantum.

Emulador H-Series (baseado em nuvem)

O Emulador H-Series está disponível gratuitamente na página Código com o Azure Quantum no site do Azure Quantum, onde você pode escrever código Q# e enviar seus trabalhos para o Emulador Quantinuum H-Series sem uma conta do Azure. O Emulador H-Series é um emulador quântico baseado em vetor de estado 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 Modelo de Sistema H1. A simulação quântica realizada é a mesma do Emulador H1 do Modelo de Sistema, mas a rotina clássica de otimização de circuitos é reduzida para aumentar a taxa de transferência. O suporte para computação híbrida integrada está planejado para uma data futura.

Modelo de sistema H1

A geração de computadores quânticos System Model H1, alimentada pela Honeywell, é composta por um dispositivo de carga acoplada quântica (QCCD) com uma seção linear e atualmente inclui uma máquina targets: o H1-1. Os usuários são incentivados a testar a compatibilidade de seu código com o H1-1 enviando trabalhos para um verificador de sintaxe e um emulador do modelo de sistema H1 antes de enviá-los para as target máquinas.

A máquina Modelo de Sistema H1 é continuamente atualizada ao longo do ciclo de vida do produto. Os usuários recebem acesso aos hardwares mais atualizados, avançados e compatíveis disponíveis.

Mais informações podem ser encontradas na Folha de dados do produto Modelo de sistema H1 encontrada na página Modelo de sistema H1.

  • Tipo de trabalho: Quantum Program
  • Formato de dados: honeywell.openqasm.v1, honeywell.qir.v1
  • Target ID:
    • H1-1: quantinuum.qpu.h1-1
  • Target Perfil de execução: QIR Adaptive RI

Emulador H2 do modelo do sistema

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 do modelo de sistema H2 encontrada na página Modelo de sistema H2. O System Model H2 Emulator usa uma API idêntica para envio de trabalho que o hardware System Model H2, permitindo uma transição perfeita 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
  • Target ID:
    • Emulador H2-1: quantinuum.sim.h2-1e
  • Target Perfil de execução: QIR Adaptive RI

O uso do emulador H2 do modelo do sistema é 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 Modelo de Sistema H2 encontrada na página 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 um emulador System Model H2 antes de enviá-los para as target máquinas.

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
  • Target ID:
    • H2-1: quantinuum.qpu.h2-1
  • Target Perfil de execução: QIR Adaptive RI

Especificações técnicas do modelo do sistema H1 e H2

Os detalhes técnicos do Modelo de Sistema H1 e do Modelo de Sistema H2 podem ser encontrados nas folhas de dados de produtos da Quantinuum nas páginas Modelo de Sistema H1 e Modelo de Sistema 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.

Capacidade Descrição
Medição e reinicialização do circuito intermediário (MCMR) Meça qubits no meio de um circuito e reutilize-os
Portas ZZ de ângulo arbitrário Execute diretamente rotações de porta de ângulo arbitrário de 2 qubits
Parâmetros de ruído do emulador Experimente os parâmetros de ruído usados nos emuladores Quantinuum H-Series
Otimizações de TKET na pilha da série H Experimente ativar diferentes níveis de otimizações TKET na pilha H-Series

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 íons presos, 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 redefiniçã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 as folhas de dados do produto da série H nas páginas Modelo de sistema H1 e Modelo de sistema H2 .

Em Q#, a MResetZ função pode ser usada para medir um qubit e redefini-lo. Para obter mais informações sobre essa função, consulte MResetZ a documentação do Q#.

%%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];
}

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 quânticos e sequências de portas. Para obter informações sobre portas ZZ de ângulo arbitrário em sistemas Quantinuum, consulte as folhas de dados do produto da série H nas páginas Modelo do sistema H1 e Modelo do sistema H2 .

Em Q#, a porta ZZ de ângulo arbitrário é implementada com a Rzz operação.

%%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) {
        set resultArray w/= i <- M(qubits[i]);  
    }
    
    return resultArray;
}

Geral SU(4) Portão Emaranhado

O conjunto de portas nativas do Quantinuum inclui uma porta de emaranhamento SU(4) geral. Observe que os circuitos quânticos 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 de emaranhamento SU(4) geral se os usuários optarem por ela. Para obter informações sobre o Entangador SU(4) Geral em sistemas Quantinuum, consulte as folhas de dados do produto da série H nas páginas Modelo do Sistema H1 e Modelo do Sistema H2 .

Em Q#, a porta de emaranhamento General SU(4) é implementada por meio do perfil QIR do Quantinuum. Para usá-lo, defina uma função com um intrínseco personalizado que corresponda à assinatura do perfil QIR e use essa função dentro da SU4Example operação.

Para garantir que o circuito seja executado com a porta de emaranhamento General SU(4), passe as seguintes opções na pilha da Série H:

  • nativetq: Rxxyyzz para evitar o rebase para outros portões nativos.
  • noreduce: True para evitar otimizações adicionais do compilador (opcional).
%%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)
}

Agora compile a operação:

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

Conecte-se ao Azure Quantum, selecione o target computador e configure os parâmetros de ruído para o emulador:

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

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

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

Passe a noreduce opção ao enviar o trabalho:

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 as folhas de dados do produto do emulador da série H nas páginas Modelo do sistema H1 e Modelo do sistema H2 .

Primeiro, importe os pacotes necessários e inicie o perfil base:

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

Em seguida, defina a função.

%%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);
}

e compilar a operação:

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

Conecte-se ao Azure Quantum, selecione o target computador e configure os parâmetros de ruído para o emulador:

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

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

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the System Model H1 Emulator Product Data Sheet
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
    }
}

Passe as opções de ruído do emulador ao enviar o trabalho:

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

Para desativar o modelo de ruído do emulador, defina a error-model opção como False. Por padrão, isso é definido como True.

option_params = {
    "error-model": False 
}

Para usar o emulador do estabilizador, defina a simulator opção como stabilizer. Por padrão, isso é definido como state-vector.

option_params = {
    "simulator": "stabilizer" 
}

Compilação TKET na pilha H-Series

Os circuitos enviados aos sistemas Quantinuum H-Series, exceto para envios híbridos integrados, são executados automaticamente por meio de passagens de compilação TKET para hardware H-Series. Isso permite que os circuitos sejam otimizados automaticamente para sistemas da série H e funcionem 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 H-Series, o nível de otimização aplicado é definido com o tket-opt-level parâmetro. A configuração de compilação padrão para todos os circuitos enviados aos sistemas da série H é o nível de otimização 2.

Os usuários que gostariam de experimentar as passagens de compilação do TKET e ver quais otimizações seriam aplicadas a seus circuitos antes de enviar qualquer trabalho podem ver o notebook 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 option_paramsde . Por exemplo, "no-opt": True.

Para obter mais informações sobre pytketo , consulte os seguintes links:

Primeiro, importe os pacotes necessários e inicie o perfil base:

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

Em seguida, defina a função.

%%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);
}

e compilar a operação:

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

Conecte-se ao Azure Quantum, selecione o target computador e configure os parâmetros de ruído para o emulador:

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

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

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

Passe a opção de otimização ao enviar o trabalho:

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

Especificações técnicas

Os detalhes técnicos dos emuladores Modelo de Sistema H1 e H2 e Modelo de Sistema H1 e H2 podem ser encontrados nas folhas de dados de produtos da Quantinuum na página Modelo de Sistema H1 e Modelo de Sistema 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.

Target Disponibilidade

Os computadores quânticos do Quantinuum série H 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 targetindica sua capacidade atual de processar trabalhos. 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 está target offline, não aceitando novos envios de trabalho.

Para o computador targetsquântico Quantinuum, Disponível e Degradado correspondem a períodos comerciais, enquanto Indisponível corresponde a períodos de desenvolvimento em que a máquina está offline para atualizações.

As informações de status atuais podem ser recuperadas na guia Provedores de um espaço de trabalho no portal do Azure.

Preços

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 de QPU, H-System Quantum Credit (HQC), para trabalhos enviados a computadores quânticos Quantinuum, e HQCs de emulador (eHQCs) para trabalhos enviados a 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 $$

em que:

  • $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.

Observação

O custo total em HQCs inclui todas as portas e medições em quaisquer ramificações condicionais ou fluxos de controle. Isso pode ter um impacto maior nos empregos híbridos integrados.

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 suas cotas atuais, acesse a folha Créditos e cotas e selecione a guia Cotas do seu workspace no portal do Azure. Para obter mais informações, confira Cotas do Azure Quantum.

Observação

Se você estiver usando um plano de Créditos do Azure Quantum e não um plano de cobrança, as informações de cotas serão mapeadas para seus créditos alocados. Nesse caso, a cota lista o número total de créditos recebidos.