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 nas medições de meio circuito enquanto os qubits físicos permanecem ativos. Ao utilizar técnicas de programação comuns, como condicionais aninhadas, ciclos e chamadas de função, um único programa quântico pode executar problemas complexos, reduzindo o número de capturas necessárias. Ao utilizar técnicas de reutilização de qubits, os programas maiores podem ser executados em máquinas que utilizam um número menor de qubits.

Importante

Atualmente, a computação quântica híbrida integrada não é suportada pela extensão QDK Moderna Quantum Development Kit (QDK Moderna) 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 tarefas híbridas integradas, utilize o Microsoft Quantum Development Kit (QDK Clássico). Para obter mais informações, veja Continuar a trabalhar no QDK Clássico.

Para mais debates, consulte:

• Granade & Weibe, "Using Random Walks for Iterative Phase Estimation".
• Lubinski, et al., "Advanceing Hybrid Quantum–Classic Computation with Real-Time Execution"

Suportado targets

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

Quantinuum

Funcionalidade suportada	Notas
Ciclos clássicos	Apenas ciclos vinculados
Fluxo de controlo arbitrário	Utilização da ramificação if/else
Medição média do circuito	Utiliza recursos de registo clássicos
Reutilização de qubits	N/D
Computação clássica em tempo real	Aritmética de número inteiro não assinado de 32 bits Utiliza recursos de registo clássicos

Introdução

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

Submeter tarefas híbridas integradas

Ao submeter uma tarefa híbrida integrada, tem de adicionar um target parâmetro de capacidade depois de especificar o target. Para além disso, os programas híbridos integrados no Azure Quantum são executados e geridos da mesma forma que os trabalhos quânticos normais. Cada tarefa tem um único ID de tarefa e o resultado é um único histograma.

Importante

Atualmente, a computação quântica híbrida integrada não é suportada pela extensão QDK Moderna Quantum Development Kit (QDK Moderna) 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 tarefas híbridas integradas, utilize o Microsoft Quantum Development Kit (QDK Clássico). Para obter mais informações, veja Continuar a trabalhar no QDK Clássico.

IQ#

Ao utilizar o kernel IQ# num Jupyter Notebook, utilize o %azure.targetComando magic -capability com o AdaptiveExecution parâmetro .

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

Python + Q#

Ao utilizar o pacote python qsharp , utilize 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 utilizar a CLI do Azure para submeter uma tarefa, 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

Submeter tarefas híbridas integradas numa sessão

Pode combinar várias tarefas híbridas integradas numa sessão com Q# o e o Python. Ao submeter 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.

Nota

Embora as sessões estejam disponíveis para todos os fornecedores de hardware de computação quântica, tenha em atenção que as tarefas de computação quântica híbrida integradas são atualmente suportadas no Quantinuum targets.

Estimar o custo de uma tarefa híbrida integrada

Pode estimar o custo da execução de uma tarefa híbrida integrada no hardware Quantinuum ao executá-lo primeiro num emulador.

Após uma execução com êxito no emulador:

1. Na área de trabalho do Azure Quantum, selecione Gestão de tarefas.
2. Selecione a tarefa que submeteu.
3. No pop-up Detalhes da tarefa, selecione Estimativa de Custos para ver quantos eHQCs (créditos de emulador Quantinuum) foram utilizados. Este número traduz-se diretamente no número de HQCs (créditos quânticos Quantinuum) que são necessários para executar a tarefa em hardware Quantinuum.

Nota

O Quantinuum anula a inscrição de todo o circuito e calcula o custo em todos os caminhos de código, quer sejam ou não executados condicionalmente.

Exemplos híbridos integrados

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

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

Pré-requisitos

• Se não estiver familiarizado com o Azure Quantum, precisará de uma subscrição do Azure e de uma área de trabalho do Azure Quantum para executar os exemplos em hardware quântico. Para obter mais informações, veja Criar uma área de trabalho do Azure Quantum.
• VS Code e a Quantum Development Kit configuração no seu ambiente local. Para obter mais informações, consulte Configurar o Quantum Development Kit.
• Certifique-se de que o VS Code tem a versão mais recente do Quantum Development Kit (0.27.258160).
  • No VS Code, selecione Ctrl + Shift + X e procure "Microsoft Quantum Development Kit".

