Computação híbrida integrada

A computação híbrida integrada reúne os processos clássicos e quânticos, permitindo que o código clássico controle a execução de operações quânticas com base em medidas de circuito médio enquanto os qubits físicos permanecem ativos. Usando técnicas de programação comuns, como condicionais aninhadas, loops e chamadas de função, um único programa quântico pode executar problemas complexos, reduzindo o número de capturas necessárias. Usando técnicas de reutilização de qubit, programas maiores podem ser executados em computadores utilizando um número menor de qubits.

Importante

Atualmente, a computação quântica híbrida integrada não é compatível com a extensão moderna Quantum Development Kit (QDK moderno) para Visual Studio Code, juntamente com outros componentes nos exemplos desta página, como o kernel IQ#, o %azure comando magic ou o qsharp.azure módulo. Para executar trabalhos híbridos integrados, use o Microsoft Quantum Development Kit (QDK Clássico). Para obter mais informações, consulte Continuar trabalhando no QDK clássico.

Para obter mais discussões, confira:

• Granade & Weibe, "Usando caminhadas aleatórias para estimativa de fase iterativa".
• Lubinski, et al., "Advanceing Hybrid Quantum–Classic Computation with Real-Time Execution"

targets com suporte

Atualmente, o modelo de computação híbrida integrado no Azure Quantum tem suporte no Quantinuumtargets.

Quantinuum

Recurso com suporte	Observações
Loops clássicos	Somente loops limitados
Fluxo de controle arbitrário	Uso da ramificação if/else
Medição de circuito médio	Utiliza recursos de registro clássicos
Reutilização do Qubit	N/D
Computação clássica em tempo real	Aritmética de inteiro sem sinal de 32 bits Utiliza recursos de registro clássicos

Introdução

Para começar a explorar a programação híbrida integrada, sugerimos percorrer os exemplos neste artigo ou explorar a guia Computação quântica híbrida na galeria Exemplos do portal do Azure Quantum.

Enviando trabalhos híbridos integrados

Ao enviar um trabalho híbrido integrado, você precisa adicionar um target parâmetro de funcionalidade depois de especificar o target. Fora isso, os programas híbridos integrados no Azure Quantum são executados e gerenciados da mesma forma que os trabalhos quânticos regulares. Cada trabalho tem uma única ID de trabalho e o resultado é um único histograma.

Importante

Atualmente, a computação quântica híbrida integrada não é compatível com a extensão moderna Quantum Development Kit (QDK moderno) para Visual Studio Code, juntamente com outros componentes nos exemplos desta página, como o kernel IQ#, o %azure comando magic ou o qsharp.azure módulo. Para executar trabalhos híbridos integrados, use o Microsoft Quantum Development Kit (QDK Clássico). Para obter mais informações, consulte Continuar trabalhando no QDK clássico.

EuQ#

Ao usar o kernel IQ# em um Jupyter Notebook, use o %azure.targetComando magic -capability com o AdaptiveExecution parâmetro .

%azure.target quantinuum.sim.h1-1e
%azure.target-capability AdaptiveExecution

Python + Q#

Ao usar o pacote qsharp do Python, use a qsharp.azure.target_capability função com o AdaptiveExecution parâmetro .

qsharp.azure.target("quantinuum.sim.h1-1e")
qsharp.azure.target_capability("AdaptiveExecution")

CLI do Azure

Ao usar a CLI do Azure para enviar um trabalho, adicione o --target-capability parâmetro com o valor AdaptiveExecution.

az quantum job submit \
    --target-capability AdaptiveExecution \
    --target-id quantinuum.sim.h1-1e \
    --job-name IterativePhaseEstimation \
    --shots 100 \
    --output table

Enviando trabalhos híbridos integrados em uma sessão

Você pode combinar vários trabalhos híbridos integrados em uma sessão usando Q# o e o Python. Ao enviar uma sessão, adicione o targetCapability parâmetro de entrada com o valor AdaptiveExecution.

