Visualización de diagramas de circuitos cuánticos con Q#

Artículo
10/23/2024

Los diagramas de circuitos cuánticos son una representación visual de las operaciones cuánticas. Muestran el flujo de cúbits a través del programa cuántico, incluidas las puertas y medidas aplicadas a ellos.

En este artículo, aprenderá a representar visualmente algoritmos cuánticos con diagramas de circuitos cuánticos mediante Visual Studio Code o Cuadernos de Jupyter Notebook.

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

Requisitos previos

Código de VS

La versión más reciente de Visual Studio Code o abrir VS Code en la Web.
La última versión de la extensión Kit de desarrollo de Azure Quantum.
Los paquetes más recientes de Azure Quantum qsharp y azure-quantum Python.
```
python -m pip install --upgrade qsharp azure-quantum
```

Jupyter Notebooks

La versión más reciente de Visual Studio Code o abrir VS Code en la Web.
VS Code con las extensiones kit de desarrollo de Azure Quantum, Python y Jupyter instaladas.
Los paquetes y Azure Quantum qsharp más recientes y el ipykernel paquete.qsharp-widgets
```
python -m pip install --upgrade qsharp qsharp-widgets ipykernel
```

Circuitos cuánticos con Visual Studio Code

Siga estos pasos para visualizar circuitos cuánticos de Q# programas en Visual Studio Code. Para más información sobre las convenciones de diagrama de circuitos cuánticos, consulte Convenciones de circuitos cuánticos.

Visualización de diagramas de circuitos para un Q# programa

Abra un Q# archivo en Visual Studio Code o cargue uno de los ejemplos cuánticos.
Para visualizar el circuito cuántico del Q# programa, seleccione Ver -> Paleta de comandos y escriba "circuito" que debe abrir la Q#opción : Mostrar circuito . También puede hacer clic en Circuito en la lista de comandos anteriores Main()a .
El circuito se muestra en la ventana del Q# circuito. Por ejemplo, el siguiente circuito corresponde a una operación que coloca un cúbit en una superposición y, a continuación, lo mide. El diagrama de circuitos muestra un registro de cúbits que se inicializa en el estado |0⟩. A continuación, se aplica una puerta Hadamard, H, al cúbit, seguida de una operación de medición, que se representa mediante un símbolo de medidor.

Visualización de diagramas de circuitos para operaciones

Puede visualizar el circuito cuántico para una sola Q# operación. Para ello, haga clic en el botón Circuito de la lente de código que aparece encima de la declaración de operación.

Captura de pantalla de Visual Studio Code en la que se muestra cómo visualizar los circuitos en el Q# panel circuitos después de depurar el programa.

Visualización de diagramas de circuitos al depurar

Al depurar un Q# programa, puede visualizar el circuito cuántico en función del estado actual del programa.

Seleccione el botón Depurar de la lista de comandos de lente de código anteriores Main()a .
En la vista Ejecutar y depurar del lado izquierdo, expanda la sección Circuito cuántico en el panel Variables para mostrar el circuito mientras recorre el programa.
Puede recorrer el código y establecer puntos de interrupción en varios puntos para ver la actualización del circuito a medida que se ejecuta el programa.
El circuito cuántico actual se muestra en el Q# panel Circuito. Este diagrama de circuitos representa el estado actual del simulador, es decir, las puertas que se han aplicado hasta el punto de ejecución actual.

Circuitos cuánticos con cuadernos de Jupyter Notebook

En Jupyter Notebooks, puede visualizar circuitos cuánticos mediante el qsharp-widgets paquete. Este paquete proporciona un widget que representa un diagrama de circuito cuántico como una imagen SVG.

En Visual Studio Code, seleccione Ver > Paleta de comandos y seleccione Crear: Nuevo Jupyter Notebook.
En la primera celda del cuaderno, ejecute el código siguiente para importar el Q# módulo.
```
import qsharp
```
Agregue una nueva celda y escriba el Q# código. Por ejemplo, el código siguiente prepara un estado de Campana.
```
%%qsharp

// Prepare a Bell State.
use register = Qubit[2];
H(register[0]);
CNOT(register[0], register[1]);
```
Puede usar la dump_circuit() función para mostrar un circuito cuántico basado en el estado actual del programa. Por ejemplo, el diagrama del circuito muestra dos registros de cúbits que se inicializan en el estado |0⟩. A continuación, se aplica una puerta Hadamard, H, al primer cúbit. Después, se aplica una puerta CNOT usando el primer cúbit como control, que se representa como un punto, y el segundo cúbit como target, que se representa como una X.
```
qsharp.dump_circuit()
```
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
Puede visualizar circuitos cuánticos como una imagen SVG mediante el qsharp-widgets paquete. En este caso, la puerta CNOT se representa como una línea que conecta los dos cúbits, con un punto en el cúbit de control y una cruz circunscripta en el target cúbit. Para más información, consulte Convenciones de circuitos cuánticos.
```
from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())
```

Visualización de diagramas de circuitos para una expresión de entrada

Puede generar un diagrama de circuitos para cualquier programa con una expresión de entrada llamando qsharp.circuit() a y pasando la expresión de entrada como argumento.