Os exemplos neste artigo estão configurados para serem executados no Visual Studio (VS) Code e utilizam a interface de linha de comandos (CLI) do Azure incorporada para submeter a tarefa para o Azure Quantum. Para executar a versão Jupyter Notebook destes e de outros exemplos, inicie sessão na área de trabalho portal do Azure e veja os exemplos do separador Computação quântica híbrida na galeria Exemplos. Pode executar o bloco de notas na nuvem ou transferi-lo e executá-lo localmente.

Para resolver problemas com programas híbridos integrados, veja Resolver problemas híbridos integrados.

Verificar o estado ghz

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

Funcionalidades a ter em conta sobre este exemplo:

• As medições de ciclo e qubit ocorrem enquanto os qubits permanecem coerentes.
• A rotina mistura operações de computação clássica e quântica.
• Não precisa de aprender a programar para hardware especializado de alto desempenho em execução junto à QPU (como FPGAs).
• A execução de um programa equivalente sem as funcionalidades híbridas integradas exigiria a devolução de cada resultado de medição intermédia e, em seguida, a execução do pós-processamento nos dados.

Criar um projeto do VS Code

1. No VS Code, crie um novo Q# projeto de aplicação de consola autónomo com o nome CheckGHZ.

   1. Selecione Ver > Comando Pallete>Q#: Criar nova aplicação de consola autónoma 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. A partir de uma janela de terminal no VS Code, ligue-se à área de trabalho do Azure Quantum e defina os recursos predefinidos.

   az login
   

   Nota

   O ID da subscrição do Azure, o grupo de recursos e o nome da área de trabalho podem ser listados na janela do terminal após iniciar sessão ao executar az quantum workspace list. Em alternativa, pode encontrá-los na portal do Azure na página Descrição geral da área de trabalho do Azure Quantum.

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

