Fornecedor do IonQ

Os computadores quânticos da IonQ realizam cálculos manipulando os estados de energia hiperfina dos iões de itérbio com lasers. Os átomos são qubits da natureza – cada qubit é idêntico dentro e entre programas. As operações lógicas também podem ser executadas em qualquer par arbitrário de qubits, permitindo programas quânticos complexos sem serem impedidos pela conectividade física. Quer saber mais? Leia a visão geral da tecnologia de computação quântica de íons presos da IonQ.

• Editora: IonQ
• ID do fornecedor: ionq

O seguinte targets está disponível neste provedor:

Os targets IonQ correspondem a um perfil QIR Base. 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.

Simulador quântico

Simulador idealizado acelerado por GPU que suporta até 29 qubits, usando o mesmo conjunto de portas que a IonQ fornece em seu hardware quântico — um ótimo lugar para comprovar trabalhos antes de executá-los em um computador quântico real.

• Tipo de trabalho: Simulation
• Formato dos dados: ionq.circuit.v1
• ID de destino: ionq.simulator
• Perfil de execução de destino: QIR Base

Computador quântico IonQ Aria

O IonQ Aria é o carro-chefe dos computadores quânticos de íons presos da IonQ, com um sistema de 25 qubits dinamicamente reconfigurável. Para obter mais informações, consulte IonQ Aria (ionq.com).

• Tipo de trabalho: Quantum Program
• Formato dos dados: ionq.circuit.v1
• ID de destino: ionq.qpu.aria-1
• Perfil de execução de destino: QIR Base

Cronometragem do sistema

Fidelidade do sistema

* State Preparation and Measurement (SPAM): Esta medição determina com que precisão um computador quântico pode definir um qubit em seu estado inicial e, em seguida, medir o resultado no final.

IonQ Aria está disponível através do plano Pay As You Go. Para obter mais informações, consulte Preços do Azure Quantum.

Computador quântico IonQ Forte

O IonQ Forte é o computador quântico de íons armadilhados com o mais alto desempenho comercialmente disponível da IonQ. Com um sistema configurável por software de 36 qubits. Para obter mais informações, consulte IonQ Forte (ionq.com).

• Tipo de trabalho: Quantum Program
• Formato dos dados: ionq.circuit.v1
• ID de destino: ionq.qpu.forte-1
• Perfil de execução de destino: QIR Base

Computador quântico IonQ Forte Enterprise

O Forte Enterprise da IonQ é o computador quântico de íons aprisionados de maior desempenho, disponível comercialmente. Com um sistema configurável por software de 36 qubits. Para obter mais informações, consulte IonQ Forte Enterprise (ionq.com).

O Forte Enterprise é uma versão dos sistemas da classe Forte que foi adaptada e robusta para implantação em um ambiente de data center padrão, tornando-o mais adequado para tarefas de nível empresarial orientadas à produção. O hardware de computação quântica base e o desempenho são os mesmos. A principal diferença entre o IonQ Forte e o IonQ Forte Enterprise reside em sua implantação e casos de uso pretendidos, não em suas principais especificações de desempenho. Embora ambos os sistemas possuam as mesmas métricas de alto desempenho, o Forte Enterprise foi projetado especificamente para integração em um ambiente de data center.

• Tipo de trabalho: Quantum Program
• Formato dos dados: ionq.circuit.v1
• ID de destino: ionq.qpu.forte-enterprise-1
• Perfil de execução de destino: QIR Base

Formato de entrada

Em Q#, a saída de uma medida quântica é um valor do tipo Result, que só pode tomar os valores Zero e One. Quando você define uma operação Q#, ela só pode ser enviada ao hardware IonQ se o tipo de retorno for uma coleção de Results, ou seja, se a saída da operação for o resultado de uma medição quântica. A razão para isso é porque o IonQ cria um histograma a partir dos valores retornados, portanto, ele restringe o tipo de retorno para Result simplificar a criação desse histograma.

