Exercício - Crie 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 Quantum Development Kit (QDK) para escrever Q# código que cria estados Bell emaranhados entre dois qubits. Para criar seu primeiro estado Bell, você aplica duas operações quânticas: a operação Hadamard e a operação Controlled-NOT (CNOT).

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

A operação Hadamard

Recorde-se que a operação de Hadamard, ou H, coloca um qubit que está num estado $\ket{0}$ ou estado puro $\ket{1}$ num estado de superposição igual.

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

O primeiro passo para criar seu estado Bell é executar uma operação Hadamard em um dos qubits.

A operação Controlled-NOT (CNOT)

Quando dois qubits estão entrelaçados, o estado de um qubit depende do estado do outro qubit. Portanto, para entrelaçar dois qubits é necessário aplicar uma operação multi-qubit, que é uma operação que atua sobre ambos os qubits ao mesmo tempo. A operação Controlled-NOT, ou CNOT, é uma operação de vários qubits que ajuda a criar emaranhamento.

A operação CNOT usa dois qubits como entrada. Um dos qubits é o qubit de controlo e o outro qubit é o target qubit. Se o qubit de controlo estiver no $\ket{1}$ estado, então a operação CNOT inverte o estado do target qubit. Caso contrário, o CNOT não faz 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.

No Q#, a operação CNOT atua num array de dois qubits e inverte o segundo qubit apenas se o primeiro qubit estiver One.

Emaranhamento com operações Hadamard e CNOT

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

Eis como funciona:

1. Escolha um qubit no estado c como qubit de controlo e o outro qubit como qubit target . 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 controlo, e target os qubits, respetivamente.

3. Aplique uma operação CNOT ao par de qubits. Recorde-se que o qubit de controlo está num estado de superposição e o target qubit está nesse $\ket{0_t}$ estado.

   $$ \begin{alinhado} CNOT \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á entrelaçado. Este estado emaranhado em particular é um dos quatro estados de Bell, $\ket{\phi^{+}}$.

Crie emaranhamento quântico em Q#

Para criar um estado Bell com Q# código, siga estas etapas no Visual Studio Code (VS 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 Bell

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

1. Importe o Std.Diagnostics namespace da Q# biblioteca padrão para que você possa usar a DumpMachine função. Esta função mostra informações sobre os estados de 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 Main operação que retorna dois Result valores de tipo, que são os resultados de medição dos qubits.

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

3. Dentro da operação Main, aloque dois qubits, q1 e q2, para serem entrelaçados.

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

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

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

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

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

6. Use a M operação para medir os qubits e armazenar 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 medição 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 o seu programa no simulador integrado, escolha a opção de código "Executar" acima da operação , ou pressione Main. Sua saída aparece no console de depuração.

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

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

    

Criar outros estados Bell

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

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

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

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

2. Coloque o qubit de controlo num 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. Aplica a $Z$ operação ao qubit de controlo.

   $$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 controlo e ao qubit target, que está no estado $\ket{0_t}$.

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

Para criar o $\ket{\phi^-}$ estado Bell em Q#, substitua o código em seu 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);
}

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

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

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