Partilhar via

Fornecedor Quantinuum

O Quantinuum fornece acesso a sistemas de íons presos com qubits de alta fidelidade e totalmente conectados e a capacidade de realizar medições no meio do circuito.

  • Editora: Quantinuum
  • ID do fornecedor: quantinuum

Objetivos

O seguinte targets está disponível neste provedor:

Nome do destino ID de destino Número de qubits Descrição
Verificador de sintaxe H1-1 quantinuum.sim.h1-1sc 20 qubits Use isso para validar programas quânticos em relação ao compilador H1-1 antes de enviar para hardware ou emuladores na plataforma da Quantinuum. Sem custos.
Verificador de sintaxe H2-1 quantinuum.sim.h2-1sc 56 qubits Use isso para validar programas quânticos contra o compilador H2-1 antes de enviar para hardware ou emuladores na plataforma da Quantinuum. Sem custos.
Verificador de sintaxe H2-2 quantinuum.sim.h2-2sc 56 qubits Use isso para validar programas quânticos contra o compilador H2-2 antes de enviar para hardware ou emuladores na plataforma da Quantinuum. Sem custos.
Emulador H1-1 quantinuum.sim.h1-1e 20 qubits Utiliza um modelo físico realista e um modelo de ruído de H1-1.
Emulador H2-1 quantinuum.sim.h2-1e 56/32 qubits Utiliza um modelo físico realista e um modelo de ruído de H2-1. A simulação de 56 qubits só está disponível como uma simulação de estabilizador
Emulador H2-2 quantinuum.sim.h2-2e 56/32 qubits Utiliza um modelo físico realista e um modelo de ruído de H2-2. A simulação de 56 qubits só está disponível como uma simulação de estabilizador
H1-1 quantinuum.qpu.h1-1 20 qubits Dispositivo de iões presos H1-1 da Quantinuum.
H2-1 quantinuum.qpu.h2-1 56 qubits Dispositivo de iões aprisionados H2-1 da Quantinuum.
H2-2 quantinuum.qpu.h2-1 56 qubits Dispositivo iónico aprisionado H2-2 da Quantinuum.

Os targets da Quantinuum 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 target sobre tipos de perfil no Azure Quantum.

Todos os targets da Quantinuum agora suportam circuitos híbridos 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, consulte Introdução ao Q# e a um bloco de anotações do Azure Quantum.

Gorjeta

As tarefas Quantum submetidas numa sessão têm acesso exclusivo ao hardware Quantinuum, desde que enfileire tarefas com um intervalo de um minuto entre elas. Depois disso, qualquer trabalho é aceito e tratado com a lógica padrão de fila e priorização. Para obter mais informações, consulte sessões no Azure Quantum.

Verificadores de sintaxe

Recomendamos que os usuários primeiro validem seu código usando um Verificador de Sintaxe. Esta é uma ferramenta para verificar a sintaxe adequada, a conclusão da compilação e a compatibilidade da máquina. Os verificadores de sintaxe usam o mesmo compilador que o computador quântico target. Por exemplo, o verificador de sintaxe H1-1 usa o mesmo compilador que H1-1. Com exceção das operações quânticas reais, a pilha de compilação completa é executada. Se o código for compilado, o verificador de sintaxe retornará um success status e um resultado composto apenas por 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 sua sintaxe de circuito. Os Verificadores de Sintaxe permitem que os desenvolvedores validem seu código a qualquer momento, mesmo quando as máquinas estão offline.

  • Tipo de trabalho: Simulation
  • Formatos de dados: honeywell.openqasm.v1, honeywell.qir.v1
  • ID de destino:
    • Verificador de sintaxe H1-1: quantinuum.sim.h1-1sc
    • 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 dos 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 de modelo de sistema H1 da Quantinuum, ferramentas de emulação que contêm um modelo físico detalhado e um modelo de ruído realista do hardware H1 do modelo de sistema real. Os modelos de ruído são derivados de uma caracterização detalhada do hardware. Os emuladores do Modelo do Sistema H1 usam uma API idêntica para a submissão de tarefas como o hardware do Modelo do Sistema H1, permitindo uma transição conveniente da emulação para o hardware. Para ajudar a maximizar a produtividade e reduzir o tempo de desenvolvimento, os emuladores H1 do modelo de sistema 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 do Modelo de Sistema H1.

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

