Ejercicio: Creación de un entrelazamiento cuántico con Q#

  • 7 minutos

En la unidad anterior, ha aprendido sobre el concepto de entrelazamiento cuántico y los estados de Bell.

En esta unidad, usará el Quantum Development Kit de Azure (QDK) para escribir código Q# que crea estados de Bell entrelazados entre dos cúbits. Para crear el primer estado de Bell, aplique dos operaciones cuánticas: la operación Hadamard y la operación Controlled-NOT (CNOT).

En primer lugar, vamos a comprender cómo funcionan estas operaciones y por qué crean estados entrelazados.

La operación Hadamard

Recuerde que la operación Hadamard, o H, coloca un cúbit que se encuentra en un estado puro $\ket{0}$ o $\ket{1}$ en un estado de superposición igual.

$$ H \ket{0} = \frac1{\sqrt2} \ket{0} + \frac1{\sqrt2} \ket{1}$$ $$ H \ket{1} = \frac1{\sqrt2} \ket{0} - \frac1{\sqrt2} \ket{1}$$

El primer paso para crear el estado de Bell es realizar una operación Hadamard en uno de los cúbits.

Operación Controlled-NOT (CNOT)

Cuando dos cúbits están entrelazados, el estado de un cúbit depende del estado del otro cúbit. Por lo tanto, para entrelazar dos cúbits, se debe aplicar una operación de múltiples cúbits, la cual actúa sobre ambos cúbits simultáneamente. La operación Controlled-NOT o CNOT es una operación de varios qubits que ayuda a crear entrelazamiento.

La operación CNOT toma dos cúbits como entrada. Uno de los cúbits es el cúbit de control y el otro cúbit es el target cúbit. Si el cúbit de control está en estado $\ket{1}$ , la operación CNOT voltea el estado del target cúbit. De lo contrario, CNOT no hace nada.

Por ejemplo, en los siguientes estados de dos cúbits, el cúbit de control es el cúbit izquierdo y el target cúbit es el cúbit más a la derecha.

Entrada a CNOT Salida de CNOT
$\ket{00}$ $\ket{00}$
$\ket{01}$ $\ket{01}$
$\ket{10}$ $\ket{11}$
$\ket{11}$ $\ket{10}$

En Q#, la CNOT operación actúa en una matriz de dos cúbits y voltea el segundo cúbit solo si el primer cúbit es One.

Entrelazamiento con operaciones Hadamard y CNOT

Supongamos que tienes un sistema de dos cúbits en el estado $\ket{00}$. En este estado, los cúbits no están entrelazados. Para colocar estos cúbits en el estado de Bell entrelazado $\ket{\phi^+}=\frac1{\sqrt2}(\ket{00}+\ket{11})$, aplique las operaciones Hadamard y CNOT.

Así es como funciona:

  1. Elija un cúbit en el estado c para que sea el cúbit de control y el otro cúbit para que sea el target cúbit. Aquí, elegimos el cúbit más a la izquierda para que sea el control y el cúbit más a la derecha para que sea el target.

  2. Coloque solo el cúbit de control en un estado de superposición igual. Para ello, aplique una operación H solo al cúbit de control:

    $$H \ket{0_c} = \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c})$$

    Nota:

    Los subíndices ${}_c$ y ${}_t$ especifican el control y target los cúbits, respectivamente.

  3. Aplique una operación CNOT al par de cúbits. Recuerde que el cúbit de control está en un estado de superposición y el target cúbit está en estado $\ket{0_t}$ .

    $ \begin{alineado} CNOT \frac{{1}{\sqrt{{2}}(\ket{0_c}+\ket{1_c})\ket{0_t}&= CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(CNOT \ket{0_c 0_t} + CNOT \ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t}) \end{alineado}$

El estado $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ está entrelazado. Este estado entrelazado en particular es uno de los cuatro estados de Bell, $\ket{\phi^{+}}$.

Nota:

En la computación cuántica, las operaciones a menudo se denominan puertas. Por ejemplo, la puerta H y la puerta CNOT.

Creación de un entrelazamiento cuántico en Q#

Para crear el estado de Bell utilizando el código Q#, siga estos pasos en Visual Studio Code (VS Code):

  1. Abra VS Code.
  2. Abra el menú Archivo y elija Nuevo archivo de texto para crear un nuevo archivo.
  3. Guarde el archivo como Main.qs.

Crea un estado de Bell

Para crear el estado de Bell $\ket{\phi^+}$ en Q#, siga estos pasos:

  1. Importe el espacio de nombres Std.Diagnostics de la biblioteca estándar Q# para poder usar la función DumpMachine. Esta función muestra información sobre los estados de cúbit cuando se llama a la función en el código. Para importar el espacio de nombres, copie el siguiente código Q# en el archivo Main.qs.

    import Std.Diagnostics.*;

  2. Cree la operación Main que devuelve dos valores de tipo Result, que son los resultados de medición de los cúbits.

    import Std.Diagnostics.*;

operation Main() : (Result, Result) {
    // Your code goes here
}

  3. Dentro de la operación Main, asigne dos cúbits para entrelazar, q1 y q2.

    import Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
}

  4. Aplique la puerta Hadamard, , Hal cúbit de control,q1 . Esto coloca solo ese cúbit en un estado de superposición. A continuación, aplique la puerta CNOT, CNOT, a ambos qubits para entrelazarlos. El primer argumento para CNOT es el cúbit de control y el segundo argumento es el target cúbit.

    import Std.Diagnostics.*; 

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);
}

  5. Use la DumpMachine función para mostrar el estado de los cúbits después de entrelazarlos. Tenga en cuenta que DumpMachine no realiza una medición en los cúbits, por lo que DumpMachine no afecta a los estados de cúbit.

    import Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);

    DumpMachine();
}

  6. Use la M operación para medir los cúbits y almacenar los resultados en m1 y m2. A continuación, use la Reset operación para restablecer los cúbits.

    import Std.Diagnostics.*;

