Informática híbrida integrada

La computación híbrida integrada reúne los procesos clásicos y cuánticos, lo que permite al código clásico controlar la ejecución de operaciones cuánticas basadas en medidas de circuito medio mientras los cúbits físicos permanecen activos. Con técnicas de programación comunes, como condicionales anidados, bucles y llamadas de función, un único programa cuántico puede ejecutar problemas complejos, lo que reduce el número de tomas necesarias. Mediante técnicas de reutilización de cúbits, los programas más grandes se pueden ejecutar en máquinas que usan un número menor de cúbits.

Importante

Actualmente, la extensión Modern Quantum Development Kit (Modern QDK) no admite la computación cuántica híbrida integrada para Visual Studio Code, junto con otros componentes de los ejemplos de esta página, como el kernel IQ#, el %azure comando magic o el qsharp.azure módulo. Para ejecutar trabajos híbridos integrados, use Microsoft Quantum Development Kit (QDK clásico). Para obtener más información, consulte Continuar trabajando en el QDK clásico.

Para obtener más información, consulte:

• Granade & Weibe, "Usar paseos aleatorios para la estimación de fase iterativa".
• Lubinski, et al., "Avance del cálculo cuántico híbrido clásico con Real-Time ejecución"

Se ha agregado compatibilidad con targets.

Actualmente, el modelo de computación híbrida integrado en Azure Quantum se admite en Quantinuumtargets.

Quantinuum

Característica admitida	Notas
Bucles clásicos	Bucles limitados solo
Flujo de control arbitrario	Uso de bifurcación if/else
Medición del circuito medio	Utiliza recursos de registro clásicos
Reutilización de cúbits	N/D
Proceso clásico en tiempo real	Aritmética de enteros de 32 bits sin signo Utiliza recursos de registro clásicos

Introducción

Para empezar a explorar la programación híbrida integrada, se recomienda recorrer los ejemplos de este artículo o explorar la pestaña Computación cuántica híbrida en la galería de ejemplos del portal de Azure Quantum.

Envío de trabajos híbridos integrados

Al enviar un trabajo híbrido integrado, debe agregar un target parámetro de funcionalidad después de especificar .target Aparte de eso, los programas híbridos integrados en Azure Quantum se ejecutan y administran igual que los trabajos cuánticos normales. Cada trabajo tiene un identificador de trabajo único y el resultado es un único histograma.

Importante

Actualmente, la extensión Modern Quantum Development Kit (Modern QDK) no admite la computación cuántica híbrida integrada para Visual Studio Code, junto con otros componentes de los ejemplos de esta página, como el kernel IQ#, el %azure comando magic o el qsharp.azure módulo. Para ejecutar trabajos híbridos integrados, use Microsoft Quantum Development Kit (QDK clásico). Para obtener más información, consulte Continuar trabajando en el QDK clásico.

IQ#

Al usar el kernel IQ# en un Jupyter Notebook, use %azure.targetComando mágico -capability con el AdaptiveExecution parámetro .

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

Python + Q#

Al usar el paquete de Python qsharp , use la qsharp.azure.target_capability función con el AdaptiveExecution parámetro .

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

Azure CLI

Al usar la CLI de Azure para enviar un trabajo, agregue el --target-capability parámetro con el valor AdaptiveExecution.

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

Envío de trabajos híbridos integrados dentro de una sesión

Puede combinar varios trabajos híbridos integrados dentro de una sesión mediante Q# y Python. Al enviar una sesión, agregue el targetCapability parámetro de entrada con el 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 obtener más información, consulte Introducción a las sesiones.

Nota

Aunque las sesiones están disponibles para todos los proveedores de hardware de computación cuántica cuántica, tenga en cuenta que actualmente se admiten trabajos de computación cuántica híbrida integrados en Quantinuum targets.

Estimación del costo de un trabajo híbrido integrado

Puede calcular el costo de ejecutar un trabajo híbrido integrado en hardware quantinuum ejecutándolo primero en un emulador.

Después de una ejecución correcta en el emulador:

1. En el área de trabajo de Azure Quantum, seleccione Administración de trabajos.
2. Seleccione el trabajo que envió.
3. En el menú emergente Detalles del trabajo , seleccione Estimación de costos para ver cuántos créditos del emulador de Quantinuum se usaron. Este número se traduce directamente en el número de HQCs (créditos cuánticos de Quantinuum) necesarios para ejecutar el trabajo en hardware quantinuum.

