Exercício – Usar o emaranhamento para teletransporte com Q#

9 minutos

Na unidade anterior, você aprendeu as etapas do protocolo de teletransporte quântico. Agora é a sua vez de ajudar Alice e Bob a implementar o teste de teletransporte quântico!

Nesta unidade, você cria um programa no Q# qual 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 funcionam juntas para executar o teletransporte.

Criar um programa de teletransporte quântico no Q#

Para começar a usar seu programa de teletransporte, siga estas etapas:

Abra o VS Code (Visual Studio 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 gravar seu programa, copie o seguinte código no 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 operação `Teleport`

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 teleporte e o bob qubit que recebe o estado teleporte.

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 dividir as etapas em nossa Teleport operação:

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

Transforme os estados bell em estados computacionais. Fazemos isso porque, em Q#, não podemos executar medidas diretamente nos estados de Bell. Aplique um portão hadamard ao message qubit para transformar os estados na base computacional. A tabela a seguir relaciona os estados bell com seus estados computacionais correspondentes:

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

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

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

Definir as operações `SetToPlus` 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. No entanto Q#, temos que definir o estado do qubit da mensagem antes do protocolo de teletransporte.

Para testar 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 de mensagem no estado inicial desejado antes de teletransportá-lo.

Copie o seguinte código para as operações SetToPlus e SetToMinus no 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 operação `Main`

Cada programa Q# deve ter uma operação de ponto de entrada, que é a operação Main 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 de Bob acabará no mesmo estado para o qual inicialmente definimos o qubit da mensagem.

Aqui está a operaçã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 dividir os componentes da Main operação:

Alocar 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 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{-}$.
Iterar na lista de tuplas para inicializar o qubit message 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 qubit bob na base correspondente e redefina os qubits para que você possa reutilizá-los para teletransporte.
Retorne os resultados da medição para cada teletransporte.

Se o protocolo funcionar corretamente, os resultados da medida de bob corresponderão aos estados inicializados para message.

Executar 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, as SetToPlus e SetToMinus operações, e a Main operação. Para executar seu código e analisar os resultados, siga estas etapas:

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 seu programa no simulador interno, escolha a lente de código Executar acima da operação Main. Ou pressione Ctrl + F5. A saída é exibida no console de depuração.

Verifique se os estados recebidos correspondem aos estados teleportáveis. 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 êxito o estado do qubit de Alice para o qubit de Bob por meio do protocolo de teletransporte quântico. Tudo graças ao entrelaçamento quântico!

Comentários

Esta página foi útil?