O uso do emulador do System Model H1 é oferecido gratuitamente com uma assinatura de hardware. Para obter detalhes, consulte Preços do Azure Quantum.

Emulador Quantinuum (baseado em nuvem)

O Emulador Quantinuum está disponível gratuitamente na página Code with 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 Quantinuum Emulator é um emulador quântico baseado em vetor de estado que utiliza um modelo de ruído físico realista e parâmetros de erro generalizados, baseados no desempenho típico de um computador quântico do modelo de sistema H1 . A simulação quântica realizada é a mesma do emulador de modelo de sistema H1, 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, Powered by Honeywell, é composta por um dispositivo acoplado à carga quântica (QCCD) com uma seção linear e atualmente inclui uma máquina targets: a H1-1. Os usuários são encorajados a testar a compatibilidade de seu código com o H1-1 enviando trabalhos para um verificador de sintaxe e emulador de modelo de sistema H1 antes de enviá-los para as target máquinas.

A máquina do modelo de sistema H1 é continuamente atualizada durante todo o ciclo de vida do produto. Os usuários têm acesso ao hardware mais atualizado, avançado e capaz disponível.

Mais informações podem ser encontradas na Folha de Dados do Produto do Modelo de Sistema H1, disponível na página do Modelo de Sistema H1.

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

Emulador de modelo de sistema H2

Depois de validar a sintaxe de seu código com o Verificador de Sintaxe H2-1, os usuários podem aproveitar o 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 H2 do Modelo de Sistema real. Mais informações sobre o modelo de ruído podem ser encontradas na Folha de Dados do Produto do Emulador Modelo de Sistema H2 encontrada na página Modelo de Sistema H2. O Emulador do Modelo de Sistema H2 utiliza uma API idêntica para a submissão de trabalhos tal como o hardware do Modelo de Sistema 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 emulador H2 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 do Modelo de Sistema H2 é oferecido gratuitamente com uma assinatura de hardware. Para obter detalhes, consulte Preços do Azure Quantum.

Modelo de sistema H2

A geração de computadores quânticos Quantinuum System Model H2, Powered by Honeywell, é composta por um dispositivo acoplado à carga quântica (QCCD) com duas seções lineares conectadas e atualmente tem 1 máquina, a H2-1. Mais informações podem ser encontradas na Folha de dados do produto do 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 emulador de modelo de sistema 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 de sistema H2 é atualizado continuamente durante todo o ciclo de vida do produto. Os usuários têm acesso ao hardware mais atualizado, avançado e capaz disponível.

  • 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 H1 e H2

Os detalhes técnicos para o Modelo de Sistema H1 e o Modelo de Sistema H2 podem ser encontrados nas fichas técnicas de produto 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.

Capacidades adicionais

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

Capacidade Descrição
Medição e redefinição de meio-circuito (MCMR) Meça qubits no meio de um circuito e reutilize-os
Portões ZZ de ângulo arbitrário Execute diretamente rotações de portas de 2 qubits em ângulos arbitrários
Porta de Entrelaçamento Geral SU(4) Execute diretamente rotações de portas de 2 qubits em ângulos arbitrários
Parâmetros de ruído do emulador Experimente os parâmetros de ruído usados nos emuladores Quantinuum
otimizações TKET no Quantinuum Stack Experimente ativar os diferentes níveis de otimizações do TKET na pilha Quantinuum.

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

Medição e reinicialização no meio do circuito

A Medição e Redefinição no Meio do Circuito (MCMR) permite aos utilizadores medir qubits a meio de um circuito e redefini-los. 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íveis internos dos qubits de iões aprisionados, uma medição a meio do circuito pode deixar o qubit em um estado não computacional. Todas as medições no meio do circuito devem ser seguidas por um reset 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 futuros elementos do circuito. Os exemplos também destacam esse uso.