Nota

Quantinuum anula la inscripción del circuito completo y calcula el costo en todas las rutas de acceso de código, tanto si se ejecutan condicionalmente como si no.

Ejemplos híbridos integrados

En los ejemplos siguientes se muestra el conjunto de características actual para la informática híbrida integrada.

• Comprobar un estado de GHZ entrelazado
• Repetición de tres cúbits
• Estimación de fase iterativa

Requisitos previos

• Si no está familiarizado con Azure Quantum, necesitará una suscripción de Azure y un área de trabajo de Azure Quantum para ejecutar los ejemplos en hardware cuántico. Para más información, consulte Creación de un área de trabajo de Azure Quantum.
• VS Code y la Quantum Development Kit configuración en el entorno local. Para obtener más información, vea Configuración de Quantum Development Kit.
• Asegúrese de que VS Code tiene la Quantum Development Kit versión más reciente de (0.27.258160).
  • En VS Code, seleccione Ctrl + Mayús + X y busque "Microsoft Quantum Development Kit".

Los ejemplos de este artículo están configurados para ejecutarse en Visual Studio (VS) Code y usar la interfaz de línea de comandos (CLI) de Azure integrada para enviar el trabajo a Azure Quantum. Para ejecutar la versión Jupyter Notebook de estos y otros ejemplos, inicie sesión en el área de trabajo de Azure Portal y vea los ejemplos en la pestaña Computación cuántica híbrida de la galería de ejemplos. Puede ejecutar el cuaderno en la nube o descargarlo y ejecutarlo localmente.

Para solucionar problemas con los programas híbridos integrados, consulte Solución de problemas híbridos integrados.

Comprobación del estado de GHZ

En este ejemplo, descubrirá cómo combinar instrucciones clásicas y cuánticas en el mismo programa, todas totalmente procesadas por el back-end de computación cuántica.

Características que se van a tener en cuenta sobre este ejemplo:

• Las medidas de bucle y cúbit se producen mientras los cúbits permanecen coherentes.
• La rutina combina operaciones de proceso clásicas y cuánticas.
• No es necesario aprender a programar para hardware especializado de alto rendimiento que se ejecuta junto a la QPU (por ejemplo, FPGA).
• La ejecución de un programa equivalente sin las características híbridas integradas requeriría devolver todos los resultados intermedios de medición y, a continuación, ejecutar el posprocesamiento en los datos.

Creación de un proyecto de VS Code

1. En VS Code, cree un nuevo Q# proyecto de aplicación de consola independiente denominado CheckGHZ.

   1. Seleccione View Command Pallete >Q#: Create new project Standalone console application (Ver > paleta de comandos): crear una aplicación de consola independiente del proyecto>.

2. Reemplace la configuración de CheckGHZ.csproj por lo siguiente:

   <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. Reemplace el código de Program.qs por lo siguiente:

   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. Desde una ventana de terminal en VS Code, conéctese al área de trabajo de Azure Quantum y establezca los recursos predeterminados.

   az login
   

   Nota

   El identificador de suscripción de Azure, el grupo de recursos y el nombre del área de trabajo se pueden mostrar en la ventana de terminal después de iniciar sesión ejecutando az quantum workspace list. Como alternativa, puede encontrarlos en el Azure Portal de la página Información general del área de trabajo de Azure Quantum.

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