with target.open_session(name="Q# session") as session:
    target.submit(input_data=QuantumOperation, name="Job 1", input_params={"count":100, "targetCapability":"AdaptiveExecution"}) # First job submission
    target.submit(input_data=QuantumOperation, name="Job 2", input_params={"count":200, "targetCapability":"AdaptiveExecution"}) # Second job submission
    target.submit(input_data=QuantumOperation, name="Job 3", input_params={"count":300, "targetCapability":"AdaptiveExecution"}) # Third job submission

Para obter mais informações, consulte Introdução às sessões.

Observação

Embora as sessões estejam disponíveis para todos os provedores de hardware de computação quântica, observe que atualmente há suporte para trabalhos integrados de computação quântica híbrida no Quantinuum targets.

Estimando o custo de um trabalho híbrido integrado

Você pode estimar o custo da execução de um trabalho híbrido integrado no hardware Quantinuum executando-o primeiro em um emulador.

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

Observação

O Quantinuum cancela o registro de todo o circuito e calcula o custo em todos os caminhos de código, sejam eles executados condicionalmente ou não.

Exemplos híbridos integrados

Os exemplos a seguir demonstram o conjunto de recursos atual para computação híbrida integrada.

• Verificar um estado GHZ emaranhado
• Repetição de três qubits
• Estimativa de fase iterativa

Pré-requisitos

• Se você for novo no Azure Quantum, precisará de uma assinatura do Azure e de um workspace do Azure Quantum para executar os exemplos em hardware quântico. Para obter mais informações, confira Criar um workspace do Azure Quantum.
• VS Code e a configuração Quantum Development Kit em seu ambiente local. Para obter mais informações, consulte Configurar o Quantum Development Kit.
• Verifique se o VS Code tem a versão mais recente do Quantum Development Kit (0.27.258160).
  • No VS Code, selecione Ctrl + Shift + X e pesquise "Microsoft Quantum Development Kit".

Os exemplos neste artigo são configurados para serem executados no Visual Studio (VS) Code e usam a CLI (interface de linha de comando) interna do Azure para enviar o trabalho ao Azure Quantum. Para executar a versão Jupyter Notebook desses e de outros exemplos, faça logon no workspace portal do Azure e exiba os exemplos da guia Computação quântica híbrida na galeria Exemplos. Você pode executar o notebook na nuvem ou baixá-lo e executá-lo localmente.

Para solucionar problemas com programas híbridos integrados, consulte Solução de problemas híbridos integrados.

Verificar o estado ghz

Neste exemplo, você descobrirá como combinar instruções clássicas e quânticas no mesmo programa, todas totalmente processadas pelo back-end de computação quântica.

Recursos a serem observados sobre este exemplo:

• As medidas de loop e qubit ocorrem enquanto os qubits permanecem coerentes.
• A rotina combina operações de computação clássicas e quânticas.
• Você não precisa aprender a programar hardware especializado de alto desempenho em execução ao lado da QPU (como FPGAs).
• Executar um programa equivalente sem os recursos híbridos integrados exigiria o retorno de cada resultado de medida intermediária e, em seguida, executar o pós-processamento nos dados.

Criar um projeto do VS Code

1. No VS Code, crie um novo Q# projeto de aplicativo de console autônomo chamado CheckGHZ.

   1. Selecione Exibir > Pallete >Q#de Comando: criar novo aplicativo de console autônomo do projeto >

2. Substitua a configuração em CheckGHZ.csproj pelo seguinte:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum</ExecutionTarget>
       <TargetCapability>AdaptiveExecution</TargetCapability>
     </PropertyGroup>
   </Project>
   