Para obter informações sobre MCMR em sistemas Quantinuum, consulte as fichas técnicas de produto de sistemas Quantinuum nas páginas System Model H1 e System Model 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 nativo da Quantinuum inclui portas do tipo ZZ com ângulos arbitrários. Isso é benéfico para reduzir o número de portas de 2 qubits em 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 fichas técnicas de produtos dos sistemas Quantinuum nas páginas System Model H1 e System Model H2.

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

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

Geral Porta de Emaranhamento SU(4)

O conjunto de portão nativo da Quantinuum inclui um portão geral de emaranhamento SU(4). Observe que os circuitos quânticos submetidos ao hardware são rebaseados para a porta ZZ totalmente entrelaçada e para a porta RZZ de ângulo arbitrário. Os circuitos são apenas adaptados para o General SU(4) Entangling gate se os utilizadores optarem por isso. Para obter informações sobre o Entangler General SU(4) em sistemas Quantinuum, consulte as fichas técnicas de produto dos sistemas Quantinuum nas páginas System Model H1 e System Model H2.

No Q#, o portão de emaranhamento General SU(4) é implementado através do perfil QIR da 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 operação SU4Example.

Para assegurar que o circuito funcione com a porta de emaranhamento General SU(4), passe as seguintes opções no sistema Quantinuum:

  • nativetq: Rxxyyzz para evitar a realocação 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 a target máquina 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 pela noreduce opção quando submeter a tarefa:

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 destacados 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 fichas técnicas de produto do emulador Quantinuum nas páginas System Model H1 e System Model 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 a target máquina 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 de estabilizador, defina a simulator opção como stabilizer. Por padrão, isso é definido como state-vector.

option_params = {
    "simulator": "stabilizer" 
}

Compilação TKET em Quantinuum Stack

Os circuitos submetidos aos sistemas Quantinuum, exceto para envios híbridos integrados, são processados automaticamente através de etapas de compilação do TKET para hardware Quantinuum. Isso permite que os circuitos sejam automaticamente otimizados para sistemas Quantinuum e funcionem de forma mais eficiente.

Mais informações sobre os passes de compilação específicos aplicados podem ser encontradas na pytket-quantinuum documentação, particularmente na seção pytket-quantinuum Passes de Compilação.

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

Os utilizadores que gostariam de experimentar as fases de compilação do TKET e ver quais otimizações se aplicariam aos seus circuitos antes de enviar quaisquer tarefas podem ver o caderno Quantinuum_compile_without_api.ipynb na pasta .

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 sobre pytket, consulte as seguintes ligações.

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 a target máquina 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 na 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 para os emuladores do Modelo de Sistema H1 e H2 e do Modelo de Sistema H1 e H2 podem ser encontrados nas fichas técnicas do produto 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.

Disponibilidade do alvo

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

O hardware Quantinuum passa por períodos comerciais e períodos de desenvolvimento. Durante os períodos comerciais, o hardware está disponível para processar trabalhos através de um sistema de fila. 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 da Quantinuum com informações sobre os períodos comerciais e de desenvolvimento. Se ainda não recebeu este calendário, por favor envie um e-mail para QCsupport@quantinuum.com.

O estado de A target indica a 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á a aceitar trabalhos, mas atualmente não os está a processar.
  • Indisponível: O target está 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 da guia Provedores de um espaço de trabalho no portal do Azure.

Preços

Para ver os planos de faturamento da Quantinuum, visite Preços do Azure Quantum.

Limites e quotas

As quotas da Quantinuum são rastreadas com base na unidade de crédito de uso de QPU, Crédito Quântico de Hardware (HQC) , para tarefas enviadas aos computadores quânticos da Quantinuum, e Créditos Quânticos de Simulador (eHQCs) para tarefas enviadas a simuladores.

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

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

onde:

  • $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. A porta nativa é equivalente ao CNOT com a adição de várias portas de um qubit.
  • $N_{m}$ é o número de operações de preparação e medição de estado (SPAM) em um circuito, incluindo preparação de estado implícito inicial e quaisquer medições intermediárias e finais e redefinições de estado.
  • $C$ é a contagem de tiros.

Nota

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

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