Desarrollar programas de OpenQASM en el Microsoft Quantum Development Kit

El Microsoft Quantum Development Kit (QDK) proporciona diferentes entornos de desarrollo para programas de OpenQASM con integración de Azure Quantum. En este artículo, aprenderá a desarrollar y ejecutar OpenQASM código en los siguientes QDK entornos:

  • Extensión QDK en Visual Studio Code (VS Code)
  • Biblioteca QDK Python en Jupyter Notebook.

Prerrequisitos

  • Instalación de la versión más reciente de VS Code

  • Para trabajar directamente con OpenQASM archivos, instale la versión más reciente de la QDK extensión en VS Code.

  • Para trabajar con OpenQASM en Python y Jupyter Notebook, instale la versión más reciente de la extensión Python y la extensión Jupyter en VS Code.

  • Instale la versión más reciente de la biblioteca /> Python de adicional:

    pip install --upgrade "qdk[jupyter]"

Trabajar con OpenQASM en VS Code mediante la QDK extensión

Para escribir OpenQASM código en VS Code, abra un proyecto de Q# y cree un archivo OpenQASM con la extensión .qasm. El QDK reconoce automáticamente el .qasm archivo como OpenQASMy las QDK características de OpenQASM están disponibles a medida que escribe el código.

Las siguientes QDK características están disponibles para OpenQASM programas en VS Code:

  • Finalización de código
  • Lentes de código (Run, Histogram, Estimate, Debug y Circuit)
  • Resaltado de sintaxis y características básicas de sintaxis, como la coincidencia de llaves de apertura
  • Comprobación de errores en los archivos de origen OpenQASM
  • Depuración de puntos de interrupción y ejecución de scripts para archivos de origen de OpenQASM
  • Depuración con generación de circuitos en directo
  • Integración con Azure Quantum para la presentación de trabajos cuánticos

Para ejecutar el programa OpenQASM desde VS Code, puede usar el simulador local de /QDK o puede enviar el código como trabajo a Azure Quantum.

Ejecución del código en el QDK simulador local

Para ejecutar OpenQASM el código en el simulador cuántico local en VS Code, abra un .qasm archivo y, a continuación, seleccione el comando Ejecutar en el CodeLens al inicio del archivo. La salida del programa se muestra en el VS Code terminal.

Nota:

Si no elige un perfil de QIR target adecuado para el programa, obtendrá errores del compilador al ejecutar el OpenQASM código. Para obtener más información sobre los perfiles de target, consulte Tipos de perfiles de target en Azure Quantum.

Programas de ejemplo integrados

QDK incluye varios ejemplos de algoritmo cuántico integrados para OpenQASM. Para probar los algoritmos de ejemplo, escriba sample en un archivo vacío .qasm . Aparece una lista de finalización que contiene los algoritmos de ejemplo. Elija un ejemplo y ejecute el código generado.

Depuración local en VS Code

QDK incluye un depurador para OpenQASM. El depurador admite la depuración mediante puntos de interrupción y es capaz de representar el estado del programa.

Para iniciar el depurador, seleccione el comando Depurar en la lente de código.

En el modo de depuración, puede establecer puntos de interrupción en el código para ayudarle a depurar. El estado del programa se muestra en el panel EJECUTAR Y DEPURAR . Por ejemplo, puede ver los estados de las variables locales y los estados de cúbit.

Ejecute el código en Azure Quantum

Para obtener instrucciones sobre cómo enviar un trabajo a Azure Quantum desde VS Code, consulte Connect to Azure Quantum y envíe el trabajo.

Trabajar con OpenQASM en Python y Jupyter Notebook

Con la biblioteca de QDK Python, puede ejecutar código OpenQASM directamente y pasar circuitos OpenQASM como operaciones a programas de Q#. Escriba su OpenQASM código como una cadena de Python y luego use esa cadena para ejecutar, importar o compilar su OpenQASM código en el entorno Python.

Ejecute OpenQASM directamente en Python

Para ejecutar OpenQASM código directamente, use la run función desde el qdk.openqasm módulo. Por ejemplo, el código siguiente ejecuta 10 tomas en el simulador local de un programa simple OpenQASM con ruido:

