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#target QIR 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 , I para $\ket{0}$X+$\ket{1}$ e SetToPlus para $\ket{. }$SetToMinus$\ket{-}$ 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 operação ou pressione Main. 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〉

Parabéns;! Você teletransporta com sucesso o estado do qubit de Alice para o qubit de Bob usando o protocolo de teletransporte quântico. Tudo graças ao emaranhamento quântico!

Na próxima unidade, testarás os teus conhecimentos de teletransporte quântico e emaranhamento.