Ćwiczenie — tworzenie splątania kwantowego za pomocą polecenia Q#

W poprzedniej lekcji przedstawiono koncepcję splątania kwantowego i stanów Bell.

W tej lekcji użyjesz platformy Azure Quantum Development Kit (QDK), aby napisać Q# kod, który tworzy splątane stany Bell między dwoma kubitami. Aby utworzyć pierwszy stan bell, należy zastosować dwie operacje kwantowe: operację Hadamard i operację Controlled-NOT (CNOT).

Najpierw wyjaśnijmy, jak działają te operacje i dlaczego tworzą splątane stany.

Operacja Hadamard

Pamiętaj, że operacja Hadamard lub H umieszcza kubit, który jest w stanie czystym $\ket{0}$ lub $\ket{1}$ w równą superpozycję.

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

Pierwszym krokiem do utworzenia stanu bell jest wykonanie operacji Hadamard na jednym z kubitów.

Operacja Kontrolowana NOT (CNOT)

Gdy dwa kubity są splątane, stan jednego kubitu zależy od stanu drugiego kubitu. W związku z tym w celu splątania dwóch kubitów należy zastosować operację z wieloma kubitami, która działa jednocześnie na obu kubitach. Operacja Controlled-NOT lub CNOT jest operacją wielokubitową, która pomaga w tworzeniu splątania kwantowego.

Operacja CNOT przyjmuje dwa kubity jako dane wejściowe. Jednym z kubitów jest kubit kontrolny, a drugi kubit to target kubit. Jeśli kubit kontrolny jest w stanie $\ket{1}$, to operacja CNOT odwraca stan kubitu target. W przeciwnym razie CNOT nic nie robi.

Na przykład w następujących stanach dwóch kubitów kubit kontrolny jest kubitem po lewej stronie, a target kubit jest kubitem z prawej strony.

W Q# systemie operacja CNOT działa na tablicy dwóch kubitów i odwraca drugi kubit tylko wtedy, gdy pierwszy kubit jest One.

Splątanie przy użyciu operacji Hadamard i CNOT

Załóżmy, że masz system z dwoma kubitami w stanie $\ket{00}$. W tym stanie kubity nie są splątane. Aby umieścić te kubity w splątanym stanie Bella $\ket{\phi^+}=\frac1{\sqrt2}(\ket{00}+\ket{11})$, zastosuj operacje Hadamarda i CNOT.

Oto, jak to działa:

1. Wybierz jeden kubit w stanie c jako kubit sterujący, a drugi jako kubit target. W tym miejscu wybieramy najdalej lewy kubit jako kontrolny, a najdalej prawy kubit jako target.

2. Umieść tylko kubit kontrolny w stanie równej superpozycji. W tym celu zastosuj operację H tylko do kubitu sterującego:

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

   Uwaga / Notatka

   Indeksy dolne ${}_c$ i ${}_t$ określają odpowiednio qubit kontrolujący i target qubit.

