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.

Q# en Visual Studio Code

Para configurar el target perfil para trabajos híbridos en Visual Studio Code, siga estos pasos:

1. Abra un Q# programa en Visual Studio Code.
2. Seleccione Ver> - Paleta de comandos y escriba Q#: Establezca el targetperfil de QIR de Azure Quantum. Presione ENTRAR.
3. Seleccione QIR Adaptive RI.

Una vez establecido QIR Adaptive RI como target perfil, puede enviar el Q# programa como un trabajo cuántico híbrido a Quantinuum.

1. Seleccione View - Command Palette (Ver:> paleta de comandos) y escriba Q#: Connect to an Azure Quantum workspace (Conectarse a un área de trabajo de Azure Quantum). Presione ENTRAR.
2. Seleccione Cuenta de Azure y siga las indicaciones para conectarse a su directorio, suscripción y área de trabajo preferidos.
3. Una vez que esté conectado, en el panel Explorador , expanda Áreas de trabajo cuánticas.
4. Expanda el área de trabajo y expanda el proveedor quantinuum .
5. Seleccione cualquier quantinuum disponible target, por ejemplo quantinuum.sim.h1-1e.
6. Seleccione el icono de reproducción situado a la derecha del target nombre para empezar a enviar el programa actual Q# .
7. Agregue un nombre para identificar el trabajo y el número de capturas.
8. Presione Entrar para enviar el trabajo. El estado del trabajo se muestra en la parte inferior de la pantalla.
9. Expanda Trabajos y mantenga el puntero sobre el trabajo, que muestra las horas y el estado del trabajo.

Q# + Python

1. Al usar el paquete de Python qsharp , use la qsharp.init función y establezca el target_profile parámetro Adaptive_RIen .

   import qsharp
   
   qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)
   

2. Conéctese al área de trabajo de Azure Quantum.

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

3. Establezca el target parámetro en quantinuum target que desea usar. Por ejemplo, para usar :quantinuum.sim.h1-1etarget

   target = workspace.get_targets("quantinuum.sim.h1-1e")
   

Puede combinar varios trabajos cuánticos híbridos dentro de una sesión mediante la target.open_session función . 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, observe que Adaptive_RItarget los trabajos de perfil solo se admiten actualmente en Quantinuum targets.

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.

Característica compatible	Notas
Valores de Dynamics	Bools e enteros cuyo valor depende de un resultado de medición
Bucles	Bucles delimitados clásicamente 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	Compatible
Proceso clásico en tiempo real	Aritmética de enteros con signo de 64 bits Utiliza recursos de registro clásicos

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.

Nota:

Debe seleccionar el perfil adecuado para obtener los comentarios adecuados QIR Adaptive RItarget al usar Q# características que target no son compatibles.

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.

namespace HybridIntegrated {
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    @EntryPoint()
    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.

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

Nota:

Este código de ejemplo fue escrito por miembros del equipo cuántico de KPMG en Australia y se encuentra bajo una licencia MIT. Muestra las funcionalidades expandidas de QIR Adaptive RItargets y hace uso de bucles delimitados, llamadas a funciones clásicas en tiempo de ejecución, instrucciones condicionales anidadas, medidas de circuito medio y reutilización de cúbits.

Contenido relacionado

• Introducción a las sesiones