3. Substitua o código em Program.qs pelo seguinte:

   namespace Microsoft.Quantum.Samples {
   
       open Microsoft.Quantum.Measurement;
       open Microsoft.Quantum.Intrinsic;
   
       /// # Summary
       /// Counts the number of times measurements of a prepared GHZ state did not match the expected correlations.
       @EntryPoint() // The EntryPoint attribute is used to mark that this operation is where a quantum program will start running.
       operation CheckGHZ() : Int {
           use q = Qubit[3];
           mutable mismatch = 0;
           for _ in 1..10 {
               // Prepare the GHZ state.
               H(q[0]);
               CNOT(q[0], q[1]);
               CNOT(q[1], q[2]);
   
               // Measures and resets the 3 qubits
               let (r0, r1, r2) = (MResetZ(q[0]), MResetZ(q[1]), MResetZ(q[2]));
   
               // Adjusts classical value based on qubit measurement results
               if not (r0 == r1 and r1 == r2) {
                   set mismatch += 1;
               }
           }
           return mismatch;
       }
   }
   

4. Em uma janela de terminal no VS Code, conecte-se ao workspace do Azure Quantum e defina os recursos padrão.

   az login
   

   Observação

   Sua ID de assinatura do Azure, o grupo de recursos e o nome do workspace podem ser listados na janela do terminal depois de fazer logon executando az quantum workspace list. Como alternativa, você pode encontrá-los no portal do Azure na página Visão geral do workspace do Azure Quantum.

   az account set --subscription <MySubscriptionID>
   
   az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
   

5. Envie o trabalho e exiba os resultados. Essa execução usa aproximadamente 10,65 eHQCs (unidades de cobrança do emulador Quantinuum)

   az quantum job submit \
     --target-id quantinuum.sim.h1-1e \
     --job-name CheckGHZ \
     --target-capability AdaptiveExecution \
     --shots 50
   

   az quantum job output \
     -o table \
     --job-id [job-id]
   

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

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

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

Criar um projeto do VS Code

1. No VS Code, crie um novo Q# projeto de aplicativo de console autônomo chamado ThreeQubit.

   1. Selecione Exibir > Palete de >Q#Comando: criar novo aplicativo de console autônomo do projeto >

2. Substitua a configuração em ThreeQubit.csproj pelo seguinte:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum</ExecutionTarget>
       <TargetCapability>AdaptiveExecution</TargetCapability>
     </PropertyGroup>
   
   </Project>
   

3. Substitua o código em Program.qs pelo seguinte:

   namespace Microsoft.Quantum.Samples {
   
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
       open Microsoft.Quantum.Measurement;
   
       @EntryPoint()
       operation ThreeQubitRepetitionCode() : (Bool, Int) {
           // Use two qubit registers, one for encoding and an auxiliary one for syndrome measurements.
           use encodedRegister = Qubit[3];
           use auxiliaryRegister = Qubit[2];
   
           // Initialize the first qubit in the register to a |-〉 state.
           H(encodedRegister[0]);
           Z(encodedRegister[0]);
   
           // Apply several unitary operations to the encoded qubits performing bit flip detection and correction between
           // each application.
           mutable bitFlipCount = 0;
           within {
               // The 3 qubit register is used as a repetition code.
               Encode(encodedRegister);
           }
           apply {
               let iterations = 5;
               for _ in 1 .. iterations {
                   // Apply a sequence of rotations to the encoded register that effectively perform an identity operation.
                   ApplyRotationalIdentity(encodedRegister);
   
                   // Measure the bit flip error syndrome, revert the bit flip if needed, and increase the count if a bit flip occurred.
                   let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister, auxiliaryRegister);
                   let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);
                   if (bitFlipReverted) {
                       set bitFlipCount += 1;
                   }
               }
           }
   
           // Transform the qubit to the |1〉 state and measure it in the computational basis.
           H(encodedRegister[0]);
           let result = MResetZ(encodedRegister[0]) == One;
           ResetAll(encodedRegister);
   
           // The output of the program is a boolean-integer tuple where the boolean represents whether the qubit
           // measurement result was the expected one and the integer represents the number of times bit flips occurred
           // throughout the program.
           return (result, bitFlipCount);
       }
   
       operation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj
       {
           // This operation implements an identity operation using rotations about the x-axis.
           // The Rx operation has a period of $2\pi$ (given that it is not possible to measure the difference between
           // states $|\\psi〉$ and $-|\\psi〉$). Using it to apply 4 $\frac{\pi}{2}$ rotations about the x-axis, effectively
           // leaves the qubit register in its original state.
           let theta = PI() * 0.5;
           for i in 1 .. 4 {
               for qubit in register
               {
                   Rx(theta, qubit);
               }
           }
       }
   
       operation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool
       {
           if (parity01 == One and parity12 == Zero) {
               X(register[0]);
           }
           elif (parity01 == One and parity12 == One) {
               X(register[1]);
           }
           elif (parity01 == Zero and parity12 == One) {
               X(register[2]);
           }
   
           return parity01 == One or parity12 == One;
       }
   
       operation Encode(register : Qubit[]) : Unit is Adj
       {
           CNOT(register[0], register[1]);
           CNOT(register[0], register[2]);
       }
   
       operation MeasureBitFlipSyndrome(encodedRegister : Qubit[], auxiliaryRegister : Qubit[]) : (Result, Result)
       {
           // Measure the bit flip syndrome by checking the parities between qubits 0 and 1, and between qubits 1 and 2.
           ResetAll(auxiliaryRegister);
           CNOT(encodedRegister[0], auxiliaryRegister[0]);
           CNOT(encodedRegister[1], auxiliaryRegister[0]);
           CNOT(encodedRegister[1], auxiliaryRegister[1]);
           CNOT(encodedRegister[2], auxiliaryRegister[1]);
           let parity01 = MResetZ(auxiliaryRegister[0]);
           let parity12 = MResetZ(auxiliaryRegister[1]);
           return (parity01, parity12);
       }
   }
   