5. Submeta a tarefa e veja os resultados. Esta execução utiliza aproximadamente 10,65 eHQCs (unidades de faturação 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 utilizado para detetar e corrigir erros de lançamento de bits.

Tira partido das funcionalidades de computação híbrida integradas para contar o número de vezes que a correção de erros foi efetuada enquanto o estado de um registo de qubit lógico é coerente.

Criar um projeto do VS Code

1. No VS Code, crie um novo Q# projeto de aplicação de consola autónomo com o nome ThreeQubit.

   1. Selecione Ver > Comando Pallete>Q#: Criar nova aplicação de consola autónoma 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. A partir de uma janela de terminal no VS Code, ligue-se à área de trabalho do Azure Quantum e defina os recursos predefinidos.

   az login
   

   Nota

   O ID da subscrição do Azure, o grupo de recursos e o nome da área de trabalho podem ser listados na janela do terminal após iniciar sessão ao executar az quantum workspace list. Em alternativa, pode encontrá-los na portal do Azure na página Descrição geral da sua área de trabalho do Azure Quantum.

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

5. Submeta a tarefa e veja os resultados. Esta execução utiliza aproximadamente 11,31 eHQCs (unidades de faturação 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 equipa quantum DA KPMG na Austrália e está abrangido por uma Licença do MIT. Tem como objetivo demonstrar capacidades expandidas de Basic Measurement Feedbacktargets e utiliza ciclos vinculados, chamadas de funções clássicas no tempo de execução, instruções condicionais aninhadas, medições de circuito médio e reutilização de qubits.

Cálculo bidimensional do produto interno com a estimativa de fase iterativa em três qubits

Este programa de exemplo demonstra uma estimativa de fase iterativa no Q#. Utiliza a estimativa de fase iterativa para calcular um produto interno entre dois vetores bidimensionais codificados num target qubit e num qubit de ancilla. É também inicializado um qubit de controlo adicional que será o único qubit utilizado para a medição.

O circuito começa por codificar o par de vetores no target qubit e no qubit de ancilla. Em seguida, aplica um operador Oracle a todo o registo, controlado fora do qubit de controlo, que é configurado no estado $\ket +$. O operador Oracle controlado gera uma fase no estado $\ket 1$ do qubit de controlo. Em seguida, pode ler-se ao aplicar uma porta H ao qubit de controlo para tornar a fase observável ao medir.

Criar um projeto do VS Code

1. No VS Code, crie um novo Q# projeto de aplicação de consola autónomo com o nome IPE.

   1. Selecione Ver > Comando Pallete>Q#: Criar nova aplicação de consola autónoma 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 de 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$, de forma semelhante $c$ pode ser construído com $\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$$

Nota

Um fator de 2 está presente aqui no teta. Uma aplicação de uma porta de $RY(2\pi)$ em $\ket 0$ dá ao estado $-\ket 0$ e codificaria o vetor $(-1,0)$. Esta fase não pode ser considerada uma fase global e é removida, uma vez que todo o registo será entrelaçado.

O registo do qubit e do target qubit de 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 de 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 seguinte operação ao ficheiro 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 Oráculo

Um Oráculo G tem de ser construído de modo a gerar um eigenphase no estado codificado no target qubit e no qubit de ancilla. A construção deste oráculo não é importante para a demonstração neste exemplo, mas a operação que se 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á vinculada entre [0,1]. Quando aplicado controlado no qubit de controlo 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 controlo contém a fase relacionada com o 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 seguinte operação ao ficheiro 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 medições, considere que a fase pode ser representada como um valor binário $\phi$e que a aplicação de $2^n$ oracles torna o nº ponto binário da fase observável (através da multiplicação binária simples e do modulus $2\pi$). O valor do qubit de controlo pode ser lido, colocado num registo clássico e na reposição do qubit para utilização na iteração seguinte. A iteração seguinte aplica $2^{n-1}$ oracles, corrigindo a fase no qubit de controlo dependente da n.ª medição. O estado no qubit de controlo pode ser representado como

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

onde $\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

Aplicar oráculos controlados por $2^n$ dá o estado no qubit de controlo

$$ 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 uma porta H e uma medição projetada ao longo do eixo Z. Repor o qubit de controlo e aplicar 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 $$

Com o valor medido anterior para $\phi_n$, o ponto binário adicional pode ser rodado 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 $$

Este processo é aplicado iterativamente para alguma precisão de bit n para obter 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}$, uma vez que apenas os números inteiros são manipuláveis no runtime atualmente.

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

Adicione a seguinte operação ao ficheiro 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 a partir 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 na função cosseno é deslocar o ponto binário para corresponder ao valor original $\phi$.

Nota

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 as medições n=3, o valor de bit medido de 2 também teria uma solução de par de 6. Qualquer um destes valores produz o mesmo valor do produto interno quando é introduzido como a variável para o cosseno da função par (resultando num produto interno de 0 neste exemplo).

Para soluções de produtos internos entre a precisão discreta de bits, será produzida uma distribuição dos resultados com base no local onde o produto interno se encontra entre o valor de bit discreto.

Adicione a seguinte operação ao ficheiro 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, pode testar o programa. Primeiro, irá executar o programa com uma operação de simulação localmente e, em seguida, irá ligar ao Azure Quantum e executá-lo num hardware target.

Simular a estimativa de fase iterativa

Q# os programas necessitam de um @EntryPoint() para indicar ao compilador onde iniciar a execução do programa. Adicione o seguinte código a Programs.qs para iniciar o programa com a SimulateInnerProduct() operação. Esta versão da operação de produto interno produz informações adicionais, incluindo a manipulação de duplos dos quais a saída é apresentada 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

Executar num Azure Quantum target

Para executar num 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, ligue-se à área de trabalho do Azure Quantum e defina os recursos predefinidos.

az login

Nota

O ID da subscrição do Azure, o grupo de recursos e o nome da área de trabalho podem ser listados na janela do terminal após iniciar sessão ao executar az quantum workspace list. Em alternativa, pode encontrá-los na portal do Azure na página Descrição geral da sua área de trabalho do Azure Quantum.

az account set --subscription <MySubscriptionID>

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

Submeta a tarefa com os seguintes parâmetros:

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

Nota

O especificado target requer um target perfil de execução que suporte Basic Measurement Feedback.

Importante

Não é recomendado aumentar o valor para além de Measurements3 ao executar no Azure targets , uma vez que os eHQCs podem aumentar significativamente.

Pode ver o estado da tarefa com

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

substituindo [job-id] pelo ID do trabalho apresentado. 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 na tarefa.

Nota

Selecionar parâmetros de entrada que têm apenas um estado de solução (os produtos internos de -1 ou 1) são ideais para visibilidade ao utilizar um número reduzido de capturas.

Passos seguintes

Computação híbrida distribuída