Exercício - Use entrelaçamento para teleportar com Q#

9 minutos

Na unidade anterior, você aprendeu os passos do protocolo de teletransporte quântico. Agora é a sua vez de ajudar Alice e Bob a implementar seu experimento de teletransporte quântico!

Nesta unidade, você cria um programa que Q# usa o protocolo de teletransporte quântico para enviar o estado de um qubit de mensagem de Alice para Bob. O programa contém quatro operações que trabalham juntas para realizar o teletransporte.

Crie um programa de teletransporte quântico em Q#

Para começar a utilizar o seu programa de teletransporte, siga estes passos:

Abra o Visual Studio Code (VS Code).
Abra o menu Arquivo e escolha Novo arquivo de texto para criar um novo arquivo.
Salve o arquivo como Main.qs.

Importar as bibliotecas necessárias

Para importar as bibliotecas que contêm as Q# operações e funções necessárias para escrever o programa, copie o seguinte código para o 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

Crie uma operação chamada Teleport que implementa o protocolo de teletransporte quântico. A operação usa dois qubits como entrada: o message qubit que contém o estado teletransportado e o bob qubit que recebe o estado teletransportado.

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);

    // Transform the Bell states into computational states for measurement
    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 as etapas da nossa Teleport operação:

Crie um alice qubit. Agora temos os três qubits que precisamos para realizar o teletransporte quântico: alice, bob, e message.
Entrelaçar os qubits alice e bob. Fazemos isso da maneira usual: aplicar um portão Hadamard para colocar o alice qubit em um estado de superposição.
Codifique o qubit message no qubit entrelaçado do par formado por alice e bob. Para fazer isso, aplicamos uma porta CNOT com message como o qubit de controle e alice como o target qubit. Os estados de qubit alice e message estão agora na base de Bell.

Transforme os estados de Bell em estados computacionais. Fazemos isso porque, no Q#, não podemos realizar medições diretamente nos estados de Bell. Aplique um portão de Hadamard ao message qubit para transformar os estados na base computacional. A tabela a seguir relaciona os estados de Bell com seus estados computacionais correspondentes:

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

Meça os alice e message qubits e aplique as portas apropriadas ao bob qubit com base nos resultados da medição. Primeiro, use a operação M para medir message. Se o resultado for 1, aplique a porta $Z$ a bob. Em seguida, meça alice através da operação M. Se o resultado for 1, aplique a $porta X$ a bob.

Este protocolo teletransporta o estado inicial do message qubit para o bob qubit.

Definir as `SetToPlus` operações e `SetToMinus`

Em um protocolo de teletransporte da vida real, o qubit da mensagem pode estar em qualquer estado de superposição. Nem Alice nem Bob sabem o estado do qubit da mensagem. O estado é teletransportado do qubit da mensagem para o qubit de Bob, mesmo que o estado não seja conhecido. Mas no Q#, temos que definir o estado do qubit da mensagem antes do protocolo de teletransporte.

Para testar o nosso protocolo de teletransporte com o qubit de mensagem em diferentes estados iniciais, como |0⟩, |1⟩, |+⟩ e |−⟩, criamos as operações SetToPlus e SetToMinus. Essas operações colocam o qubit da mensagem no estado inicial desejado antes de teletransportá-lo.

Copie o seguinte código para as operações SetToPlus e SetToMinus no seu arquivo Main.qs:

/// 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 operação de ponto de entrada, que é a Main operação por padrão. Aqui, nossa Main operação executa o protocolo de teletransporte para diferentes estados iniciais do qubit da mensagem, $\ket{{0}$, $\ket{1}$, $\ket{+}$ e $\ket{-}$. Se o protocolo for bem-sucedido, o qubit do Bob terminará no mesmo estado para o qual definimos inicialmente o qubit da mensagem.

Aqui está a instrução Main para o programa de teletransporte quântico:

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;
}

Vamos detalhar os componentes da Main operação:

Aloque dois qubits message e bob.
Crie uma lista de tuplas que contêm o estado quântico, a operação que inicializa o message qubit no estado desejado e a base para a medição. As operações de inicialização são I para $\ket{0}$, X para $\ket{1}$, SetToPlus para $\ket{+}$ e SetToMinus para $\ket{-}$.
Itere sobre a lista de tuplas para inicializar o message qubit e exibir o estado inicial. Em seguida, chame a operação Teleport para teletransportar o estado do qubit message para o qubit bob.
Meça o bob qubit na base correspondente e redefina os qubits para que você possa reutilizá-los para teletransporte.
Devolve os resultados das medidas para cada teleportação.

Se o protocolo funcionar corretamente, então os resultados da medição para bob correspondem aos estados inicializados para message.

Execute o programa

Seu programa de teletransporte quântico está pronto! Execute o programa para ver como o teletransporte quântico funciona para diferentes estados iniciais do qubit da mensagem.

O programa completo contém a Teleport operação, a SetToPlus operação, a SetToMinus operação, e a Main operação. Para executar o código e analisar os resultados, siga estes passos:

Substitua o conteúdo do arquivo Main.qs pelo seguinte Q# código:

/// 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 a message qubit to a bob qubit by 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);
}

Para executar o programa no simulador integrado, escolha a lente de código Executar sobre a operação Main. Ou pressione Ctrl + F5. Sua saída aparece no console de depuração.

Verifique se os estados recebidos correspondem aos estados teletransportados. Por exemplo:

Teleporting state |0〉

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

Received state |0〉

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

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

Feedback

Esta página foi útil?