Exercício - Use o emaranhamento para se teletransportar com Q#

  • 9 minutos

Na unidade anterior, você revisou as etapas do protocolo de teletransporte quântico. Agora é a sua vez de ajudar Alice e Bob com seu experimento de teletransporte quântico!

Nesta unidade, você criará um programa de teletransporte quântico que Q# usa o protocolo de teletransporte quântico para enviar o estado de um qubit de Alice para Bob.

Crie um programa de teletransporte quântico em Q#

  1. Abra o Visual Studio Code.
  2. Selecione Arquivo > Novo Arquivo de Texto e salve-o como Main.qs.
  3. Selecione Exibir -> Paleta de Comandos e digiteQ#: Defina o perfil QIR target do Azure Quantum. Prima Enter.
  4. Selecione Q#: Sem restrições.

Importar as bibliotecas necessárias

Primeiro, você precisa importar as bibliotecas necessárias para usar as Q# operações e funções. Copie e cole o código a seguir em seu arquivo Main.qs .

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

Definir a Teleport operação

Primeiro, você precisa definir a Teleport operação que implementa o protocolo de teletransporte quântico. A operação usa dois qubits como entrada: o message qubit que contém o estado quântico a ser teletransportado e o bob qubit que receberá o 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 detalhar a Teleport operação:

  1. A operação usa o alice qubit e cria emaranhamento entre alice e bob qubits. O message qubit é então emaranhado com o alice qubit, então os dois qubits são emaranhados com o bob qubit, e o message é codificado.

  2. Então, você precisa medir alice e message qubits na base Bell. Como você pode expressar uma medida na base Bell em Q#? Não pode fazê-lo. Ou, pelo menos, não diretamente. Em Q# você tem a M operação, que realiza uma medição na $base Z$ ou base computacional. Então, para usar a M operação corretamente, você precisa transformar os estados de Bell nos estados de base computacional. Você pode fazer isso aplicando uma H operação ao message qubit. A tabela a seguir mostra a correspondência entre os estados de Bell e os estados de base computacional.

    Estado do sino Estado da base computacional
    $\ket{\phi^+}$ $\ket{00}$
    $\ket{\phi^-}$ $\ket{01}$
    $\ket{\psi^+}$ $\ket{10}$
    $\ket{\psi^-}$ $\ket{11}$

    Gorjeta

    Um bom exercício é verificar a equivalência dos estados de Bell e dos estados de base computacional depois de aplicar a operação de Hadamard ao primeiro qubit. Boa sorte!

  3. Finalmente, as if instruções verificam os resultados da medição e aplicam correções ao bob qubit de acordo. Se o qubit for medido message em One, você aplicará a porta Z ao bob qubit. Se o qubit também for medido alice em One você, aplique a porta X ao bob qubit.

Definir as SetToPlus operações e SetToMinus

Caso você queira teletransportar qubits em diferentes estados, como |0⟩, |1⟩, |+⟩ e |−⟩, você precisa definir os estados inicializados. Você já tem a Teleport operação para teletransportar o qubit, mas precisa preparar o qubit no estado correto antes de teletransportá-lo.

Você precisa definir mais duas operações SetToPlus e SetToMinusdefinir um qubit no estado |0⟩ para |+⟩ e |−⟩, 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);
    }

Definir a Main operação

Cada Q# programa deve ter uma Main operação que sirva como ponto de entrada para o programa. A Main operação executa o protocolo de teletransporte para diferentes estados quânticos, $\ket{{0}$, $\ket{1}$, $\ket{+}$ e $\ket{-}$.

Vamos detalhar a Main operação:

  1. A operação aloca dois qubits message e bob.
  2. Ele define uma lista de tuplas que contêm o estado quântico, a operação do inicializador necessária para inicializar o qubit nesse estado e a base para o teletransporte. As operações do inicializador são para , para , SetToPlus para $\ket{1}$$\ket{+}$ e SetToMinus para $\ket{-}$. X $\ket{0}$I As SetToPlus operações e SetToMinus são definidas nas etapas anteriores.
  3. A operação itera sobre a lista de tuplas e inicializa o message qubit no estado correspondente e usa DumpMachine para exibir o estado. Em seguida, teletransporta o estado do message qubit para o bob qubit usando a Teleport operação definida nas etapas anteriores.
  4. Depois de teletransportar o estado, a operação mede o bob qubit na base correspondente e redefine os qubits para continuar teletransportando mais mensagens.
  5. Finalmente, a operação retorna os resultados da medição para 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;
}

Execute o programa

Seu programa de teletransporte quântico está pronto! Você pode executar o programa para ver como o teletransporte quântico funciona para diferentes estados quânticos. O programa inicializa o message qubit em diferentes estados e teletransporta o estado para o bob qubit.

O código a seguir contém a Teleport operação, as SetToPlus operações e SetToMinus e a Main operação que executa o protocolo de teletransporte para diferentes estados quânticos.

  1. Seu arquivo Main.qs deve ter esta aparência:

    /// 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 executar o programa no simulador integrado, clique em Executar acima da Main operação ou pressione Ctrl+F5. Sua saída aparecerá no console de depuração.

  3. Verifique se os estados recebidos correspondem aos estados de teletransporte. Por exemplo:

    Teleporting state |0〉

DumpMachine:

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

Received state |0〉