Executar trabalhos de computação quântica híbrida com um perfil adaptável target

A computação híbrida combina processos de computação clássica e quântica para resolver problemas complexos.

Na computação híbrida, o código clássico controla a execução de operações quânticas com base em medições de circuito intermediário enquanto os qubits físicos permanecem ativos. Você pode usar técnicas comuns de programação, como condicionais aninhadas, loops e chamadas de função, em um único programa quântico para executar problemas complexos, reduzindo o número de disparos necessários. Com técnicas de reutilização de qubits, programas maiores podem ser executados em máquinas usando um número menor de qubits.

Este artigo explica como enviar trabalhos híbridos para o Azure Quantum usando o Adaptive RItarget perfil. O Adaptive RItarget perfil oferece suporte para medições de circuito intermediário, fluxo de controle baseado em medição, redefinição de qubit e computação inteira clássica.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Se você não tiver uma conta do Azure, registre-se gratuitamente e inscreva-se para uma assinatura paga conforme o uso.
• Um workspace do Azure Quantum. Para obter mais informações, confira Criar um workspace do Azure Quantum.

Se você quiser enviar Q# programas autônomos, também precisará dos seguintes pré-requisitos:

• Visual Studio Code (VS Code) com a extensão do Azure Quantum Development Kit (QDK) instalada.
• A versão mais recente da extensãoQuantum Development KitAzure.

Se você quiser enviar Python e Q# programas, também precisará dos seguintes pré-requisitos:

• Um ambiente Python com Python e Pip instalados.

• A biblioteca Python mais recente qdk com o extra opcional azure.

  pip install --upgrade "qdk[azure]"
  

targets com suporte

Para executar trabalhos de computação quântica híbrida, você precisa selecionar um provedor quântico que dê suporte ao Adaptive RItarget perfil.

Atualmente, há suporte para o perfil adaptável target no Azure Quantum no Quantinuumtargets.

Envio de trabalhos de RI adaptável

Para enviar trabalhos de computação quântica híbrida, você precisa configurar o target perfil como Adaptive RI, onde RI significa "qubit Reset e Integer computations".

O Adaptive RItarget perfil oferece suporte para medições de circuito intermediário, fluxo de controle baseado em medição, redefinição de qubit e computação inteira clássica.

Você pode enviar trabalhos quânticos híbridos para o Azure Quantum como Q# programas autônomos ou programas Python + Q# . Para configurar o perfil para trabalhos quânticos target híbridos, consulte as seções a seguir.

Recursos com suporte

A tabela a seguir lista os recursos com suporte para computação quântica híbrida com Quantinuum no Azure Quantum.

O QDK fornece targetcomentários específicos quando Q# os recursos de linguagem não são compatíveis com o target. Se o programa Q# contiver recursos sem suporte ao executar trabalhos quânticos híbridos, você receberá uma mensagem de erro no momento do design. Para obter mais informações, consulte a QIR página wiki.

Para ver os recursos com suporte em ação, copie o código a seguir em um Q# arquivo e adicione os snippets de código subsequentes.

import Std.Measurement.*;
import Std.Math.*;
import Std.Convert.*;

operation Main() : Result {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);
    let r0 = MResetZ(q0);

    // Copy here the code snippets below to see the supported features 
    // in action.
    // Supported features include dynamic values, classically-bounded loops, 
    // arbitrary control flow, and mid-circuit measurement.

    r0
}

O Quantinuum suporta bools e inteiros dinâmicos, o que significa bools e inteiros que dependem dos resultados da medição. Observe que r0 é um Result tipo que pode ser usado para gerar valores booleanos e inteiros dinâmicos.

    let dynamicBool = r0 != Zero; 
    let dynamicBool = ResultAsBool(r0); 
    let dynamicInt = dynamicBool ? 0 | 1; 

