Provedor IonQ

Os computadores quantum da IonQ executam cálculos manipulando com lasers, os estados de energia hiperfina dos íons de itérbio. Os átomos são qubits da natureza, cada qubit é idêntico dentro e entre os programas. Operações lógicas também podem ser executadas em qualquer par arbitrário de qubits, permitindo que programas quantum complexos não sejam prejudicados pela conectividade física. Quer saber mais? Leia a visão geral da tecnologia de computadores quantum de íons presos da IonQ.

• Editor: IonQ
• ID do provedor: ionq

Os seguintes targets itens estão disponíveis neste provedor:

Os IonQ targets correspondem a um QIR Base perfil. Para obter mais informações sobre esse target perfil e suas limitações, consulte Noções básicas sobre target tipos de perfil no Azure Quantum.

Simulador do Quantum

Simulador idealizado, acelerado por GPU, com suporte para até 29 qubits, usando o mesmo conjunto de portas que a IonQ fornece em seu hardware quantum. Uma ótima ferramenta para testar trabalhos antes de executá-los em um computador quantum real.

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

Computador quântico do IonQ Aria

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

• Tipo de trabalho: Quantum Program
• Formato dos dados: ionq.circuit.v1
• Target IDENTIFICAÇÃO: ionq.qpu.aria-1, ionq.qpu.aria-2
• Target Perfil de execução: QIR Base

Tempo do sistema

Fidelidade do sistema

* SPAM (Preparação e Medição de Estado): essa medida determina com que precisão um computador do quantum pode definir um qubit no estado inicial e, em seguida, medir o resultado no final.

O IonQ Aria está disponível por meio do plano de Créditos do Azure Quantum e de um plano de cobrança separado. Para obter mais informações, confira Preços do Azure Quantum.

Computador quântico IonQ Forte

O IonQ Forte é o computador quântico de íons presos 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 em 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 ID: ionq.qpu.forte
• Target Perfil de execução: QIR Base

Formato de entrada

Em Q#, a saída de uma medição quântica é um valor do tipo Result, que só pode usar os valores Zero e One. Quando você define uma operação Q#, ela só poderá 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 targets correspondem aos QIR Base profilearquivos . Esse perfil não pode executar operações quânticas que exigem o uso dos resultados de medições de qubit para controlar o fluxo do programa.

Formato da 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 faz uma amostra da distribuição de probabilidade criada por um programa quântico, mas retorna a distribuição dimensionada para o número de disparos. Isso é mais aparente quando você envia um circuito de disparo único. Você verá vários resultados de medição no histograma de uma foto. Esse comportamento é inerente ao simulador IonQ, enquanto o IonQ QPU realmente executa o programa e agrega os resultados.

Recursos 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 Q# e Qiskit do Azure Quantum.

Mitigação de erros

O IonQ oferece a opção de habilitar a mitigação de erros quânticos ao enviar trabalhos para o 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 mitiga o impacto de erros de hardware e decoerência de 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 porta e qubit.

A viés é o processo de criar pequenas variações de um determinado circuito que deve ser idêntico em uma máquina silenciosa ideal, usando técnicas como diferentes atribuições de qubits, decomposições de portas e soluções de pulso e, em seguida, executando essas variações.

Nitidez e 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 errôneos e pode ser mais confiável para certos tipos de algoritmos.

Para obter mais informações, consulte Remoção de viés e nitidez. Para obter preços de mitigação de erros, consulte Preços do IonQ.

Ativando a mitigação de erros

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

Para habilitar a mitigação de erros, adicione um parâmetro opcional para o target computador:

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

Para desativar a mitigaçã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 o target computador 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")

Especifique 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 máquina antes de target 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 que você especifique um circuito quantum usando um conjunto abstrato de portões quantum, chamado qis, que permite flexibilidade e portabilidade ao escrever um algoritmo sem se preocupar com a otimização do hardware.

No entanto, em alguns casos de uso avançado, talvez você queira definir um circuito diretamente em portões nativos para estar mais perto do hardware e ignorar a otimização. O conjunto de portões nativos é o conjunto de portões quantum que são executados fisicamente no processador quantum e mapeiam o circuito para aqueles como parte da execução.

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

Para usar o conjunto de portões nativo ao enviar trabalhos do Qiskit para o Azure Quantum, especifique o parâmetro gateset 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 de hoje 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 do modelo de ruído de hardware.

Parâmetros do modelo de ruído

Consciência do tiro

A simulação do modelo de ruído reconhece a tomada; ou seja, ela coleta amostras de medições do estado de saída com base no número de fotos fornecidas. 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

Embora o ideal modelo de ruído permita 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 qubits do hardware, que é de 25 qubits para o aria-1 modelo de target ruído.

Habilitando a simulação do modelo de ruído

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

Para habilitar a simulação do 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 em 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 máquina antes de target 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 do IonQ, visite os preços do Azure Quantum.

Limites e cotas

As cotas de IonQ são controladas com base na unidade de uso da QPU, que é QGS (qubit-gate-shot). O uso do recurso é creditado em sua conta.

Cada programa quântico consiste em portas lógicos quantum $N$ de um ou mais qubits e é executado para um determinado número de disparos. O número de disparos de porta é calculado pela seguinte fórmula:

$$ QGS = N · C $$

em que:

• O $N$ é o número de portas de um ou dois qubits enviados
• O $C$ é o número de disparos 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 suas cotas atuais, acesse a folha Créditos e cotas e selecione a guia Cotas do seu workspace no portal do Azure. Para obter mais informações, confira Cotas do Azure Quantum.

Status do IonQ

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

Melhores práticas e grafo de conectividade da IonQ

Para ver as melhores práticas para a QPU do IonQ, consulte as Melhores práticas do IonQ (ionq.com).