IonQ targets correspondem ao QIR Base profile. Este perfil não pode executar operações quânticas que exijam o uso dos resultados de medições de qubit para controlar o fluxo do programa.

Formato de saída

Quando você envia um programa quântico para o simulador IonQ, ele retorna o histograma criado pelas medições. O simulador IonQ não mostra a distribuição de probabilidade criada por um programa quântico, mas retorna a distribuição dimensionada para o número de disparos. Isso é mais evidente quando você envia um circuito de tiro único. Você verá vários resultados de medição no histograma numa única captura. Este comportamento é inerente ao simulador IonQ, enquanto IonQ QPU realmente executa o programa e agrega os resultados.

Capacidades adicionais

Recursos adicionais suportados pelo hardware IonQ estão listados aqui.

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

Atenuação de erros

O IonQ oferece a opção de habilitar a mitigação de erros quânticos quando você envia trabalhos para o hardware IonQ. A atenuação de erros é um processo ao nível do compilador que processa múltiplas variações simétricas de um circuito e, em seguida, agrega os resultados, ao mesmo tempo que reduz o impacto de erros de hardware e da descoerência dos qubits. Ao contrário das técnicas de correção de erros quânticos, a mitigação de erros não requer uma grande sobrecarga de portas e qubits.

Debiasing é o processo de criar pequenas variações de um determinado circuito, que numa máquina ideal sem ruído deveria ser idêntico, utilizando técnicas como diferentes atribuições de qubits, decomposições de portas e soluções de pulsos, e depois executar essas variações.

A nitidez e a média são opções para agregar os resultados das variações. A média é baseada igualmente em todos os resultados de variação, enquanto a nitidez filtra os resultados errados e pode ser mais confiável para certos tipos de algoritmos.

Para obter mais informações, consulte Debiasing and Sharpening. Para obter preços de mitigação de erros, consulte Preços IonQ.

Ativando a mitigação de erros

No Azure Quantum, a atenuação de erros pode ser habilitada ou desabilitada para trabalhos enviados com Q# ou com Qiskit.

Para habilitar a atenuação de erros, adicione um parâmetro opcional para a target máquina:

option_params = {
    "error-mitigation": {
        "debias": True
    }
}

Para desativar a atenuação de erros, defina o parâmetro como False:

option_params = {
    "error-mitigation": {
        "debias": False
    }
}

option_params = {
    "error-mitigation": {
        "debias": False
    },
    "noise": {
    "model": "aria-1",
    "seed": 100
    }
}

Executando um trabalho no Azure Quantum com mitigação de erros

Este exemplo usa um gerador de números aleatórios simples.

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

from qdk import qsharp
from qdk.azure import Workspace
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);
}

and compile the operation:

