Ejercicio: Uso del entrelazamiento para teletransportar con Q#

  • 9 minutos

En la unidad anterior, ha revisado los pasos del protocolo de teletransportación cuántica. ¡Ahora es tu turno para ayudar a Alice y Bob con su experimento de teletransportación cuántica!

En esta unidad creará un programa de teletransportación cuántica en Q# que usa el protocolo de teletransportación cuántica para enviar el estado de un cúbit de Alice a Bob.

Creación de un programa de teletransportación cuántica en Q#

  1. Abra Visual Studio Code.
  2. Seleccione Archivo > Nuevo archivo de texto y guárdelo como Main.qs.
  3. Seleccione Ver> - Paleta de comandos y escriba Q#: Establezca el targetperfil de QIR de Azure Quantum. Presione ENTRAR.
  4. Seleccione Q#: Sin restricciones.

Importación de las bibliotecas necesarias

En primer lugar, debe importar las bibliotecas necesarias para usar las operaciones y funciones de Q#. Copie y pegue el siguiente código en el archivo Main.qs.

import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
import Microsoft.Quantum.Intrinsic.*; // Aka Std.Intrinsic.*;
import Microsoft.Quantum.Measurement.*; // Aka Std.Measurement.*;

Definición de la operación Teleport

En primer lugar, debe definir la Teleport operación que implementa el protocolo de teletransportación cuántica. La operación toma dos cúbits como entrada: el message cúbit que contiene el estado cuántico que se va a teletransportar y el bob cúbit que recibirá el estado.

operation Teleport(message : Qubit, bob : Qubit) : Unit {
        // Allocate an alice qubit.
        use alice = Qubit();

        // Create some entanglement that we can use to send our message.
        H(alice);
        CNOT(alice, bob);

        // Encode the message into the entangled pair.
        CNOT(message, alice);
        H(message);

        // Measure the qubits to extract the classical data we need to decode
        // the message by applying the corrections on the bob qubit
        // accordingly.
        if M(message) == One {
            Z(bob);
        }
        if M(alice) == One {
            X(bob);
        }

        // Reset alice qubit before releasing.
        Reset(alice);
    }

Vamos a desglosar la Teleport operación:

  1. La operación usa el alice cúbit y crea un entrelazamiento entre alice cúbits y bob. A continuación, el message cúbit se entrelazará con el alice cúbit, por lo que los dos cúbits están entrelazados con el bob cúbit y se message codifican.

  2. A continuación, debe medir alice y message cúbits en la base de Bell. ¿Cómo puede expresar una medida en la base bell en Q#? No puede. O al menos no directamente. En Q# usted tiene la M operación, que realiza una medición en la base Z $o en la$base computacional. Por lo tanto, para usar correctamente la M operación, debe transformar los estados de Bell en los estados de base computacional. Para ello, aplique una H operación al message cúbit. En la tabla siguiente se muestra la correspondencia entre los estados de Bell y los estados de base computacional.

    Estado de Bell Estado de base computacional
    $\ket{\phi^+}$ $\ket{00}$
    $\ket{\phi^-}$ $\ket{01}$
    $\ket{\psi^+}$ $\ket{10}$
    $\ket{\psi^-}$ $\ket{11}$

    Sugerencia

    Un buen ejercicio es comprobar la equivalencia de los estados de Bell y los estados de base computacional después de aplicar la operación Hadamard al primer cúbit. Buena suerte.

  3. Por último, las if instrucciones comprueban los resultados de la medición y aplican correcciones al bob cúbit en consecuencia. Si el message cúbit se mide en One, aplique la puerta Z al bob cúbit. Si el alice cúbit también se mide en One, aplique la puerta X al bob cúbit.

Definición de las operaciones SetToPlus y SetToMinus

En caso de que quiera teletransportar cúbits en diferentes estados, como |0⟩, |1⟩, |+⟩ y |-⟩, debe definir los estados inicializados. Ya tiene la Teleport operación para teletransportar el cúbit, pero debe preparar el cúbit en el estado correcto antes de teletransportarlo.

Debe definir dos operaciones más y SetToPlus SetToMinus, para establecer un cúbit en el estado |0⟩ en |+⟩ y |-⟩, respectivamente.

    /// Sets a qubit in state |0⟩ to |+⟩.
    operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {
        H(q);
    }

    /// Sets a qubit in state |0⟩ to |−⟩.
    operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {
        X(q);
        H(q);
    }

Definición de la operación Main

Cada programa Q# debe tener una operación Main que actúa como punto de entrada para el programa. La operación Main ejecuta el protocolo de teletransportación para distintos estados cuánticos, $\ket{{0}$, $\ket{1}$, $\ket{+}$ y $\ket{-}$.