4. Em uma janela de terminal no VS Code, conecte-se ao workspace do Azure Quantum e defina os recursos padrão.

   az login
   

   Observação

   Sua ID de assinatura do Azure, o grupo de recursos e o nome do workspace podem ser listados na janela do terminal depois de fazer logon executando az quantum workspace list. Como alternativa, você pode encontrá-los no portal do Azure na página Visão geral do workspace do Azure Quantum.

   az account set --subscription <MySubscriptionID>
   
   az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
   

5. Envie o trabalho e exiba os resultados. Essa execução usa aproximadamente 11,31 eHQCs (unidades de cobrança do emulador Quantinuum)

   az quantum job submit \
       --target-id quantinuum.sim.h1-1e \
       --job-name ErrorCorrection \
       --target-capability AdaptiveExecution \
       --shots 50
   

   az quantum job output \
       -o table \
       --job-id [job-id]
   

Estimativa de fase iterativa

Este código de exemplo foi escrito por membros da equipe kpmg quantum na Austrália e se enquadra em uma licença mit. Ele tem como objetivo demonstrar recursos expandidos de Basic Measurement Feedbacktargets e usa loops limitados, chamadas de função clássica em tempo de execução, instruções aninhadas condicional se, medições de circuito médio e reutilização de qubit.

Cálculo de produto interno bidimensional usando estimativa de fase iterativa em três qubits

Este programa de exemplo demonstra uma estimativa de fase iterativa dentro Q#de . 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 será o único qubit usado para medição.

O circuito começa codificando o par de vetores no target qubit e no qubit ancilla. Em seguida, ele aplica um operador Oracle a todo o registro, controlado fora do 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 um portão H ao qubit de controle para tornar a fase observável ao medir.

Criar um projeto do VS Code

1. No VS Code, crie um novo Q# projeto de aplicativo de console autônomo chamado IPE.

   1. Selecione Exibir > Palete de >Q#Comando: criar novo aplicativo de console autônomo do projeto >

2. Substitua a configuração em IPE.csproj pelo seguinte:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
     </PropertyGroup>
   
   </Project>
   

