Solución de problemas híbridos integrados

  • Artículo

Nota

Este contenido solo se aplica al QDK clásico.

Desarrollar y ejecutar algoritmos híbridos integrados en el hardware compatible más reciente es un campo nuevo y en rápida evolución. En este artículo se describen las herramientas y los métodos disponibles actualmente, junto con los problemas conocidos, y se actualizan a medida que se admiten nuevas características.

Limitaciones y restricciones de características

En la tabla siguiente se enumeran las limitaciones y restricciones conocidas actualmente del conjunto de características híbridas integrado. Tener en cuenta estas limitaciones puede ayudar a evitar errores a medida que explora programas híbridos integrados. Esta tabla se actualiza a medida que se expande la funcionalidad.

Elemento Notas
Bibliotecas admitidas A partir de esta versión, no todas las bibliotecas del QDK admiten programas híbridos integrados.
Advertencias del compilador De forma predeterminada, targetlos errores del compilador específicos se convierten en advertencias. Asegúrese de validar el código en el simulador, emulador o validador proporcionado por el targetproveedor de hardware ed para detectar problemas antes de ejecutarse en hardware cuántico.
Tipos de datos compuestos El uso de tipos de datos compuestos, como tipos de estructura, tuplas y tipos secuenciales, incluidas matrices, no se admite actualmente con programas híbridos integrados. Esta limitación también impide el uso de estas estructuras de datos para los valores invocables. Además, los programas integrados no pueden usar subrutinas como valores de primera clase y el uso de tipos de función se limita a funciones LLVM declaradas globalmente que se pueden llamar como parte de la ejecución del programa.
Bucles sin enlazar o recursiones Los bucles sin enlazar y las recursiones directas o indirectas de función están fuera del ámbito de esta versión.
Asignaciones de cúbits dinámicos y acceso Las funciones en tiempo de ejecución para la asignación y versión de cúbits no están disponibles y la falta de compatibilidad con variables locales y tipos de datos compuestos impide cualquier alias de cúbit.
Aplicaciones parciales No se admite el uso de una aplicación parcial para definir un elemento visible al que se puede llamar en un ámbito de espacio de nombres.
Matrices Use rangos en lugar de matrices, siempre que sea posible. Para bucles pequeños en los que el rendimiento no es un problema, el usuario puede preferir usar intervalos (memoria contigua) para evitar salir de la memoria asignada.
Compatibilidad con enteros La compatibilidad actual de hardware de Quantinuum con enteros está limitada a valores sin signo de 32 bits, aunque Q# los enteros se tratan como de 64 bits con signo en el código. Esta limitación puede afectar a algunas operaciones y comparaciones bit a bit. Se recomienda usar valores enteros positivos para programas híbridos integrados.
Devolver valores constantes Los programas que devuelven valores constantes Result (es decir, Zero o One) no se admiten.
Limitaciones del registro clásico Cada compatible target tiene recuentos de registros clásicos específicos del hardware y la compilación puede producir un error si el programa subyacente usa más registros clásicos de los disponibles. Estos errores suelen producirse con estructuras de bucle.

Mensajes de error y solución de problemas

Compilación incompleta

  • Código de error: honeywell - 1000
  • Mensaje de error: 1000: Error de compilación: Error interno: Compilación incompleta
  • Tipo: Error de trabajo
  • Origen: compilador de destino

Este error puede producirse cuando se envía un programa que implementa cualquiera de los escenarios siguientes:

  • Comparación de enteros no admitida.

    operation IntegerComparisons() : Bool[] { 
    use register = Qubit[2]; 
    mutable i = 0; 
    if (MResetZ(register[0]) == Zero) { 
        set i += 1; 
    } 
    mutable j = 0; 
    if (MResetZ(register[1]) == One) { 
        set j += 1; 
    } 
    let logicalResults = [ 
        // Supported: equality comparisons with non-negative constants. 
        i == 0, 
        // Supported: equality comparisons between integer variables. 
        i == j, 
        // Not supported: equality comparisons with negative constants. 
        i == -1, 
        // Not supported: non-equality integer comparisons. 
        i < 0, 
        i <= i, 
        i > 0, 
        i >= j 
    ]; 
    return logicalResults; 
}

  • Bucles no admitidos que dependen de los resultados de medición de cúbits.

    operation UnboundedLoops() : Result { 
    use q = Qubit(); 
    H(q); 
    use t = Qubit(); 
    repeat { 
        X(t); 
        H(q); 
    } 
    until MResetZ(q) == One; 
    return MResetZ(t); 
}

