Exercício: Criar o emaranhamento quântico com Q#

Na unidade anterior, você aprendeu sobre o conceito de emaranhamento quântico e estados de Bell.

Nesta unidade, você usa o Azure QDK (Quantum Development Kit) para escrever Q# código que cria estados de Bell emaranhados entre dois qubits. Para criar seu primeiro estado Bell, você aplica duas operações quânticas: a operação de Hadamard e a operação Controlada-NOT (CNOT).

Primeiro, vamos entender como essas operações funcionam e por que elas criam estados emaranhados.

A operação Hadamard

Lembre-se de que a operação Hadamard, ou H, coloca um qubit que está em um estado puro $\ket{0}$ ou $\ket{1}$ em um estado de superposição igualmente distribuído.

$$ H \ket{0} = \frac1{\sqrt2} \ket{0} + \frac1{\sqrt2} \ket{1}$$ $$ H \ket{1} = \frac1{\sqrt2} \ket{0} - \frac1{\sqrt2} \ket{1}$$

A primeira etapa para criar o estado de Bell é executar uma operação hadamard em um dos qubits.

A operação Controled-NOT (CNOT)

Quando dois qubits estão emaranhados, o estado de um qubit depende do estado do outro qubit. Portanto, para emaranhar dois qubits, você precisa aplicar uma operação de vários qubits, que é uma operação que atua em ambos os qubits ao mesmo tempo. A operação Controlled-NOT ou CNOT é uma operação de vários qubits que ajuda a criar o emaranhamento.

A operação CNOT usa dois qubits como entrada. Um dos qubits é o qubit de controle e o outro qubit é o target qubit. Se o qubit de controle estiver no $\ket{1}$ estado, a operação CNOT inverterá o estado do target qubit. Caso contrário, o CNOT não fará nada.

Por exemplo, nos seguintes estados de dois qubits, o qubit de controle é o qubit mais à esquerda e o target qubit é o qubit mais à direita.

Em Q#, a operação CNOT atua em uma matriz de dois qubits e inverte o segundo qubit somente se o primeiro qubit for One.

Emaranhamento com operações Hadamard e CNOT

Suponha que você tenha um sistema de dois qubits no estado $\ket{00}$. Nesse estado, os qubits não estão emaranhados. Para colocar esses qubits no estado Bell emaranhado $\ket{\phi^+}=\frac1{\sqrt2}(\ket{00}+\ket{11})$, aplique as operações Hadamard e CNOT.

Veja como isso funciona:

1. Escolha um qubit no estado c para ser o qubit de controle e o outro qubit para ser o target qubit. Aqui, escolhemos o qubit mais à esquerda para ser o controle e o qubit mais à direita para ser o target.

2. Coloque apenas o qubit de controle em um estado de superposição igual. Para fazer isso, aplique uma operação H apenas ao qubit de controle:

   $$H \ket{0_c} = \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c})$$

   Observação

   Os subscritos ${}_c$ e ${}_t$ especificam o controle e os qubits target, respectivamente.

3. Aplique uma operação CNOT ao par de qubits. Lembre-se de que o qubit de controle está em um estado de superposição e o qubit target está no estado $\ket{0_t}$.

   $ \begin{CNOT} alinhado \frac{{1}{\sqrt{{2}}\ket{0_c}+\ket{1_c}\ket{0_t}&= CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(CNOT \ket{0_c 0_t} + CNOT \ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t}) \end{alinhado}$

O estado $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ está emaranhado. Este estado emaranhado em particular é um dos quatro estados de Bell, $\ket{\phi^{+}}$.

Criar um emaranhamento quântico em Q#

Para criar um estado Bell com Q# código, siga estas etapas no Vs Code (Visual Studio Code):

1. Abra o VS Code.
2. Abra o menu Arquivo e escolha Novo Arquivo de Texto para criar um novo arquivo.
3. Salve o arquivo como Main.qs.

Criar um estado de Bell

Para criar o estado Bell em $\ket{\phi^+}$, Q# siga estas etapas:

1. Importe o Std.Diagnostics namespace da Q# biblioteca padrão para que você possa usar a DumpMachine função. Essa função mostra informações sobre os estados do qubit quando você chama a função em seu código. Para importar o namespace, copie o seguinte Q# código para o arquivo Main.qs :

   import Std.Diagnostics.*;
   

2. Crie a operação Main que retorna dois valores de tipo Result, que são os resultados de medida dos qubits.

   import Std.Diagnostics.*;
   
   operation Main() : (Result, Result) {
       // Your code goes here
   }
   

3. Dentro da operação Main, aloque dois qubits a serem emaranhados, q1 e q2.

   import Std.Diagnostics.*;
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
   }
   