Por ejemplo, agregue una nueva celda y copie el código siguiente, que prepara un estado GHZ.

%%qsharp

import Std.Diagnostics.*;
import Std.Measurement.*;

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    H(qs[0]);
    ApplyToEach(CNOT(qs[0], _), qs[1...]);

    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Agregue una nueva celda y ejecute el código siguiente para visualizar el circuito. Por ejemplo, prepare un estado GHZ con 3 cúbits.
```
Circuit(qsharp.circuit("GHZSample(3)"))
```

Visualización de diagramas de circuitos para operaciones con cúbits

Puede generar diagramas de circuito para cualquier operación que tome cúbits o matrices de cúbits. El diagrama muestra tantos cables como hay cúbits de entrada, además de los cúbits adicionales que se asignan dentro de la operación. Cuando la operación toma una matriz de cúbits (Qubit[]), el circuito muestra la matriz como un registro de 2 cúbits.

Agregue una nueva celda y copie el ejemplo siguiente. Este código prepara un estado cat.

%%qsharp

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

Agregue una nueva celda y ejecute el código siguiente para visualizar el circuito de la PrepareCatState operación.
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Condiciones que afectan a los diagramas de circuitos

Al visualizar circuitos cuánticos, las condiciones siguientes pueden afectar a la visualización del diagrama de circuitos.

Circuitos dinámicos

Los diagramas de circuitos se generan ejecutando toda la lógica clásica dentro de un Q# programa y realizando un seguimiento de los cúbits asignados o puertas que se han aplicado. Los bucles y condicionales se admiten siempre y cuando solo se ocupen de valores clásicos.

Sin embargo, los programas que contienen bucles y expresiones condicionales que usan resultados de medición de cúbits son más complicados de representar con un diagrama de circuitos. Por ejemplo, una expresión como la siguiente

if (M(q) == One) {
   X(q)
}

no se puede representar con un diagrama de circuito sencillo, ya que las puertas están condicionales a un resultado de medición. Este circuito se denomina circuito dinámico .

Los diagramas de circuitos se pueden generar para circuitos dinámicos ejecutando el programa en el simulador cuántico y trazando las puertas a medida que se aplican. Esto se denomina modo de seguimiento, ya que se realiza el seguimiento de los cúbits y las puertas a medida que se realiza la simulación.

La desventaja de los circuitos rastreados es que solo capturan el resultado de la medición y las aplicaciones de puerta consiguientes para una sola simulación. En el ejemplo anterior, si el resultado de la medición es Zero, no verá la X puerta en el diagrama. Otra ejecución de la simulación puede mostrar un circuito ligeramente diferente.

Perfil Target

El perfil seleccionado target actualmente influye en cómo se generan los diagramas de circuitos. Target Los perfiles se usan para especificar las funcionalidades del target hardware y las restricciones que se imponen en el programa cuántico.

Cuando el target perfil se establece en RI adaptable sin restricciones o QIR, los diagramas de circuitos muestran las operaciones cuánticas que se invocan en el Q# programa. Cuando el target perfil se establece en la base de QIR, los diagramas de circuitos muestran las operaciones cuánticas que se ejecutarían en hardware si el programa se envía a Azure Quantum con este target perfil.

Nota:

Para seleccionar el target perfil en VS Code, seleccione Ver -> Paleta de comandos y seleccione Q#: Establezca el perfil de Azure Quantum QIRtarget. Puede seleccionar QIR base, QIR Adaptive RIo unrestricted en la lista desplegable.
Para seleccionar el target perfil en Python, llame a qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)qsharp.init(target_profile=qsharp.TargetProfile.Base)o qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted).

En concreto, se aplican descomposición de puertas que harían que el circuito resultante sea compatible con las funcionalidades del target hardware. Estas son las mismas descomposición que se aplicarían durante la generación de código y el envío a Azure Quantum.

Por ejemplo, considere el siguiente Q# programa que mide un cúbit y una matriz de cúbits.

import Std.Measurement.*;

operation Main() : (Result, Result[]) {
    // The `M` operation performs a measurement of a single qubit in the
    // computational basis, also known as the Pauli Z basis.
    use q = Qubit();
    let result = M(q);
    Reset(q);

    // The `MeasureEachZ` operation measures each qubit in an array in the
    // computational basis and returns an array of `Result` values.
    use qs = Qubit[2];
    let results = MeasureEachZ(qs);

    return (result, results);
}

Cuando target profile se establece en Unrestricted o QIR Adaptive RI, las puertas mostradas en el circuito corresponden exactamente a las operaciones cuánticas que se invocan en el Q# programa.
Cuando el target perfil es base QIR, el circuito tiene un aspecto diferente. Dado que el perfil targets base no permite la reutilización de cúbits después de la medición, la medida ahora se realiza en un cúbit entrelazado en su lugar. Puesto Reset que la operación no es una puerta admitida en el perfil base, se quita. El circuito resultante coincide con lo que se ejecutaría en hardware si este programa se envía a Azure Quantum con este target perfil.

Compartir a través de