Ejercicio: Creación de diferentes estados de superposición con Q#

12 minutos

En las unidades anteriores, ha obtenido información sobre la superposición y la notación Dirac. ¡Basta de teoría por ahora! Vamos a explorar la superposición en Q# escribiendo algo de código.

En esta unidad, creará superposiciones cuánticas y se sumergirá en las probabilidades con Q# usando la función DumpMachine. La función DumpMachine vuelca información sobre el estado actual del sistema cuántico en el punto en el que es llamada.

Creación de un nuevo archivo Q#

Abra Visual Studio Code.
En Visual Studio Code, seleccione Archivo > Nuevo archivo de texto y guarde el archivo como Main.qs.
Seleccione Ver -> Paleta de comandos y escriba Q#: Establecer el perfil de destino de QIR de Azure Quantum. Presione ENTRAR.
Seleccione Q#: Sin restricciones.

Introducción a la superposición

Vamos a empezar con un programa sencillo que genera un bit aleatorio mediante un bit cuántico en superposición. Usará la función DumpMachine para ver el estado del cúbit en distintos puntos del programa.

Agregue el siguiente código al archivo Main.qs:

import Microsoft.Quantum.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

Aquí, se llama a DumpMachine cuatro veces:

Después de asignar el bit cuántico.
Después de colocar el bit cuántico en la superposición.
Después de medir el estado del bit cuántico.
Después de restablecer el bit cuántico.

La operación MResetZ se divide en dos operaciones: M y Reset. El motivo es que desea inspeccionar el estado después de la medición.

Para ejecutar el programa en el simulador integrado, haga clic en Ejecutar encima de la operación de Main o presione Ctrl+F5. La salida aparecerá en la consola de depuración.
La función DumpMachine crea una tabla de información en la que se describe el estado del registro del bit cuántico. En concreto, proporciona la amplitud de probabilidad, la probabilidad y la fase en radianes para cada estado de base.
Al final del programa, obtendrá un resultado de Zero o One. Ahora se analizará cada paso.
1. Bit cuántico inicializado: Cada bit cuántico asignado con la instrucción use se inicia en el estado $|0\rangle$. Por tanto, DumpMachine genera la información que se corresponde a un registro de un solo bit cuántico en el estado $|0\rangle$.
```
Initialized qubit:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
```
2. Bit cuántico después de aplicar H: Después de aplicar H, se prepara el bit cuántico en el estado de superposición $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.
```
Qubit after applying H:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
```
3. Bit cuántico después de la medición: Después de medir y almacenar el resultado, que puede ser Zero o One. Por ejemplo, si el estado resultante es One, el estado de los registros se contrae en $|1\rangle$ y ya no está en la superposición.
```
Qubit after the measurement:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
```
4. Bit cuántico después del restablecimiento: La operación Reset restablece el bit cuántico al estado $|0\rangle$. Recuerde que para cualquier operación de Q# siempre debe dejar los bits cuánticos que usa en el estado $|0\rangle$ para que lo puedan utilizar otras operaciones.
```
Qubit after resetting:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
```
Nota:

Las salidas pueden ser distintas porque el generador de números aleatorios es probabilístico. Las probabilidades de los resultados no son deterministas.

Explorar otros tipos de estados de superposición

Ahora que sabe cómo inspeccionar el estado de un registro, puede ver más operaciones que modifican el estado de los bits cuánticos y los colocan en una superposición.

El generador de números aleatorios actual produce Zero o One con una probabilidad del 50 %. Echemos un vistazo a un segundo ejemplo que genera números aleatorios con una probabilidad diferente.

Generador de bits aleatorio sesgado

Supongamos que desea crear un generador de bits aleatorio que está distorsionado, es decir, que la probabilidad de obtener Zero sea diferente de la probabilidad de obtener One.

Por ejemplo, desea el resultado Zero con la probabilidad $P$ y el resultado One con la probabilidad $1-P$. Este es un estado de bit cuántico válido que crea este generador de bits aleatorio:

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1-P}|1\rangle$$

Aquí, $\alpha=\sqrt{P}$ y $\beta=\sqrt{1-P}$ son las amplitudes de los estados base $|0\rangle$ y $|1\rangle$, respectivamente.

