Visualización de diagramas de circuitos cuánticos con QDK

Los diagramas de circuitos cuánticos son una representación visual de los algoritmos cuánticos. Los diagramas de circuitos muestran el flujo de cúbits a través de un programa cuántico, incluidas las puertas y medidas que el programa aplica a los cúbits.

En este artículo, aprenderá a crear diagramas de circuitos para programas Q# y OpenQASM con Microsoft Quantum Development Kit (QDK) usando Visual Studio Code (VS Code) y Jupyter Notebook.

Para más información sobre los diagramas de circuitos cuánticos, consulte Convenciones de diagrama de circuitos cuánticos.

Requisitos previos

Para crear diagramas de circuitos a partir de archivos Q# y OpenQASM en VS Code, instale lo siguiente:

• La versión más reciente de VS Code o abra VS Code para la Web.
• La versión más reciente del complemento QDK en VS Code.

Para crear diagramas de circuitos a partir de programas de Python en Jupyter Notebook, instale lo siguiente:

• La extensión de Python y la extensión Jupyter en VS Code.

• La versión más reciente de la qdk librería de Python con el extra jupyter.

  python -m pip install --upgrade "qdk[jupyter]"
  

Visualización de circuitos cuánticos en VS Code

Con la QDK extensión en VS Code, puede crear diagramas de circuitos para archivos Q# (.qs) y OpenQASM (.qasm).

Para ver un diagrama de circuitos en VS Code, siga estos pasos:

1. Abra un archivo Q# o OpenQASM en VS Code, o cargue uno de los ejemplos cuánticos de QDK.
2. Elija el comando Circuit en la lente de código que precede al programa.

Se QDK abre la ventana Circuito y se muestra el diagrama de circuitos del programa. Por ejemplo, el siguiente diagrama de circuitos corresponde a un programa que genera un bit aleatorio. El circuito coloca el cúbit en un estado de superposición y, a continuación, mide el cúbit.

Visualización de diagramas de circuitos para operaciones individuales de Q#

Para visualizar el circuito cuántico para una operación individual en un archivo Q#, elija el comando Circuit en la lente de código que precede a la operación.

Visualización de diagramas de circuitos al depurar

Al usar el VS Code depurador en un programa de Q#, puede visualizar el circuito cuántico en función del estado del programa en el punto de interrupción actual del depurador.

1. Elija el comando Depurar en el CodeLens que antecede a su operación de punto de entrada.
2. En el panel Ejecutar y depurar , expanda la lista desplegable Circuito cuántico en el menú VARIABLES . Se abre el panel QDK Circuito, que muestra el circuito a medida que recorre el programa.
3. Establezca puntos de interrupción y recorra el código para ver cómo se actualiza el circuito a medida que se ejecuta el programa.

Visualización de circuitos cuánticos en Jupyter Notebook

En Jupyter Notebook, puede visualizar circuitos cuánticos para programas Q# y OpenQASM con los módulos de Python qdk.qsharp y qdk.widgets. El widgets módulo proporciona un widget que representa un diagrama de circuitos cuánticos como una imagen SVG.

Para obtener más ejemplos de generación de Jupyter Notebook de circuito en , consulte el cuaderno de ejemplo Circuitos en el QDK repositorio de GitHub.

Visualización de diagramas de circuitos para programas de Q#

Para ver un diagrama de circuitos para un programa de Q# en Jupyter Notebook, siga estos pasos:

1. En VS Code, abra el menú Ver y elija Paleta de comandos.

2. Escriba Crear: Nuevo Jupyter Notebook. Se abre un archivo vacío Jupyter Notebook en una nueva pestaña.

3. En la primera celda del cuaderno, ejecute el código siguiente para importar el qsharp módulo.

   from qdk import qsharp
   

