Provedor Quantinuum

Gorjeta

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

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

Alvos

O seguinte targets está disponível neste provedor:

Nome do destino	ID de destino	Número de qubits	Description
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	32 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.
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	32 qubits	Utiliza um modelo físico realista e um modelo de ruído de H2-1.
H1-1	quantinuum.qpu.h1-1	20 qubits	Dispositivo de iões presos H1-1 da Quantinuum.
H2-1	quantinuum.qpu.h2-1	32 qubits	Dispositivo de iões aprisionados H2-1 da Quantinuum.

Os Quantinuum targets correspondem a um Basic Measurement Feedback 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.

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, consulte Introdução ao Q# e a um bloco de anotações do Azure Quantum.

Gorjeta

Os trabalhos Quantum enviados em uma sessão têm acesso exclusivo ao hardware Quantinuum, desde que você enfileire trabalhos dentro de um minuto um do outro. 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 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 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
• Perfil de Execução do Alvo: Feedback Básico de Medição

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 H1 do modelo de sistema usam uma API idêntica para o envio de trabalhos como o hardware H1 do modelo de sistema, 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 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 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: Basic Measurement Feedback

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 da série H (baseado na nuvem)

O Emulador da Série H 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 da Série H da Quantinuum sem uma conta do Azure. O emulador da série H é 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 System Model 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 encontrada na página 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: Basic Measurement Feedback

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 do modelo de sistema H2 encontrada na página Modelo de sistema H2. O emulador H2 do modelo de sistema usa uma API idêntica para o envio de trabalhos como o hardware H2 do modelo de sistema, 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
• Perfil de Execução do Alvo: Feedback Básico de Medição

O uso do emulador H2 do modelo de sistema é 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
• Perfil de Execução do Alvo: Feedback Básico de Medição

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	Description
Medição e reposição a médio do circuito (MCMR)	Meça qubits no meio de um circuito e reutilize-os
Portões ZZ de ângulo arbitrário	Execute diretamente rotações arbitrárias de porta angular 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 TKET na pilha da série H	Experimente ativar diferentes níveis de otimizações TKET na pilha da série H

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 reposição a meio do circuito

Mid-circuit Measurement and Reset (MCMR) permite aos usuários medir qubits no 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ível interno dos qubits de íons presos, uma medição de circuito médio 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 folhas de dados de produtos da série H nas páginas Modelo de sistema H1 e Modelo de sistema H2 .

MCMR com provedor Q#

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
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.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];
}

MCMR com Qiskit Provider

No Qiskit, os qubits são explicitamente medidos e redefinidos. As operações condicionais podem ser especificadas usando a c_if função após um portão.

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()

Portões ZZ de ângulo arbitrário

O conjunto de portas nativo da 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 de produtos da série H nas páginas Modelo de sistema H1 e Modelo de sistema H2 .

Portões ZZ de ângulo arbitrário com provedor Q#

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

%%qsharp
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Arrays;

operation ContinueComputationAfterReset(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;
}

Portões ZZ de ângulo arbitrário com provedor Qiskit

No Qiskit, a porta ZZ de ângulo arbitrário é implementada com o rzz método.

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()

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

Parâmetros de ruído do emulador com o provedor Q#

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
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Arrays;
open Microsoft.Quantum.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" 
}

Parâmetros de ruído do emulador com o provedor Qiskit

# Specify the emulator backend target to submit to
backend = provider.get_backend("quantinuum.sim.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
    }
}
backend.options.update_options(**option_params)

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

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 na pilha da série H

Os circuitos submetidos aos sistemas Quantinuum H-Series, exceto para envios híbridos integrados, são executados automaticamente através de passos de compilação TKET para hardware H-Series. Isso permite que os circuitos sejam automaticamente otimizados para sistemas da série H 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, especificamente na seção Passes de pytket-quantinuum compilação .

Na pilha de software da série H, 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 os passos de compilação TKET e ver quais otimizações se aplicariam aos seus circuitos antes de enviar qualquer trabalho podem ver o bloco de anotações Quantinuum_compile_without_api.ipynb na pytket-quantinuum pasta Exemplos.

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

• pytket
• pytket Manual do Utilizador

Compilação TKET com Q# Provider

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
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Arrays;
open Microsoft.Quantum.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()

Compilação TKET com Qiskit Provider

# Specify the backend target to submit to
backend = provider.get_backend("quantinuum.sim.h1-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

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 da série H da Quantinuum são projetados para serem atualizados continuamente, o que permite que os clientes tenham acesso aos recursos de hardware mais recentes, já que o Quantinuum melhora continuamente as fidelidades do portão, 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 QCsupport@quantinuum.compara .

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 empregos, mas não atualmente processando-os.
• 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 cotas da 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.

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. O portão nativo é equivalente ao 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 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 tíquete de suporte. Para ver seus limites e cotas atuais, vá para a folha Créditos e cotas e selecione a guia Cotas do seu espaço de trabalho no portal do Azure. Para obter mais informações, consulte Cotas do Azure Quantum.

Nota

Se estiver a utilizar um plano Azure Quantum Credits, e não um plano de faturação, as informações de quotas são mapeadas para os créditos atribuídos. Nesse caso, a cota lista o número total de créditos recebidos.