3. Substitua o código em Program.qs pelo seguinte:

   namespace IPE {
   
       //IMPORT LIBRARIES
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
       open Microsoft.Quantum.Arrays;
       open Microsoft.Quantum.Measurement;
       open Microsoft.Quantum.Convert;
   
   
       // additional code added here
   
   
   }
   

Vetores de codificação

Os vetores v e c devem ser codificados no target qubit e no qubit ancilla. O vetor $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ pode ser representado pelo estado quântico $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, da mesma forma, $c$ pode ser construído usando $\theta_2$.

Uma rotação Y aplicada a um target qubit no estado $\ket 0$:

$$RY(\theta)\ket 0 = e^{iY\theta/2}\ket 0 = cos(\frac{\theta}{2})\ket 0 + sin(\frac{\theta}{2})\ket 1$$

Observação

Um fator de 2 está presente aqui em theta. Uma aplicação de um portão $RY(2\pi)$ em $\ket 0$ dá ao estado $-\ket 0$ e codificaria o vetor $(-1,0)$. Essa fase não pode ser considerada uma fase global e é removida, pois todo o registro será emaranhado.

O registro do target qubit e do qubit ancilla é

$$\ket \Psi = \ket {\Psi_\text{Target qubit}}\ket {\Psi_\text{Ancilla qubit}}$$

O estado a ser criado está no target qubit e o qubit ancilla é

$$\ket{\Psi}=\frac{1}{\sqrt{2}}(\ket{v}\ket{+}+\ket{c}\ket{-}),$$

que também assume o formulário

$$\ket{\Psi} = \frac{1}{2}(\ket{v}+\ket{c})\ket{0}+\frac{1}{2}(\ket{v}-\ket{c})\ket{1}.$$

Adicione a operação a seguir ao arquivo Program.qs .

//This is state preparation operator A for encoding the 2D vector
operation StateInitialisation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    H(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector v.
    Controlled R([AncilReg], (PauliY, theta_1, TargetReg));

    // X gate on ancilla to change from |+> to |->
    X(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector c.
    Controlled R([AncilReg], (PauliY, theta_2, TargetReg));
    X(AncilReg);
    H(AncilReg);
}

O Oracle

Um oracle G precisa ser construído de modo que gere uma eigenphase no estado codificado no target qubit e no qubit ancilla. A construção desse oráculo não é importante para a demonstração neste exemplo, mas a operação que ele aplica é

$$G\ket \Psi = e^{2\pi i\phi} \ket \Psi.$$

em que o produto interno $\braket {v|c}$ está contido na fase $\phi$, que está associada entre [0,1]. Quando aplicado controlado no qubit de controle que começa nesse estado $\ket{\Psi_\text{Control Qubit}} = \ket +$

$$\begin{aligned} \text{Controlled }G \ket{\Psi_\text{Control Qubit}} \ket \Psi & = \frac {1}{\sqrt{2}} (\ket 0 \ket \Psi + e^{2\pi i\phi}\ket 1 \ket \Psi )\ & =\frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1) \ket \Psi \end{aligned}$$

Agora, o qubit de controle contém a fase relacionada ao produto interno $\braket {v|c}$

$$\ket{\Psi_\text{Control Qubit}} = \frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1)$$

Adicione a operação a seguir ao arquivo Program.qs .

operation GOracle(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    Z(AncilReg);
        within {
            Adjoint StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);

            // Apply X gates individually here as currently ApplyAll is not Adj + Ctl
            X(AncilReg);
            X(TargetReg);
        }
        apply {
            Controlled Z([AncilReg],TargetReg);
        }
    }

Iteração

Agora, para a parte iterativa do circuito. Para n medidas, considere que a fase pode ser representada como um valor binário $\phi$e que a aplicação de oracles $2^n$ torna o nº ponto binário da fase observável (por meio de multiplicação binária simples e módulo $2\pi$). O valor do qubit de controle pode ser lido, colocado em um registro clássico e a redefinição de qubit para uso na próxima iteração. A próxima iteração aplica os oráculos $2^{n-1}$, corrigindo a fase no qubit de controle dependente da nª medida. O estado no qubit de controle pode ser representado como