```python
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 = Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("ionq.qpu.aria-1")

Especificar a error-mitigation configuração

option_params = {
    "error-mitigation": {
        "debias": True
    }
}

Passe a configuração de mitigação de erros ao enviar o trabalho:

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

No Qiskit, você passa os parâmetros opcionais para a configuração da target máquina antes de enviar o trabalho:

circuit.name = "Single qubit random - Debias: True"
backend.options.update_options(**option_params)
job = backend.run(circuit, shots=500)

Suporte e uso de portões nativos

Por padrão, o IonQ permite especificar um circuito quântico usando um conjunto abstrato de portas quânticas, chamado qis, que permite flexibilidade e portabilidade ao escrever um algoritmo sem se preocupar com a otimização para o hardware.

No entanto, em alguns casos de uso avançado, você pode querer definir um circuito diretamente em portões nativos para estar mais próximo do hardware e ignorar a otimização. O conjunto de portas nativo é o conjunto de portas quânticas que são fisicamente executadas no processador quântico e que mapeiam o circuito para estas como parte da execução.

Para obter mais informações, consulte Introdução aos portões nativos (ionq.com).

Para usar o conjunto de portas nativo ao enviar trabalhos do Qiskit para o Azure Quantum, especifique o gateset parâmetro ao inicializar o back-end, como no exemplo abaixo:

# Here 'provider' is an instance of AzureQuantumProvider
backend = provider.get_backend("ionq.qpu.aria-1", gateset="native")

Para obter mais informações sobre tarefas do Qiskit, consulte Enviar um circuito com o Qiskit.

Simulação de modelo de ruído

Mesmo o melhor do hardware quântico atual tem ruído inerente. Conhecer as características de ruído do seu target sistema pode ajudá-lo a refinar os seus algoritmos e obter uma previsão mais realista dos resultados ao executar o circuito em hardware real. O IonQ fornece uma simulação de modelo de ruído que introduz ruído no circuito usando uma "impressão digital de ruído" específica para o target hardware. Para obter mais informações, consulte Introdução à simulação de modelo de ruído de hardware.

Parâmetros do modelo de ruído

Consciência de disparos

A simulação de modelos de ruído reconhece disparos; ou seja, ele coleta amostras do estado de saída com base no número de disparos fornecidos. No Azure Quantum, o shots parâmetro é enviado com o trabalho e é necessário para aria-1 modelos de ruído. Se nenhum shot valor for especificado, um valor padrão de 1000 será usado. Se o ideal modelo de ruído for usado, o shots parâmetro será ignorado.

Capacidade de Qubit

Enquanto o modelo de ruído ideal permite simular até 29 qubits com o simulador quântico IonQ, os modelos de ruído específicos do hardware são limitados à capacidade real de qubit do hardware, que é de 25 qubits para o modelo de ruído target.

Ativar simulação de modelo de ruído

No Azure Quantum, a simulação de modelo de ruído pode ser habilitada ou desabilitada para trabalhos enviados com Q# ou com Qiskit.

Para habilitar a simulação de modelo de ruído, adicione um parâmetro opcional para a target máquina, por exemplo:

option_params = {
    "noise": {
        "model": "aria-1",   # targets the Aria quantum computer
        "seed" : 1000         # If seed isn't specified, a random value is used  
    }
}

option_params = {
    "error-mitigation": {
        "debias": False
    },
    "noise": {
    "model": "aria-1",
    "seed": 1000
    }
}

Executar um trabalho com simulação de modelo de ruído

Você pode usar o mesmo programa de exemplo mostrado anteriormente na mitigação de erros e adicionar ou substituir a configuração do modelo de ruído em option_params;

option_params = {
    "error-mitigation": {
        "debias": True
    },
    "noise": {
    "model": "aria",
    "seed": 1000
    }
}

Em seguida, passe os parâmetros opcionais ao enviar o trabalho:

job = MyTarget.submit(MyProgram, "Experiment with noise model simulation", shots = 10, input_params = option_params)
job.get_results()

No Qiskit, você passa os parâmetros opcionais para a configuração da target máquina antes de enviar o trabalho:

circuit.name = "Single qubit random - Debias: True"
backend.options.update_options(**option_params)
job = backend.run(circuit, shots=500)

Preços

Para ver o plano de cobrança IonQ, visite Preços do Azure Quantum.

Limites e quotas

As quotas da IonQ são monitoradas com base na unidade de uso do QPU, que corresponde ao qubit-gate-shot (QGS). A utilização do recurso é creditada na sua conta.

Cada programa quântico consiste em $N$ portas lógicas quânticas de um ou mais qubits, e é executado por um certo número de execuções. O número de gate-shots é calculado pela fórmula seguinte:

$$ QGS = N · C $$

onde:

• $N$ é o número de portas de um ou dois qubits enviadas
• $C$ é o número de tiros de execução solicitados

Estado da IonQ

Para obter informações sobre atrasos no processamento de tarefas da IonQ QPU, consulte a página de status do IonQ.

Práticas recomendadas da IonQ e gráfico de conectividade

Para ver as práticas recomendadas para a QPU IonQ, consulte Práticas recomendadas IonQ (ionq.com).