Este estado se puede obtener mediante la aplicación secuencial del operador $R_y(2\arccos \sqrt{P})$ a un bit cuántico en el estado $|0\rangle$. Puede conseguir este resultado en Q# mediante la operación Ry de la biblioteca estándar.

Sugerencia

Para obtener más información sobre las operaciones matemáticas que subyacen a las operaciones de un solo bit cuántico, consulte el tutorial sobre las Puertas de un solo bit cuántico en Quantum Kata.

Modifique Main.qs como en el ejemplo siguiente y, después, guarde el archivo. En este ejemplo se elige $\alpha$ para que sea aproximadamente $\frac13$.

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    Message("");
    DumpMachine(); // Dump the state of the qubit 
    Message("");
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

Para ejecutar el programa en el simulador integrado, haga clic en Ejecutar encima de la operación de Main o presione Ctrl+F5. La salida aparecerá en la consola de depuración.
Puede ver cómo DumpMachine muestra el estado esperado después de aplicar las operaciones y muestra las probabilidades asociadas. Observe que la probabilidad de obtener Zero es aproximadamente del 33,33 % y la probabilidad de obtener One es aproximadamente del 66,67 %. Por lo tanto, el generador de bits aleatorio está distorsionado.
```
The qubit is in the desired state.

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000


Your skewed random bit is:
Result: "One"
```
Nota:

La salida puede ser distinta porque el generador de números aleatorios es probabilístico. Las probabilidades de los resultados no son deterministas.

Superposición de varios bits cuánticos

Ahora se explorarán las superposiciones de un registro de muchos bits cuánticos. Por ejemplo, si el registro contiene tres bits cuánticos, tiene ocho estados base:

Por tanto, puede expresar un estado de tres bits cuánticos arbitrario como:

Aquí, $alpha_i$ son números complejos que cumplen $\sum|alpha_i|^2=1$.

Por ejemplo, puede colocar bits cuánticos en una superposición uniforme aplicando H a cada bit cuántico. Puede usar esta superposición uniforme para crear otra versión del generador de números aleatorios cuánticos que genere números de tres bits midiendo tres bits cuánticos en superposición en lugar de un bit cuántico tres veces.

Basis	Number
$\ket{000}$	0
$\ket{001}$	1
$\ket{010}$	2
$\ket{011}$	3
$\ket{100}$	4
$\ket{101}$	5
$\ket{110}$	6
$\ket{111}$	7

Modifique Main.qs como en el ejemplo siguiente y, después, guarde el archivo.
```
import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;
import Microsoft.Quantum.Arrays.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = ForEach(M, qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return BoolArrayAsInt(ResultArrayAsBoolArray(result));
}
```
Aquí verá tres conceptos:
- Ahora la variable qubits representa una matriz de Qubit con una longitud de tres.
- Las operaciones ApplyToEach y ForEach son útiles para medir y actuar en varios bits cuánticos, y usan menos código. Las bibliotecas de Q# ofrecen muchos tipos de operaciones y funciones que facilitan la escritura de programas cuánticos.
- Las funciones BoolArrayAsInt y ResultArrayAsBoolArray de la biblioteca Microsoft.Quantum.Convert transforman la matriz Result binaria devuelta por ForEach(M, qubits) en un entero.
Para ejecutar el programa, haga clic en Ejecutar encima de la operación Main o presione Ctrl+F5. La salida aparecerá en la consola de depuración.

Al usar DumpMachine, se ve cómo el acto de medir los tres bits cuánticos contrae el estado del registro a uno de los ocho estados de base posibles. Por ejemplo, si obtiene el resultado 3, significa que el estado del registro se ha contraído en $|110\rangle$.

The qubit register in a uniform superposition:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |110⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Result: "3"

Nota:

La salida puede ser distinta porque el generador de números aleatorios es probabilístico. Las probabilidades de los resultados no son deterministas.

La operación ForEach(M, qubit) mide cada bit cuántico en orden, y contrae gradualmente el estado. También puede volcar los estados intermedios después de cada medida. Para ello, modifique Main.qs como en el ejemplo siguiente y, después, guarde el archivo.

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        set results += [M(q)];
        DumpMachine();
    }
    Message(" ");
    Message("Your random number is: ");
    ResetAll(qubits);
    return BoolArrayAsInt(ResultArrayAsBoolArray(results));
}