$$ \ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i\phi}\ket 1 $$

em que $\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

Aplicar oráculos controlados por $2^n$ fornece o estado no qubit de controle

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n\phi_{n+1}\phi_{n+2}\phi_{n+3}...} \ket 1 $$

Considere que a fase não tem termos mais profundos do que $\phi_n$ (ou seja, termos $\phi_{n+1},\phi_{n+2}, \text{etc}$)

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n}\ket 1 $$

Agora, o valor $\phi_n$ pode ser observado com um portão H e uma medição projetando ao longo do eixo Z. Redefinindo o qubit de controle e aplicando o oracle $2^{n-1}$ vezes

$$ G^{2^{n-1}}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}\phi_n}\ket 1 $$

Usando o valor medido anteriormente para $\phi_n$, o ponto binário adicional pode ser girado para fora

$$ RZ(-2\pi \times 0.0\phi_n)G^{n-1}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}}\ket 1 $$

Esse processo é aplicado iterativamente para que alguma precisão de bit n obtenha a fase $0.\phi_0\phi_1\phi_2...\phi_{n}$. O valor é armazenado como um valor binário $x = \phi_0\phi_1\phi_2...\phi_{n}$, pois somente inteiros são manipuláveis no runtime no momento.

Como a leitura não indica nenhum dos vetores, somente o produto interno entre eles, os estados no target qubit e no qubit ancilla permanecem no mesmo estado durante todo o processo!

Adicione a operação a seguir ao arquivo Program.qs .

operation IterativePhaseEstimation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double, Measurements : Int) : Int{
    use ControlReg = Qubit();
    mutable MeasureControlReg = [Zero, size = Measurements];
    mutable bitValue = 0;

    //Apply to initialise state, this is defined by the angles theta_1 and theta_2
    StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);
    for index in 0 .. Measurements - 1{
        H(ControlReg);

        //Don't apply rotation on first set of oracles
        if index > 0 {

            //Loop through previous results
            for index2 in 0 .. index - 1{
                if MeasureControlReg[Measurements - 1 - index2] == One{
                    let angle = -IntAsDouble(2^(index2))*PI()/(2.0^IntAsDouble(index));

                    //Rotate control qubit dependent on previous measurements and number of measurements
                    R(PauliZ, angle, ControlReg);
                }
            }
        }
        let powerIndex = (1 <<< (Measurements - 1 - index));

        //Apply a number of oracles equal to 2^index, where index is the number or measurements left
        for _ in 1 .. powerIndex{
                Controlled GOracle([ControlReg],(TargetReg, AncilReg, theta_1, theta_2));
            }
        H(ControlReg);

        //Make a measurement mid circuit
        set MeasureControlReg w/= (Measurements - 1 - index) <- MResetZ(ControlReg);
        if MeasureControlReg[Measurements - 1 - index] == One{

            //Assign bitValue based on previous measurement
            set bitValue += 2^(index);

        }
    }
    return bitValue;
}

Calcular o produto interno

Por fim, calcule o produto interno do valor medido

$$\braket {v|c} = -cos(2\pi x / 2^n)$$

em que $x = \phi_0\phi_1\phi_2...\phi_{n}$. O denominador dentro da função cosseno é deslocar o ponto binário para corresponder ao valor original $\phi$.

Observação

Para produtos internos que não são -1 ou 1, as soluções são emparelhadas com uma diferença de valor de $2^{n-1}$. Por exemplo, para medidas n=3, o valor de bit medido de 2 também teria uma solução de par de 6. Qualquer um desses valores produz o mesmo valor do produto interno quando a entrada da variável para o cosseno de função par (resultando em um produto interno de 0 neste exemplo).

Para soluções internas de produto entre a precisão discreta de bits, uma distribuição de resultados será produzida com base no local em que o produto interno está entre o valor de bit discreto.

Adicione a operação a seguir ao arquivo Program.qs .