5. Envíe el trabajo y vea los resultados. Esta ejecución usa aproximadamente 10.65 eHQCs (unidades de facturación del emulador de 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 repetición de tres cúbits

En este ejemplo se muestra cómo crear un código de repetición de 3 cúbits que se puede usar para detectar y corregir errores de volteo de bits.

Aprovecha las características de computación híbrida integradas para contar el número de veces que se realizó la corrección de errores mientras el estado de un registro de cúbits lógico es coherente.

Creación de un proyecto de VS Code

1. En VS Code, cree un nuevo Q# proyecto de aplicación de consola independiente denominado ThreeQubit.

   1. Seleccione View Command Pallete >Q#: Create new project Standalone console application (Ver > paleta de comandos): crear una aplicación de consola independiente del proyecto>.

2. Reemplace la configuración de ThreeQubit.csproj por lo siguiente:

   <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. Reemplace el código de Program.qs por lo siguiente:

   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. Desde una ventana de terminal en VS Code, conéctese al área de trabajo de Azure Quantum y establezca los recursos predeterminados.

   az login
   

   Nota

   El identificador de suscripción de Azure, el grupo de recursos y el nombre del área de trabajo se pueden mostrar en la ventana de terminal después de iniciar sesión ejecutando az quantum workspace list. Como alternativa, puede encontrarlos en el Azure Portal de la página Información general del área de trabajo de Azure Quantum.

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

5. Envíe el trabajo y vea los resultados. Esta ejecución usa aproximadamente 11.31 eHQCs (unidades de facturación del 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]
   

Estimación de fase iterativa

Este código de ejemplo fue escrito por miembros del equipo cuántico de KPMG en Australia y está bajo una licencia MIT. Tiene como objetivo demostrar funcionalidades ampliadas de Basic Measurement Feedbacktargets y hace uso de bucles limitados, llamadas de función clásicas en tiempo de ejecución, instrucciones if anidadas, medidas de circuito medio y reutilización de cúbits.

Cálculo de producto interno bidimensional mediante la estimación de fase iterativa en tres cúbits

En este programa de ejemplo se muestra una estimación de fase iterativa dentro de Q#. Usa la estimación de fase iterativa para calcular un producto interno entre dos vectores bidimensionales codificados en un target cúbit y un cúbit ancilla. También se inicializa un cúbit de control adicional, que será el único cúbit usado para la medición.

El circuito comienza codificando el par de vectores en el target cúbit y el cúbit ancilla. A continuación, aplica un operador de Oracle a todo el registro, controlado fuera del cúbit de control, que se configura en el estado $\ket +$. El operador de Oracle controlado genera una fase en el estado $\ket 1$ del cúbit de control. A continuación, se puede leer aplicando una puerta H al cúbit de control para que la fase sea observable al medir.

Creación de un proyecto de VS Code

1. En VS Code, cree un nuevo Q# proyecto de aplicación de consola independiente denominado IPE.

   1. Seleccione View Command Pallete >Q#: Create new project Standalone console application (Ver > paleta de comandos): crear una aplicación de consola independiente del proyecto>.

2. Reemplace la configuración de IPE.csproj por lo siguiente:

   <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. Reemplace el código de Program.qs por lo siguiente:

   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
   
   
   }
   

Vectores de codificación

Los vectores v y c se codifican en el target cúbit y el cúbit ancilla. El vector $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ se puede representar mediante el estado cuántico $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, de forma similar $c$ se puede construir mediante $\theta_2$.

Rotación Y aplicada a un target cúbit en el 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

Un factor de 2 está presente aquí en theta. Una aplicación de una puerta de $RY(2\pi)$ en $\ket 0$ proporciona el estado $-\ket 0$ y codificaría el vector $(-1,0)$. Esta fase no se puede considerar una fase global y se quita porque todo el registro se entrelazará.

El registro del target cúbit y el cúbit ancilla es

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

El estado que se va a crear está en el target cúbit y el cúbit ancilla es

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

que también adopta la forma

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

Agregue la siguiente operación al archivo 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);
}

The Oracle

Un oráculo G debe construirse de forma que genere una fase propio en el estado codificado en el target cúbit y el cúbit ancilla. La construcción de este oráculo no es importante para la demostración en este ejemplo, pero la operación que aplica es

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

donde el producto interno $\braket {v|c}$ se encuentra dentro de la fase $\phi$, que está enlazada entre [0,1]. Cuando se aplica controlado en el cúbit de control que comienza en ese estado $\ket{\Psi_\text{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}$$

Ahora el cúbit de control contiene la fase relacionada con el producto interno $\braket {v|c}$

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

Agregue la siguiente operación al archivo 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);
        }
    }

Iteración

Ahora para la parte iterativa del circuito. Para n medidas, tenga en cuenta que la fase se puede representar como un valor binario $\phi$, y que la aplicación de oráculos $2^n$ hace que el nº punto binario de la fase sea observable (mediante multiplicación binaria simple y módulo $2\pi$). El valor del cúbit de control se puede leer, colocar en un registro clásico y restablecer el cúbit para su uso en la siguiente iteración. La siguiente iteración aplica los oráculos $2^{n-1}$, lo que corrige la fase en el cúbit de control que depende de la medida nª. El estado del cúbit de control se puede representar como

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

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