operation Main() : (Result, Result) {

    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);
    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

}

  7. Devuelve los resultados de medición de los cúbits utilizando la instrucción return. Este es el programa final en su archivo Main.qs :

    import Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);

    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

  8. Para ejecutar el programa en el simulador integrado, elige la lente Ejecutar código que está encima de la operación de Main o presiona Ctrl+F5. La salida aparece en la consola de depuración.

  9. Los resultados de la medición se correlacionan, por lo que al final del programa se obtiene un resultado de (Zero, Zero) o (One, One) con la misma probabilidad. Vuelva a ejecutar el programa varias veces y observe la salida para convencerse de la correlación.

  10. Para visualizar el diagrama del circuito, elija la lente de código de Circuito encima de la operación Main. El diagrama del circuito muestra la puerta Hadamard aplicada al primer cúbit y la puerta CNOT aplicada a ambos cúbits.

    Captura de pantalla del circuito que crea el estado bell.

Crear otros estados de Bell

Para crear otros estados de Bell, aplique pauli $X$ o $Z$ operaciones adicionales a los cúbits.

Por ejemplo, para crear el estado $\ket{\phi^-}=\frac1{\sqrt2}(\ket{00}-\ket{11})$Bell, aplique la operación Pauli $Z$ al cúbit de control después de aplicar la puerta Hadamard, pero antes de aplicar la puerta CNOT. La $Z$ operación invierte el estado $\ket{+}$ en $\ket{-}$.

Nota:

Los estados $\frac{1}{\sqrt{2}}(\ket{0}+\ket{1})$ y $\frac{1}{\sqrt{2}}(\ket{0} - \ket{1})$ también se conocen como $\ket{+}$ y $\ket{-}$, respectivamente.

Aquí se muestra cómo crear el $\ket{\phi^-}$ estado:

  1. Cree dos cúbits en el estado $\ket{00}$.

  2. Coloque el cúbit de control en un estado de superposición con la operación $H$

    $$H \ket{0_c} = \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c}) = \ket{+_c}$$

  3. Aplique la $Z$ operación al cúbit de control.

    $$Z \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c}) = \frac{1}{\sqrt{2}}(\ket{0_c} - \ket{1_c}) = \ket{-_c}$$

  4. Aplique la operación CNOT al cúbit de control y al cúbit target, que está en el estado $\ket{0_t}$.

    $ \begin{alineado} CNOT \frac{{1}{\sqrt{{2}}(\ket{0_c}-\ket{1_c})\ket{0_t}&= CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(CNOT \ket{0_c 0_t} - CNOT \ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 1_t}) \end{alineado}$

Para crear el estado Bell $\ket{\phi^-}$ en Q#, reemplace el código de su Main.qs por el código siguiente:

import Std.Diagnostics.*;
    
operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    
    H(q1);
    Z(q1); // Apply the Pauli Z operation to the control qubit
    CNOT(q1, q2);
    
    DumpMachine();
    
    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

Del mismo modo, puede crear los estados $\ket{\psi^+}$ and $\ket{\psi^-}$ de Bell aplicando las operaciones Pauli $X$ y $Z$ a los cúbits.

  • Para crear el estado de Bell $\ket{\psi^+}=\frac1{\sqrt2}(\ket{01}+\ket{10})$, aplique la puerta Pauli $X$ al cúbit target después de aplicar la puerta Hadamard al cúbit de control. A continuación, aplique la puerta CNOT.
  • Para crear el estado Bell $\ket{\psi^-}=\frac1{\sqrt2}(\ket{01}-\ket{10})$, aplique Pauli $Z$ al cúbit de control y aplique Pauli $X$ al cúbit target después de aplicar la puerta Hadamard al cúbit de control. A continuación, aplique la puerta CNOT.

En la siguiente unidad, aprenderá a usar el entrelazamiento para enviar información cuántica, un proceso conocido como teletransportación cuántica.