O Quantinuum suporta bools e inteiros dinâmicos, no entanto, não suporta valores dinâmicos para outros tipos de dados, como double. Copie o código a seguir para ver comentários sobre as limitações dos valores dinâmicos.

    let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
    let dynamicInt = r0 == One ? 1 | 0;
    let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
    let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Embora não haja suporte para valores dinâmicos para alguns tipos de dados, esses tipos de dados ainda podem ser usados com valores estáticos.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Mesmo os valores dinâmicos de tipagem com suporte não podem ser usados em determinadas situações. Por exemplo, o Quantinuum não oferece suporte a matrizes dinâmicas, ou seja, matrizes cujo tamanho depende de um resultado de medição. O Quantinuum também não oferece suporte a loops limitados dinamicamente. Copie o código a seguir para ver as limitações dos valores dinâmicos.

    let dynamicInt = r0 == Zero ? 2 | 4;
    let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
    let staticallySizedArray = [0, size = 10];
    // Loops with a dynamic condition are not supported by Quantinuum.
    for _ in 0..dynamicInt {
         Rx(PI(), q1);
    }
        
    // Loops with a static condition are supported.
    let staticInt = 3;
    for _ in 0..staticInt {  
         Rx(PI(), q1);  
    }

O Quantinuum suporta fluxo de controle, incluindo if/else ramificação, usando condições estáticas e dinâmicas. A ramificação em condições dinâmicas também é conhecida como ramificação com base nos resultados da medição.

    let dynamicInt = r0 == Zero ? 0 | 1; 
    if dynamicInt > 0 {
        X(q1);
     }
    let staticInt = 1;
    if staticInt > 5 {
         Y(q1);
    } else {
         Z(q1);
    }

O Quantinuum suporta loops com condições clássicas e incluindo if expressões.

    for idx in 0..3 {
        if idx % 2 == 0 {
            Rx(ArcSin(1.), q0);
            Rz(IntAsDouble(idx) * PI(), q1)
        } else {
            Ry(ArcCos(-1.), q1);
             Rz(IntAsDouble(idx) * PI(), q1)
        }
     }

O Quantinuum suporta medição de circuito intermediário, ou seja, ramificação com base nos resultados da medição.

    if r0 == One {
        X(q1);
    }
    let r1 = MResetZ(q1);
    if r0 != r1 {
        let angle = PI() + PI() + PI()* Sin(PI()/2.0);
        Rxx(angle, q0, q1);
    } else {
        Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
    }

Estimar o custo de um trabalho de computação quântica híbrida

Você pode estimar o custo para executar um trabalho de computação quântica híbrida no hardware Quantinuum executando o trabalho em um emulador primeiro.

Após uma execução bem-sucedida no emulador:

1. No workspace do Azure Quantum, selecione Gerenciamento de trabalhos.
2. Selecione o trabalho que você enviou.
3. No pop-up Detalhes do trabalho , selecione Estimativa de custo para exibir quantos eHQCs (créditos do emulador Quantinuum) foram usados. Esse número se traduz diretamente no número de HQCs (créditos quânticos do Quantinuum) necessários para executar o trabalho no hardware do Quantinuum.

Exemplos de computação quântica híbrida

Os exemplos a seguir podem ser encontrados no Q# repositório de exemplos de código. Eles demonstram o conjunto de recursos atual para computação quântica híbrida.

Código de repetição de três qubits

Este exemplo demonstra como criar um código de repetição de três qubits que pode ser usado para detectar e corrigir erros de inversão de bits.

Ele aproveita os recursos de computação híbrida integrados para contar o número de vezes que a correção de erros foi executada enquanto o estado de um registro de qubit lógico é coerente.

Você pode encontrar o código neste exemplo.

Estimativa de fase iterativa

Este programa de exemplo demonstra uma estimativa de fase iterativa dentro Q#do . Ele usa a estimativa de fase iterativa para calcular um produto interno entre dois vetores bidimensionais codificados em um target qubit e um qubit ancilla. Um qubit de controle adicional também é inicializado, que é o único qubit usado para medição.

O circuito começa codificando o par de vetores no qubit e no target qubit ancilla. Em seguida, ele aplica um operador Oracle a todo o registro, controlado pelo qubit de controle, que é configurado no estado $\ket +$. O operador Oracle controlado gera uma fase no estado $\ket 1$ do qubit de controle. Isso pode ser lido aplicando uma porta H ao qubit de controle para tornar a fase observável durante a medição.

Você pode encontrar o código neste exemplo.

Conteúdo relacionado

• Introdução às sessões