from qdk import BitFlipNoise, TargetProfile
from qdk.openqasm import run
from qdk import qsharp

# Set the QIR target profile
qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

results = run(qasm_code, shots=10, noise=BitFlipNoise(0.1))
print(results)

Llamada a un OpenQASM programa en Q#

Puede usar la función para almacenar un programa /> :

from qdk import TargetProfile
from qdk.openqasm import import_openqasm
from qdk import qsharp

# Set the QIR target profile
qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

import_openqasm(qasm_code, name="bell")

Cuando bell forma parte de su entorno, puede ejecutarlo directamente desde una celda de Q#:

%%qsharp

use qs = Qubit[2];
bell(qs)

También puede usar la funcionalidad del QDK paquete con bell, como simulación ruidosa, representación de circuitos y generación de código.

Programas con parámetros OpenQASM

La celda siguiente crea un circuito OpenQASM que toma un ángulo theta como entrada y, a continuación, llama al circuito como una función de Python:

from qdk import TargetProfile
from qdk.openqasm import import_openqasm, ProgramType
from qdk import qsharp

qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qsharp.code.qasm_import import parameterized_circuit

parameterized_circuit(1.57)

Pasar un OpenQASM programa a Q#

Con la biblioteca de QDK Python, puede pasar directamente un programa OpenQASM a un programa de Q#. Por ejemplo, el código siguiente crea un OpenQASM programa llamado Entangle y, a continuación, usa Entangle como una operación en un programa de Q#:

from qdk import TargetProfile
from qdk.openqasm import import_openqasm
from qdk import qsharp

# Set the QIR target profile
qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    qubit[2] qs;
    h qs[0];
    cx qs[0], qs[1];
    """

import_openqasm(qasm_code, name="Entangle")

qsharp.eval("{ use qs = Qubit[2]; Entangle(qs); MResetEachZ(qs) }")

Al importar Q# e importar OpenQASM programas en un entorno de Python con qsharp.eval y import_openqasm, estos programas se convierten en objetos Python a los que puede llamar en el código de Python. Por ejemplo, el código siguiente crea un programa de Q# denominado TestAntiCorrelation y pasa el EntangleOpenQASM programa a TestAntiCorrelation:

qsharp.eval("""
    operation TestAntiCorrelation(entangler : Qubit[] => Unit) : Result[] {
        use qs = Qubit[2];
        X(qs[1]);
        entangler(qs);
        MResetEachZ(qs)
    }
    """)

from qsharp.code import Entangle, TestAntiCorrelation

TestAntiCorrelation(Entangle)

Compilar programas OpenQASM en QIR

Puede compilar código de OpenQASM en Quantum Intermediate Representation (QIR) con la función compile.

Por ejemplo, la celda siguiente compila código para un circuito con parámetros OpenQASM en QIR:

from qdk import TargetProfile
from qdk.openqasm import import_openqasm, ProgramType
from qdk import qsharp

qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qsharp.code.qasm_import import parameterized_circuit

bound_compilation = qsharp.compile(parameterized_circuit, 1.57)
print(bound_compilation)

Nota:

Debe usar la biblioteca Python de QDK para compilar programas OpenQASM que aceptan variables de entrada en QIR. No se pueden compilar programas parametrizados OpenQASM en QIR con la extensión QDK en VS Code.

Desarrollo continuo OpenQASM en QDK

La compatibilidad con OpenQASM en QDK está en curso.

Para obtener una lista de las características de OpenQASM que están en desarrollo en QDK, consulte Limitaciones y problemas conocidos en la wiki del repositorio de QDK GitHub.

Resumen

QDK ofrece dos opciones para desarrollar y ejecutar programas OpenQASM.

  • Trabajar directamente con archivos .qasm con la extensión QDK en VS Code
  • Escriba programas como cadenas de Python mediante OpenQASM e importe los programas usando la biblioteca de Python QDK

Las herramientas de desarrollo como CodeLends, IntelliSense, autocompletado de código y depuración de puntos de parada solo están disponibles en la extensión VS Code.

Solo la librería de Python permite pasar Q# y OpenQASM como invocables de objetos Python y compilar programas de OpenQASM que aceptan variables de entrada en QIR.

  • Last updated on