4. Cree una nueva celda y escriba el código de Q#. Por ejemplo, el código siguiente prepara un estado de Bell.

   %%qsharp
   
   // Prepare a Bell State.
   operation BellState() : Unit {
       use register = Qubit[2];
       H(register[0]);
       CNOT(register[0], register[1]);
   }
   

5. Para mostrar un diagrama de circuito cuántico, pase la operación de Q# a la qsharp.circuit función. Ejecute el código siguiente en una nueva celda:

   qsharp.circuit("BellState()")
   

   La salida es similar a esta:

   q_0    ── H ──── ● ──
   q_1    ───────── X ──
   

6. Para representar una imagen SVG del circuito cuántico, use el widgets módulo . Cree una nueva celda y ejecute el código siguiente para visualizar el mismo circuito que creó en la celda anterior.

   from qdk.widgets import Circuit
   
   Circuit(qsharp.circuit("BellState()"))
   

   El diagrama de circuitos tiene este aspecto:

   

Visualización de diagramas de circuitos para operaciones que toman cúbits como entrada

En el ejemplo de estado de Bell anterior, la operación BellState no toma cúbits como entrada. Si la operación toma cúbits o matrices de cúbits como entrada, omita los paréntesis al pasar la operación para dibujar diagramas de circuitos.

Por ejemplo, siga estos pasos para dibujar diagramas de circuitos para una operación que toma cúbits:

1. En una nueva celda, ejecute el siguiente código de Q#. Este código prepara un estado cat.

   %%qsharp
   
   operation PrepareCatState(register : Qubit[]) : Unit {
       H(register[0]);
       ApplyToEach(CNOT(register[0], _), register[1...]);
   }
   

2. Para dibujar el circuito como un diagrama de texto, ejecute el código siguiente:

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

3. Para representar el diagrama del circuito como una imagen SVG, ejecute el código siguiente:

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

Cuando la operación toma una matriz de cúbits (Qubit[]), el circuito muestra la matriz como un registro de dos cúbits.

Visualización de diagramas de circuitos para programas OpenQASM

Para ver un diagrama de circuitos para un programa OpenQASM en Jupyter Notebook, siga estos pasos:

1. En VS Code, abra el menú Ver y elija Paleta de comandos.

2. Escriba Crear: Nuevo Jupyter Notebook. Se abre un archivo vacío Jupyter Notebook en una nueva pestaña.

3. En la primera celda del cuaderno, ejecute el código siguiente para importar los objetos necesarios para crear y llamar a funciones de OpenQASM con la QDK biblioteca de Python:

   from qsharp.openqasm import import_openqasm, ProgramType
   

4. En una nueva celda, escriba el programa OpenQASM en una cadena de Python y pase la cadena a la import_openqasm función. Para llamar al programa en el código de Python, asigne un nombre a la función y establezca program_type en ProgramType.File.

   source = """
       include "stdgates.inc";
       bit[2] c;
       qubit[2] q;
       h q[0];
       cx q[0], q[1];
       c = measure q;
   """
   
   import_openqasm(source, name="bell", program_type=ProgramType.File)
   

5. En una nueva celda, importe el programa OpenQASM como una función de Python y llame al programa para obtener los resultados de la medición.

   from qsharp.code.qasm_import import bell
   
   bell()
   

6. Para dibujar el circuito como diagrama de texto, ejecute el código siguiente en una nueva celda:

   from qdk.qsharp import circuit
   
   circuit(bell)
   

   La salida es similar a esta:

   q_0    ── H ──── ● ──── M ──
                │      ╘═══
   q_1    ───────── X ──── M ──
                       ╘═══
   

7. Para representar el diagrama del circuito como una imagen SVG, ejecute el código siguiente en una nueva celda:

   from qsharp_widgets import Circuit
   
   Circuit(qsharp.circuit(bell))
   

   El diagrama de circuitos tiene este aspecto:

   

Contenido relacionado

• Exploración de diagramas de circuitos en QDK
• Convenciones de diagrama de circuitos cuánticos