4. Aplique o portão do Hadamard, Hao qubitq1 de controle. Isso coloca apenas esse qubit em um estado de superposição. Em seguida, aplique a porta CNOT, CNOT, a ambos os qubits para emaranhar os dois qubits. O primeiro argumento a CNOT é o qubit de controle e o segundo argumento é o qubit target.

   import Std.Diagnostics.*; 
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
   
       H(q1);
       CNOT(q1, q2);
   }
   

5. Use a função DumpMachine para exibir o estado dos qubits depois de emaranhá-los. Observe que DumpMachine não executa uma medida nos qubits, portanto DumpMachine , não afeta os estados do qubit.

   import Std.Diagnostics.*;
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
   
       H(q1);
       CNOT(q1, q2);
   
       DumpMachine();
   }
   

6. Use a operação M para medir os qubits e armazene os resultados em m1 e m2. Em seguida, use a operação Reset para reiniciar os qubits.

   import Std.Diagnostics.*;
   
   operation Main() : (Result, Result) {
   
       use (q1, q2) = (Qubit(), Qubit());
   
       H(q1);
       CNOT(q1, q2);
       DumpMachine();
   
       let (m1, m2) = (M(q1), M(q2));
       Reset(q1);
       Reset(q2);
   
   }
   

7. Retorne os resultados da medida dos qubits com a instrução return . Aqui está o programa final em seu arquivo Main.qs :

   import Std.Diagnostics.*;
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
   
       H(q1);
       CNOT(q1, q2);
   
       DumpMachine();
   
       let (m1, m2) = (M(q1), M(q2));
       Reset(q1);
       Reset(q2);
   
       return (m1, m2);
   }
   

8. Para executar seu programa no simulador interno, escolha a lente Executar código acima da Main operação ou pressione Ctrl + F5. A saída é exibida no console de depuração.

9. Os resultados da medida estão correlacionados, portanto, no final do programa, você obtém um resultado de (Zero, Zero) ou (One, One) com igual probabilidade. Execute o programa várias vezes e observe a saída para se convencer da correlação.

10. Para visualizar o diagrama de circuito, escolha a lente de código Circuito acima da operação Main. O diagrama do circuito mostra o portão Hadamard aplicado ao primeiro qubit e o portão CNOT aplicado a ambos os qubits.

    

Criar outros estados de Bell

Para criar outros Estados Bell, aplique operações Pauli adicionais $X$ ou $Z$ aos qubits.

Por exemplo, para criar o estado $\ket{\phi^-}=\frac1{\sqrt2}(\ket{00}-\ket{11})$Bell, aplique a operação Pauli $Z$ ao qubit de controle depois de aplicar o portão Hadamard, mas antes de aplicar o CNOT. A $Z$ operação inverte o estado $\ket{+}$ para $\ket{-}$.

Veja como criar o $\ket{\phi^-}$ estado:

1. Crie dois qubits no estado $\ket{00}$.

2. Coloque o qubit de controle em um estado de superposição com a operação $H$.

   $$H \ket{0_c} = \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c}) = \ket{+_c}$$

3. Aplique a $Z$ operação ao qubit de controle.

   $$Z \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c}) = \frac{1}{\sqrt{2}}(\ket{0_c} - \ket{1_c}) = \ket{-_c}$$

4. Aplique a operação CNOT ao qubit de controle e ao qubit target, que está no estado $\ket{0_t}$.

   $ \begin{CNOT} alinhado \frac{{1}{\sqrt{{2}}\ket{0_c}-\ket{1_c}\ket{0_t}&= CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(CNOT \ket{0_c 0_t} - CNOT \ket{1_c 0_t})\\&=\frac{{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 1_t}) \end{alinhado}$

Para criar o estado Bell $\ket{\phi^-}$ em Q#, substitua o código no Main.qs pelo seguinte código:

import Std.Diagnostics.*;
    
operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    
    H(q1);
    Z(q1); // Apply the Pauli Z operation to the control qubit
    CNOT(q1, q2);
    
    DumpMachine();
    
    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

Da mesma forma, você pode criar os estados $\ket{\psi^+}$ and $\ket{\psi^-}$ Bell aplicando as operações Pauli $X$ e $Z$ aos qubits.

• Para criar o estado Bell $\ket{\psi^+}=\frac1{\sqrt2}(\ket{01}+\ket{10})$, aplique a porta Pauli $X$ ao qubit target depois de aplicar a porta Hadamard ao qubit de controle. Em seguida, aplique a porta CNOT.
• Para criar o estado $\ket{\psi^-}=\frac1{\sqrt2}(\ket{01}-\ket{10})$ de Bell, aplique o Pauli $Z$ ao qubit de controle e o Pauli $X$ ao qubit target depois de aplicar o portão Hadamard ao qubit de controle. Em seguida, aplique a porta CNOT.

Na próxima unidade, você aprenderá a usar o emaranhamento para enviar informações quânticas, um processo conhecido como teletransporte quântico.