3. Zastosuj operację CNOT do pary kubitów. Pamiętaj, że kubit kontrolny jest w stanie superpozycji, a kubit target jest w stanie $\ket{0_t}$.

   $$ \begin{wyrównane} CNOT \frac{{1}{\sqrt{{2}}(\ket{0_c}+\ket{1_c})\ket{0_t} amp;& CNOT =\frac{2{1}{\sqrt(}0_c 0_t\ket{+}1_c 0_t\ket{)} amp;\\&2=(CNOT \frac{0_c 0_t{1}{\sqrt + CNOT }1_c 0_t\ket{)} amp;\ket{}2\\(&0_c 0_t=+\frac{1_c 1_t{1}{\sqrt)} wyrównane\ket{}\ket{

Stan $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ jest splątany. Ten konkretny stan splątany to jest jednym z czterech stanów Bella, $\ket{\phi^{+}}$.

Utwórz splątanie kwantowe w Q#

Aby utworzyć stan bell z Q# kodem, wykonaj następujące kroki w programie Visual Studio Code (VS Code):

1. Otwórz program VS Code.
2. Otwórz menu Plik , a następnie wybierz pozycję Nowy plik tekstowy , aby utworzyć nowy plik.
3. Zapisz plik jako Main.qs.

Tworzenie stanu dzwonka

Aby utworzyć stan $\ket{\phi^+}$ Bell w pliku Q#, wykonaj następujące kroki:

1. Zaimportuj przestrzeń nazw Std.Diagnostics z biblioteki standardowej Q#, aby móc używać funkcji DumpMachine. Ta funkcja wyświetla informacje o stanach kubitu podczas wywoływania funkcji w kodzie. Aby zaimportować przestrzeń nazw, skopiuj następujący Q# kod do pliku Main.qs :

   import Std.Diagnostics.*;
   

2. Utwórz operację Main zwracającą dwie Result wartości typu, które są wynikami pomiaru kubitów.

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

3. Wewnątrz operacji Main, przydziel dwa kubity do splątania, q1 i q2.

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

4. Zastosuj bramę Hadamard, H, do kubituq1 sterującego. Spowoduje to przejście tylko kubitu do stanu superpozycji. Następnie zastosuj bramę CNOT<, c0 /> na obu kubitach, aby splątać oba kubity. Pierwszym argumentem CNOT jest kubit kontrolny, a drugim argumentem target jest kubit.

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

5. Użyj funkcji DumpMachine, aby wyświetlić stan kubitów po ich splątaniu. Należy pamiętać, że DumpMachine nie wykonuje pomiaru na kubitach, więc DumpMachine nie ma wpływu na stany kubitu.

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

6. M Użyj operacji, aby zmierzyć kubity i zapisać wyniki w m1 i m2. Następnie użyj operacji Reset, aby zresetować kubity.

   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. Zwróć wyniki pomiaru kubitów za pomocą polecenia return. Oto końcowy program w pliku 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. Aby uruchomić program w wbudowanym symulatorze, wybierz polecenie Uruchom nad Main operacją lub naciśnij Ctrl + F5. Dane wyjściowe są wyświetlane w konsoli debugowania.

9. Wyniki pomiaru są skorelowane, więc na końcu programu uzyskasz wynik (Zero, Zero) lub (One, One) z równym prawdopodobieństwem. Uruchom ponownie program wiele razy i obserwuj dane wyjściowe, aby przekonać się o korelacji.

10. Aby zwizualizować schemat obwodu, wybierz soczewkę kodu Circuit powyżej Main operacji. Diagram obwodu przedstawia bramę Hadamard zastosowaną do pierwszego kubitu i bramę CNOT zastosowaną do obu kubitów.

    

Tworzenie innych stanów Bella

Aby utworzyć inne stany Bell, zastosuj dodatkowe operacje Pauli $X$ lub $Z$ na kubitach.

Aby na przykład utworzyć stan $\ket{\phi^-}=\frac1{\sqrt2}(\ket{00}-\ket{11})$Bell, zastosuj operację Pauli $Z$ do kubitu kontrolnego po zastosowaniu bramy Hadamard, ale przed zastosowaniem CNOT. Operacja $Z$ przerzuca stan $\ket{+}$ na $\ket{-}$.

Oto sposób, w jaki można utworzyć stan $\ket{\phi^-}$:

1. Utwórz dwa kubity w stanie $\ket{00}$.

2. Umieść kubit kontrolki w stanie superpozycji z operacją $H$ :

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

3. Zastosuj operację $Z$ do kubitu sterującego.

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

4. Zastosuj operację CNOT do kubitu sterującego i kubitu target, który znajduje się w stanie $\ket{0_t}$.

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

Aby utworzyć $\ket{\phi^-}$ stan Bella w Q#, zastąp kod w pliku Main.qs następującym:

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

Podobnie możesz utworzyć stany $\ket{\psi^+}$ and $\ket{\psi^-}$ Bell, stosując operacje Pauli $X$ i $Z$ do kubitów.

• Aby utworzyć stan $\ket{\psi^+}=\frac1{\sqrt2}(\ket{01}+\ket{10})$Bell, zastosuj bramę Pauli $X$ do kubitu target po zastosowaniu bramy Hadamard do kubitu sterującego. Następnie zastosuj bramę CNOT.
• Aby utworzyć stan $\ket{\psi^-}=\frac1{\sqrt2}(\ket{01}-\ket{10})$ Bell, zastosuj Pauli $ Z $ do kubitu kontrolnego i Pauli $ X $ do kubitu target po zastosowaniu bramy Hadamard do kubitu kontrolnego. Następnie zastosuj bramę CNOT.

W następnej lekcji dowiesz się, jak używać splątania do wysyłania informacji kwantowych, czyli procesu znanego jako teleportacja kwantowa.