La aplicación de oráculos controlados $2^n$ proporciona el estado en el cúbit de control

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

Tenga en cuenta que la fase no tiene términos más profundos que $\phi_n$ (es decir, términos $\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 $$

Ahora el valor $\phi_n$ se puede observar con una puerta H y una proyección de medida a lo largo del eje Z. Restablecer el cúbit de control y aplicar el oráculo $2^{n-1}$ veces

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

Con el valor medido anterior para $\phi_n$, se puede girar el punto binario adicional.

$$ 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 proceso se aplica de forma iterativa para cierta precisión de bits n para obtener la fase $0.\phi_0\phi_1\phi_2...\phi_{n}$. El valor se almacena como un valor binario $x = \phi_0\phi_1\phi_2...\phi_{n}$, ya que actualmente solo se pueden manipular enteros en tiempo de ejecución.

Como el readout no indica nada de ninguno de los vectores, solo el producto interno entre ellos, los estados del target cúbit y un cúbit decilla permanecen en el mismo estado durante todo el proceso.

Agregue la siguiente operación al archivo 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;
}

Cálculo del producto interno

Por último, calcule el producto interno a partir del valor medido.

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

donde $x = \phi_0\phi_1\phi_2...\phi_{n}$. El denominador dentro de la función coseno es desplazar el punto binario para que coincida con el valor original $\phi$.

Nota

Para el producto interno que no son -1 o 1, las soluciones se emparejan con una diferencia de valor de $2^{n-1}$. Por ejemplo, para las medidas n=3, el valor de bit medido de 2 también tendría una solución de par de 6. Cualquiera de estos valores produce el mismo valor del producto interno cuando se introduce como la variable en el coseno de función par (lo que da como resultado un producto interno de 0 en este ejemplo).

En el caso de las soluciones de productos internas entre la precisión de bits discreta, se generará una distribución de resultados en función de dónde se encuentra el producto interno entre el valor de bit discreto.

Agregue la siguiente operación al archivo 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)}");
}

Ejecución del programa

Ahora, puede probar el programa. En primer lugar, ejecutará el programa mediante una operación de simulación localmente y, a continuación, se conectará a Azure Quantum y lo ejecutará en un hardware target.

Simulación de la estimación de fase iterativa

Q# los programas requieren que @EntryPoint() indique al compilador dónde iniciar la ejecución del programa. Agregue el código siguiente a Programs.qs para iniciar el programa con la SimulateInnerProduct() operación . Esta versión de la operación interna del producto genera información adicional, incluida la manipulación de dobles de las que se muestra la salida en el 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 ejecutar el programa, abra una ventana de terminal en VS Code y ejecute

    dotnet run

Ejecución en Una instancia de Azure Quantum target

Para ejecutarse en un hardware target, reemplace la SimulateInnerProduct() operación por la siguiente HardwareInnerProduct() operación:

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

A continuación, conéctese al área de trabajo de Azure Quantum y establezca los recursos predeterminados.

az login

Nota

El identificador de suscripción de Azure, el grupo de recursos y el nombre del área de trabajo se pueden mostrar en la ventana de terminal después de iniciar sesión ejecutando az quantum workspace list. Como alternativa, puede encontrarlos en el Azure Portal de la página Información general del área de trabajo de Azure Quantum.

az account set --subscription <MySubscriptionID>

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

Envíe el trabajo con los parámetros siguientes:

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

Nota

El especificado target requiere un target perfil de ejecución que admita Basic Measurement Feedback.

Importante

No se recomienda aumentar el valor de más de Measurements3 al ejecutarse en Azure targets , ya que los eHQC pueden aumentar significativamente.

Puede ver el estado del trabajo con

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

reemplazando [job-id] por el identificador de trabajo mostrado. Los resultados muestran una solución en el estado con la población mayoritario. El producto interno final a partir de los resultados enteros se puede calcular mediante $\braket {v|c} = -cos(2\pi x / 2^n)$, donde n es el número de medidas especificadas en el trabajo.

Nota

La selección de parámetros de entrada que solo tienen un estado de solución (productos internos de -1 o 1) son ideales para la visibilidad cuando se usa un número bajo de tomas.

Pasos siguientes

Informática híbrida distribuida