Vamos a desglosar la Main operación:

  1. La operación asigna dos cúbits, message y bob.
  2. Define una lista de tuplas que contienen el estado cuántico, la operación del inicializador necesaria para inicializar el cúbit en este estado y la base para la teletransportación. Las operaciones del inicializador son I para $\ket{0}$, X para $\ket{1}$, SetToPlus para $\ket{+}$ y SetToMinus para $\ket{-}$. Las operaciones SetToPlus y SetToMinus se definen en los pasos anteriores.
  3. La operación recorre en iteración la lista de tuplas e inicializa el cúbit message en el estado correspondiente y usa DumpMachine para mostrar el estado. A continuación, teletransporta el estado del cúbit message al cúbit bob mediante la operación Teleport definida en los pasos anteriores.
  4. Después de teletransportar el estado, la operación mide el cúbit bob en la base correspondiente y restablece los cúbits para seguir teletransportando más mensajes.
  5. Por último, la operación devuelve los resultados de medición de cada teletransporte.
operation Main() : Result[] {
    // Allocate the message and bob qubits.
    use (message, bob) = (Qubit(), Qubit());

    // Use the `Teleport` operation to send different quantum states.
    let stateInitializerBasisTuples = [
        ("|0〉", I, PauliZ),
        ("|1〉", X, PauliZ),
        ("|+〉", SetToPlus, PauliX),
        ("|-〉", SetToMinus, PauliX)
    ];

    mutable results = [];
    for (state, initializer, basis) in stateInitializerBasisTuples {
        // Initialize the message and show its state using the `DumpMachine`
        // function.
        initializer(message);
        Message($"Teleporting state {state}");
        DumpMachine();

        // Teleport the message and show the quantum state after
        // teleportation.
        Teleport(message, bob);
        Message($"Received state {state}");
        DumpMachine();

        // Measure bob in the corresponding basis and reset the qubits to
        // continue teleporting more messages.
        let result = Measure([basis], [bob]);
        set results += [result];
        ResetAll([message, bob]);
    }

    return results;
}

Ejecución del programa

El programa de teletransportación cuántica está listo. Puede ejecutar el programa para ver cómo funciona la teletransportación cuántica para diferentes estados cuánticos. El programa inicializa el message cúbit en diferentes estados y teletransporta el estado al bob cúbit.

El código siguiente contiene la Teleport operación, las SetToPlus operaciones y SetToMinus la Main operación que ejecuta el protocolo de teletransportación para diferentes estados cuánticos.

  1. El archivo Main.qs debe tener este aspecto:

    /// This Q# program implements quantum teleportation.
import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Measurement.*;

operation Main() : Result[] {
    // Allocate the message and bob qubits.
    use (message, bob) = (Qubit(), Qubit());

    // Use the `Teleport` operation to send different quantum states.
    let stateInitializerBasisTuples = [
        ("|0〉", I, PauliZ),
        ("|1〉", X, PauliZ),
        ("|+〉", SetToPlus, PauliX),
        ("|-〉", SetToMinus, PauliX)
    ];

    mutable results = [];
    for (state, initializer, basis) in stateInitializerBasisTuples {
        // Initialize the message and show its state using the `DumpMachine`
        // function.
        initializer(message);
        Message($"Teleporting state {state}");
        DumpMachine();

        // Teleport the message and show the quantum state after
        // teleportation.
        Teleport(message, bob);
        Message($"Received state {state}");
        DumpMachine();

        // Measure bob in the corresponding basis and reset the qubits to
        // continue teleporting more messages.
        let result = Measure([basis], [bob]);
        set results += [result];
        ResetAll([message, bob]);
    }

    return results;
}

/// # Summary
/// Sends the state of one qubit to a bob qubit by using teleportation.
///
/// Notice that after calling Teleport, the state of `message` is collapsed.
///
/// # Input
/// ## message
/// A qubit whose state we wish to send.
/// ## bob
/// A qubit initially in the |0〉 state that we want to send
/// the state of message to.
operation Teleport(message : Qubit, bob : Qubit) : Unit {
    // Allocate an alice qubit.
    use alice = Qubit();

    // Create some entanglement that we can use to send our message.
    H(alice);
    CNOT(alice, bob);

    // Encode the message into the entangled pair.
    CNOT(message, alice);
    H(message);

    // Measure the qubits to extract the classical data we need to decode
    // the message by applying the corrections on the bob qubit
    // accordingly.
    if M(message) == One {
        Z(bob);
    }
    if M(alice) == One {
        X(bob);
    }

    // Reset alice qubit before releasing.
    Reset(alice);
}

/// # Summary
/// Sets a qubit in state |0⟩ to |+⟩.
operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {
    H(q);
}

/// # Summary
/// Sets a qubit in state |0⟩ to |−⟩.
operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {
    X(q);
    H(q);
}

  2. Para ejecutar el programa en el simulador integrado, haga clic en Ejecutar encima de la operación Main o presione Ctrl+F5. La salida aparecerá en la consola de depuración.

  3. Compruebe que los estados recibidos coinciden con los estados de teletransporte. Por ejemplo:

    Teleporting state |0〉

DumpMachine:

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

Received state |0〉