Ejecución de trabajos de computación cuántica híbrida con perfil adaptable target

La informática híbrida combina procesos de computación clásica y cuántica para resolver problemas complejos.

En la informática híbrida, el código clásico controla la ejecución de operaciones cuánticas basadas en medidas de circuito medio mientras los cúbits físicos permanecen activos. Puede usar técnicas de programación comunes, como condicionales anidados, bucles y llamadas de función, en un único programa cuántico para ejecutar problemas complejos, lo que reduce el número de tomas necesarias. Con las técnicas de reutilización de cúbits, los programas más grandes se pueden ejecutar en máquinas con un número menor de cúbits.

En este artículo se explica cómo enviar trabajos híbridos a Azure Quantum mediante el QIR Adaptive RItarget perfil. El perfil de RI target adaptable ofrece compatibilidad con medidas de circuito medio, flujo de control basado en medidas, restablecimiento de cúbits y cálculo de enteros clásico.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Si no tiene una cuenta de Azure, regístrese gratuitamente y regístrese para obtener una suscripción de pago por uso.
• Un área de trabajo de Azure Quantum. Para más información, consulte Creación de un área de trabajo de Azure Quantum.
• Si desea enviar Q# programas independientes, necesita los siguientes requisitos previos:
  • Visual Studio Code con la extensión de Azure Quantum Development Kit instalada.
  • La versión más reciente de la extensión de AzureQuantum Development Kit.
• Si quiere enviar programas y Q# Python, necesita los siguientes requisitos previos:

  • Un entorno de Python con Python y Pip instalados.

  • Azure Quantum azure-quantum y qsharp los paquetes.

    pip install --upgrade azure-quantum qsharp
    

Se ha agregado compatibilidad con targets.

Para ejecutar trabajos de computación cuántica híbrida, debe seleccionar un proveedor cuántico que admita el perfil de RI target adaptable.

Actualmente, el perfil adaptable target en Azure Quantum se admite en Quantinuumtargets.

Envío de trabajos de RI adaptables

Para enviar trabajos de computación cuántica híbrida, debe configurar el target perfil como QIR Adaptive RI, donde RI significa "qubit Reset y Integer computations".

El QIR Adaptive RItarget perfil ofrece compatibilidad con medidas de circuito medio, flujo de control basado en medidas, restablecimiento de cúbits y cálculo de enteros clásico.

Puede enviar trabajos cuánticos híbridos a Azure Quantum como Q# programas independientes o python + Q# programas. Para configurar el target perfil para trabajos cuánticos híbridos, consulte las secciones siguientes.

Características admitidas

En la tabla siguiente se enumeran las características admitidas para la computación cuántica híbrida con Quantinuum en Azure Quantum.

El QDK proporciona targetcomentarios específicos cuando Q# no se admiten características de lenguaje para el objeto seleccionado target. Si el Q# programa contiene características no admitidas al ejecutar trabajos cuánticos híbridos, recibirá un mensaje de error en tiempo de diseño. Para obtener más información, consulte la página wiki de QIR.

Para ver las características admitidas en acción, copie el código siguiente en un Q# archivo y agregue los fragmentos de código siguientes.

import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;

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

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

    r0
}

Quantinuum admite booles y enteros dinámicos, lo que significa booles e enteros que dependen de los resultados de la medición. Tenga en cuenta que r0 es un Result tipo que se puede usar para generar valores bool e enteros dinámicos.

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

Quantinuum admite booles dinámicos e enteros, pero no admite valores dinámicos para otros tipos de datos, como double. Copie el código siguiente para ver comentarios sobre las limitaciones de los valores dinámicos.

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

Aunque no se admiten valores dinámicos para algunos tipos de datos, esos tipos de datos todavía se pueden usar con valores estáticos.

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

Incluso los valores dinámicos de los tipos admitidos no se pueden usar en determinadas situaciones. Por ejemplo, Quantinuum no admite matrices dinámicas, es decir, matrices cuyo tamaño depende de un resultado de medición. Quantinuum tampoco admite bucles enlazados dinámicamente. Copie el código siguiente para ver las limitaciones de los valores dinámicos.

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

Quantinuum admite el flujo de control, incluida if/else la bifurcación, mediante condiciones estáticas y dinámicas. La bifurcación en condiciones dinámicas también se conoce como bifurcación basada en los resultados de la medición.

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

Quantinuum admite bucles con condiciones clásicas y expresiones incluidas if .

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

Quantinuum admite la medición del circuito medio, es decir, la bifurcación basada en los resultados de la medición.

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

Estimación del costo de un trabajo de computación cuántica híbrida

Puede calcular el costo de ejecutar un trabajo de computación cuántica híbrida 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 HQC (créditos cuánticos de Quantinuum) necesarios para ejecutar el trabajo en hardware Quantinuum.

Ejemplos de computación cuántica híbrida

Los ejemplos siguientes se pueden encontrar en el Q# repositorio de ejemplos de código. Muestran el conjunto de características actual para la computación cuántica híbrida.

Código de repetición de tres cúbits

En este ejemplo se muestra cómo crear un código de repetición de tres 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úbit lógico es coherente.

Puede encontrar el ejemplo de código aquí.

Estimación de fase iterativa

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 2 dimensionales codificados en un target cúbit y un cúbit ancilla. También se inicializa un cúbit de control adicional, que es el único cúbit utilizado 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.

Puede encontrar el ejemplo de código aquí.

Contenido relacionado

• Introducción a las sesiones