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

Targets

O seguinte targets está disponível neste provedor:

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.

Verificadores de sintaxe

Recomendamos que os usuários primeiro usem um Verificador de Sintaxe para validar seu código. Os verificadores de sintaxe verificam 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 H2-1 usa o mesmo compilador que H2-1. A stack de compilação completa é executada, exceto pelas operações quânticas reais. Se o código compilasse, o verificador de sintaxe retornaria um status success e um resultado composto por todos 0s. Se o código não compilar, o verificador de sintaxe retornará um status de falha e fornecerá uma mensagem de erro para ajudar os usuários a depurar a sintaxe do 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 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.

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 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 H2. A simulação quântica realizada é a mesma do emulador de modelo de sistema H2 , 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.

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 H2

Detalhes técnicos para o Modelo de Sistema H2 podem ser encontrados nas fichas técnicas de produto da Quantinuum na página 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.

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 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 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, página Portas ZZ de ângulo parametrizado no Quantinuum Docs.

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

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 General SU(4) Entangler em sistemas Quantinuum, consulte a página Portões SU(4) de Â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 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 a página Emuladores Quantinuum em documentos 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 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 os passos de compilação TKET e ver quais otimizações se aplicariam aos seus circuitos antes de submeter 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 de option_params. Por exemplo, "no-opt": True.

Para obter mais informações sobre pytket, consulte as seguintes ligações.

• pytket
• pytket Manual do Utilizador

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 para o modelo de sistema H2 e os emuladores de modelo de sistema H2 podem ser encontrados na página Guia do Utilizador de Hardware, juntamente com a especificação Quantinuum e repositórios de dados de volume quântico e Como Citar 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á aceitando trabalhos, mas não os está a processar atualmente.
• 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.

Pricing

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

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

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.