Se superó el número máximo permitido de registros clásicos

  • Código de error: honeywell - 1000
  • Mensaje de error: 1000: Error de compilación: se superó el número máximo permitido de registros clásicos
  • Tipo: Error de trabajo
  • Origen: compilador de destino

Este error puede producirse cuando se envía un programa que requiere un número significativo de registros clásicos. Algunos patrones que pueden causar este problema son bucles for que contienen un gran número de iteraciones, instrucciones if profundamente anidadas o un gran número de medidas de cúbits.

operation ClassicalRegisterUsage() : Result { 
    use q = Qubit(); 
    use t = Qubit(); 
    mutable count = 0; 
    for _ in 1 .. 100 { 
        H(q); 
        if (MResetZ(q) == One) { 
            X(t); 
        } 
        if (MResetZ(t) == One) { 
            set count += 1; 
        } 
    } 
    return MResetZ(t); 
}

Advertencia QS5023

  • Código de error: Advertencia QS5023
  • Mensaje de error: target{0} no admite la comparación de los resultados de la medición
  • Tipo: Advertencia
  • Origen: compilador de destino

Advertencia QS5024

  • Código de error: Advertencia QS5024
  • Mensaje de error: Los resultados de medición no se pueden comparar aquí. El target{0} único admite la comparación de resultados de medición como parte de la condición de una instrucción if-o elif en una operación.
  • Tipo: Advertencia
  • Origen: compilador de destino

Advertencia QS5025

  • Código de error: Advertencia QS5025
  • Mensaje de error: No se puede usar una instrucción return aquí. target{0} No admite instrucciones return en bloques condicionales que dependen de un resultado de medición.
  • Tipo: Advertencia
  • Origen: compilador de destino

La advertencia sugiere que debe tener la instrucción return en el último bloque.

Advertencia QS5026

  • Código de error: Advertencia QS5026
  • Mensaje de error: La variable "{0}" no se puede reasignar aquí. En bloques condicionales que dependen de un resultado de medición, el target{1} único admite la reasignación de variables declaradas dentro del bloque.
  • Tipo: Advertencia
  • Origen: compilador de destino

Esta advertencia indica que el programa debe adaptarse para ejecutarse en el target hardware. Defina una operación solo para el cuerpo del bucle que prepara un estado y lo mide, y ejecútelo como un trabajo.

Advertencia QS5027

  • Código de error: Advertencia QS5027
  • Mensaje de error: el invocable {0} requiere funcionalidades en tiempo de ejecución que no son compatibles con .target{1}
  • Tipo: Advertencia
  • Origen: compilador de destino

Esta advertencia indica que el programa usa invocables que intentan realizar cálculos clásicos que no se admiten en el target hardware. Por ejemplo, algunos proveedores de hardware no admiten cálculos clásicos con Boolean tipos de datos o Int .

Advertencia QS5028

  • Código de error: Advertencia QS5028
  • Mensaje de error: Esta construcción requiere una funcionalidad clásica en tiempo de ejecución que no es compatible con target.
  • Tipo: Advertencia
  • Origen: compilador de destino

Esta advertencia indica que el Q# programa usa características clásicas avanzadas, que se deben optimizar durante el procesamiento de QIR . Si no se puede producir esta optimización, la ejecución del programa puede producir un error en un paso de compilación posterior.

Error de transformación específica de destino

  • Código de error: QATTransformationFailed
  • Mensaje de error: el mensaje será específico del programa.
  • Tipo: Error de trabajo
  • Origen: Servicio Azure Quantum

Este error puede producirse porque el servicio Azure Quantum no pudo transformar el programa (QIR) lo suficiente para poder ejecutar el programa Quantum Intermediate Representation en el especificado target. El mensaje de error contiene los detalles sobre QIR que representan el programa y lo que provocó un error en la validación. Sin embargo, no proporciona detalles sobre cómo está relacionado el error con el código fuente.

Los escenarios que pueden hacer que se produzca este error son muy amplios. La siguiente lista no contiene todas ellas, pero enumera algunas de las más comunes:

  • Acceso a los elementos de matriz que están fuera del intervalo de la matriz.

    operation IndexOutOfRange() : Result { 
    use register = Qubit[1]; 
    H(register[1]); 
    return MResetZ(register[1]); 
}

  • Uso de operaciones aritméticas que no son compatibles con target.

    operation UnsupportedArithmetic() : Result { 
    use q = Qubit(); 
    mutable theta = 0.0; 
    for _ in 1 .. 10 { 
        Rx(theta, q); 
        set theta += (0.25 * PI()); 
    } 
    return MResetZ(q); 
}