function CalculateInnerProduct(Results : Int, theta_1 : Double, theta_2 : Double, Measurements : Int): Unit{
    let DoubleVal = PI() * IntAsDouble(Results) / IntAsDouble(2 ^ (Measurements-1));

    //Convert to the final inner product
    let InnerProductValue = -Cos(DoubleVal);
    Message("The Bit Value measured is:");
    Message($"{Results}");
    Message("The Inner Product is:");
    Message($"{InnerProductValue}");
    Message("The True Inner Product is:");
    Message($"{Cos(theta_1/2.0)*Cos(theta_2/2.0)+Sin(theta_1/2.0)*Sin(theta_2/2.0)}");
}

Execute o programa

Agora, você pode testar o programa. Primeiro, você executará o programa usando uma operação de simulação localmente e, em seguida, se conectará ao Azure Quantum e o executará em um hardware target.

Simulando a estimativa de fase iterativa

Q# os programas exigem um @EntryPoint() para informar ao compilador onde iniciar a execução do programa. Adicione o código a seguir a Programs.qs para iniciar o programa com a SimulateInnerProduct() operação. Esta versão da operação interna do produto gera informações adicionais, incluindo a manipulação de duplas das quais a saída é exibida no terminal.

@EntryPoint()

//Operation for calculating the inner product on local simulators
operation SimulateInnerProduct() : Unit{

    //This operation will output additional classical calculations
    let (Results, theta_1, theta_2, Measurements) = InnerProduct();
    CalculateInnerProduct(Results, theta_1, theta_2, Measurements);
}

operation InnerProduct() : (Int, Double, Double, Int){

    //Specify the angles for inner product
    let theta_1 = 0.0;
    let theta_2 = 0.0;
    let Measurements = 3;

    //Create target register
    use TargetReg = Qubit();

    //Create ancilla register
    use AncilReg = Qubit();

    //This runs iterative phase estimation
    let Results = IterativePhaseEstimation(TargetReg, AncilReg, theta_1, theta_2, Measurements);
    Reset(TargetReg);
    Reset(AncilReg);
    return (Results, theta_1, theta_2, Measurements);
}

Para executar o programa, abra uma janela de terminal no VS Code e execute

    dotnet run

Em execução em um Azure Quantum target

Para executar em um hardware target, substitua a SimulateInnerProduct() operação pela seguinte HardwareInnerProduct() operação:

//Operation for calculating the inner product on hardware or emulators
operation HardwareInnerProduct() : Int{
    let (Results,_,_,_) = InnerProduct();
    return Results;
}

Em seguida, conecte-se ao workspace do Azure Quantum e defina os recursos padrão.

az login

Observação

Sua ID de assinatura do Azure, o grupo de recursos e o nome do workspace podem ser listados na janela do terminal depois de fazer logon executando az quantum workspace list. Como alternativa, você pode encontrá-los no portal do Azure na página Visão geral do workspace do Azure Quantum.

az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>

Envie o trabalho com os seguintes parâmetros:

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --target-capability AdaptiveExecution \
    --shots 50 \
    --job-name IterativePhaseEstimation

Observação

O especificado target requer um target perfil de execução que dê Basic Measurement Feedbacksuporte a .

Importante

Não é recomendável aumentar o valor de além de Measurements3 durante a execução no Azure targets , pois os eHQCs podem aumentar significativamente.

Você pode exibir a status do trabalho com

az quantum job output \
    -o table \
    --job-id [job-id]

substituindo [id do trabalho] pela ID do trabalho exibida. Os resultados mostram uma solução no estado com a maioria da população. O produto interno final dos resultados inteiros pode ser calculado por $\braket {v|c} = -cos(2\pi x / 2^n)$, em que n é o número de medidas especificadas no trabalho.

Observação

Selecionar parâmetros de entrada que têm apenas um estado de solução (produtos internos de -1 ou 1) é ideal para visibilidade ao usar um número baixo de capturas.

Próximas etapas

Computação híbrida distribuída