Ejecuta simulaciones cuánticas con el paquete QDKPython

El MicrosoftQuantum Development Kit paquete (QDK) Python incluye simuladores cuánticos locales que puede usar para probar y desarrollar programas cuánticos. En este artículo se explica cómo instalar los simuladores y ejecutar los programas Q#, OpenQASM, Qiskit y QIR en Python o Jupyter Notebook.

El QDKPython paquete incluye cuatro simuladores principales:

• Simulador disperso
• Simulador de estabilizador
• GPU simulador
• CPU simulador

Para obtener más información sobre los QDK simuladores cuánticos, consulte Introducción a los simuladores cuánticos en QDK.

Para ejecutar programas Q# u OpenQASM directamente en la extensión QDK para Visual Studio Code (VS Code), consulta Ejecutar simulaciones cuánticas en la extensión QDK para Visual Studio Code.

Prerequisites

Para seguir los ejemplos de Jupyter Notebook de este artículo, instale estas herramientas:

• Un entorno Python con Python la versión 3.10 o posterior y pip
• La versión más reciente de Visual Studio Code (VS Code)
• Las versiones más recientes de la Python extensión y la extensión de Jupyter en VS Code

Instalación de los simuladores

Para usar los simuladores cuánticos en Python y Jupyter Notebook, instale la versión más reciente del qdkPython paquete con el jupyter adicional:

pip install --upgrade "qdk[jupyter]"

Los simuladores no requieren el jupyter extra, pero el extra agrega el módulo qdk.widgets para visualizar los resultados de la simulación en Jupyter Notebook.

Seleccione un simulador basado en el marco de programación cuántica y la API Python que use.

Llamada al simulador disperso

El simulador disperso admite programas Q#, OpenQASM y Qiskit. En esta tabla se muestra cómo ejecutar 10 shots con el paquete qdk en cada framework.

Por ejemplo, siga estos pasos para ejecutar el programa de par Q# Bell en un cuaderno de Jupyter Notebook en VS Code:

1. En VS Code, seleccione Ver>paleta de comandos.

2. Ingrese Crear: Nuevo cuaderno de Jupyter. Se abre un archivo de cuaderno vacío en una nueva pestaña.

3. En la primera celda, importe el qsharp módulo desde el qdk paquete.

   from qdk import qsharp
   

4. En una nueva celda, use el %%qsharp comando magic para escribir el Q# código.

   %%qsharp
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
       PrepareBellPair(q1, q2);
       (MResetZ(q1), MResetZ(q2))
   }
   
   operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
       H(q1);
       CNOT(q1, q2);
   }
   

5. Crear una celda nueva. Para ejecutar el programa Q# en el simulador disperso, llame a la función run desde el módulo qsharp y especifique el número de ejecuciones.

   qsharp.run("Main()", shots=10)
   

Ejecutar el simulador de estabilizadores

El simulador de estabilizadores ejecuta de forma eficiente circuitos amplios dominados por Clifford. La ramificación del estabilizador también admite un número limitado de operaciones distintas de Clifford, como las puertas $T$ y $T^\dagger$ y las rotaciones Pauli de ángulo arbitrario. Dado que el número de ramas puede crecer exponencialmente con el número de operaciones no Clifford, use un simulador de estado completo para circuitos con una evolución no Clifford sustancial.

El simulador de estabilizador admite los programas Q#, OpenQASM, Qiskit y QIR. Esta tabla muestra cómo ejecutar 10 tiradas en cada entorno.

Las API NeutralAtomDevice y NeutralAtomBackend se utilizan específicamente para simulaciones en ordenadores cuánticos de átomos neutros. Para obtener más información, consulte Descripción general del simulador de dispositivos de átomos neutros.

Por ejemplo, este Python código ejecuta un OpenQASM programa con una puerta no-Clifford $T$ en el simulador de estabilizador:

from qdk.openqasm import run

qasm_code = """
include "stdgates.inc";
qubit[1] q;
bit[1] result;

h q[0];
t q[0];
h q[0];
result = measure q;
"""

run(qasm_code, type="stabilizer", shots=1000)

La puerta $T$ crea ramificaciones del estabilizador. La medición final muestrea la interferencia entre esas ramificaciones.

Llamar a los simuladores GPU y CPU

Los simuladores GPU y CPU admiten programas Qiskit y QIR. Esta tabla muestra cómo ejecutar 10 tiradas en el simulador GPU con el paquete qdk en cada entorno. Para usar el simulador CPU, reemplace cpu por gpu en el parámetro de tipo de simulador.

Por ejemplo, este Python código convierte un programa simple OpenQASM en QIR y ejecuta el QIR en el simulador GPU:

from qdk.openqasm import compile
from qdk.simulation import run_qir

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

qir = compile(qasm_code)
run_qir(qir, type="gpu", shots=10)

Contenido relacionado

• Configurar el MicrosoftQuantum Development Kit
• Cómo instalar QDK para la corrección de errores