Fornecedor do IonQ

Os computadores quânticos da IonQ realizam cálculos manipulando os estados de energia hiperfina dos íons Ytterbium 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 computador quântico de íons presos da IonQ.

• Editora: IonQ
• ID do fornecedor: ionq

O seguinte targets está disponível neste provedor:

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

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
• Target Identificação: ionq.simulator
• Target Perfil de Execução: 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
• Target ID: ionq.qpu.aria-1, ionq.qpu.aria-2
• Target Perfil de Execução: 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.

O IonQ Aria está disponível através do plano Azure Quantum Credits e de um plano de faturação separado. 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 de maior desempenho e disponível comercialmente da IonQ. Com um sistema configurável por software de 32 qubits, o IonQ Forte está disponível na Pré-visualização Privada no Azure Quantum. Para obter mais informações, consulte IonQ Forte (ionq.com).

• Tipo de trabalho: Quantum Program
• Formato dos dados: ionq.circuit.v1
• Target Identificação: ionq.qpu.forte
• Target Perfil de Execução: 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.

Os IonQ correspondem targets 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 para uma foto. 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 ao enviar trabalhos para hardware IonQ. A mitigação de erros é um processo no nível do compilador que executa e executa várias variações simétricas de um circuito e, em seguida, agrega os resultados enquanto reduz o impacto de erros de hardware e decoerência de qubit. 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 porta e qubit.

Debiasing é o processo de criar pequenas variações de um determinado circuito que deve ser idêntico em uma máquina ideal sem ruído, usando técnicas como diferentes atribuições de qubit, decomposições de porta e soluções de pulso, e então 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:

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

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 = azure.quantum.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 elas mapeiam o circuito para aquelas 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 trabalhos 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, e conhecer as características de ruído do seu target sistema pode ajudá-lo a refinar seus algoritmos e obter uma previsão mais realista dos resultados ao executar o circuito no hardware. 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 do tiro

A simulação de modelo de ruído reconhece tiros, ou seja, coleta amostras de medições 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 ideal modelo de ruído 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 aria-1 modelo de target ruído.

Habilitando a 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
    }
}

Executando 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 cotas IonQ são rastreadas com base na unidade de uso QPU, que é qubit-gate-shot (QGS). A utilização do recurso é creditada na sua conta.

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

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

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.

Estado IonQ

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

Gráfico de práticas recomendadas e conectividade IonQ

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