Kuantum dolanıklık oluşturma alıştırması - Q# ile

Tamamlandı

Önceki ünitede kuantum dolanıklığı ve Bell durumları kavramını öğrendiniz.

Bu birimde, Quantum Development Kit iki kubit arasında dolanık Bell durumları oluşturan Q# kodunu yazmak için Microsoft'un (QDK) 'sını kullanacaksınız. İlk Bell durumunuzu oluşturmak için iki kuantum işlemi uygularsınız: Hadamard işlemi ve Kontrollü-NOT (CNOT) işlemi.

İlk olarak, bu işlemlerin nasıl çalıştığını ve neden dolanık durumlar oluşturduklarını anlayalım.

Hadamard işlemi

Hadamard veya H işleminin saf $\ket{0}$ bir durumda veya $\ket{1}$ durumda olan bir kubiti eşit bir süper pozisyon durumuna koyduğunu hatırlayın.

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

Bell durumunuzu oluşturmanın ilk adımı kubitlerden birinde hadamard işlemi gerçekleştirmektir.

Controlled-NOT (CNOT) işlemi

İki kubit dolanık olduğunda, bir kubitin durumu diğer kubitin durumuna bağlıdır. Bu nedenle, iki kubiti dolanık yapmak için, aynı anda her iki kubit üzerinde de hareket eden bir işlem olan çok kubitli bir işlem uygulamanız gerekir. Controlled-NOT veya CNOT işlemi, dolanıklık oluşturmaya yardımcı olan çok kubitli bir işlemdir.

CNOT işlemi giriş olarak iki kubit alır. Kubitlerden biri denetim kubiti, diğer kubit ise kubittir target . Kontrol kubiti $\ket{1}$ durumundaysa, CNOT işlemi target kubitinin durumunu çevirir. Aksi takdirde, CNOT hiçbir şey yapmaz.

Örneğin, aşağıdaki iki kubitli durumlarda, denetim kubiti en soldaki kubit ve target kubit en sağdaki kubittir.

Giriş: CNOT	CNOT Kaynağından Çıkış
$\ket{00}$	$\ket{00}$
$\ket{01}$	$\ket{01}$
$\ket{10}$	$\ket{11}$
$\ket{11}$	$\ket{10}$

Q# içinde, CNOT işlemi iki kubitlik bir dizi üzerinde hareket eder ve ancak ilk kubit One olduğunda ikinci kubiti çevirir.

Hadamard ve CNOT operasyonlarıyla dolanıklık

Varsayalım ki $\ket{00}$ durumunda iki kubitli bir sisteminiz var. Bu durumda kubitler dolanık değildir. Bu kubitleri dolanık Bell durumuna $\ket{\phi^+}=\frac1{\sqrt2}(\ket{00}+\ket{11})$getirmek için Hadamard ve CNOT işlemlerini uygulayın.

İşleyişi şu şekildedir:

1. C durumundaki bir kubiti denetim kubiti, diğer kubiti ise kubit olarak target seçin. Burada, denetim olarak en soldaki kubiti ve en sağdaki kubiti targetolarak seçiyoruz.

2. Yalnızca denetim kubitini eşit bir süper konum durumuna yerleştirin. Bunu yapmak için yalnızca denetim kubitine bir H işlemi uygulayın:

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

   Uyarı

   Alt indisler ${}_c$ ve ${}_t$, sırasıyla kontrol ve target kubitleri belirtir.

3. Kubit çiftine bir CNOT işlemi uygulayın. Denetim kubitinin bir süperpozisyon durumunda ve target kubitinin $\ket{0_t}$ durumunda olduğunu hatırlayın.

Durum $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ dolanık. Bu dolanık durum, dört Bell durumundan biridir: $\ket{\phi^{+}}$.

Uyarı

Kuantum bilişiminde işlemler genellikle geçit olarak adlandırılır. Örneğin, H kapısı ve CNOT kapısı.

Q#'de kuantum dolanıklığı oluşturma

Kodla Q# bir Bell durumu oluşturmak için Visual Studio Code'da (VS Code) şu adımları izleyin:

1. VS Code'i açın.
2. Dosya menüsünü açın ve yeni bir dosya oluşturmak için Yeni Metin Dosyası'nı seçin.
3. Dosyayı Main.qs olarak kaydedin.

Bell durumu oluşturma

Bell durumunu $\ket{\phi^+}$ içinde Q# oluşturmak için şu adımları izleyin:

1. Standart kütüphaneden Std.Diagnostics ad alanını içeri aktarın, böylece Q# işlevini DumpMachine kullanabilirsiniz. Bu işlev, kodunuzda işlevi çağırdığınızda kubit durumları hakkındaki bilgileri gösterir. Ad alanını içeri aktarmak için aşağıdaki Q# kodu Main.qs dosyanıza kopyalayın:

   import Std.Diagnostics.*;
   

2. Kubitlerin Main ölçüm sonuçları olan iki Result tür değeri döndüren işlemi oluşturun.

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

3. İşlemin içinde, dolanık olmaları için Main ve q1 olarak iki kubit ayırın.

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

4. Hadamard geçidini , Hdenetim kubitineq1 uygulayın. Bu, yalnızca o kubiti süperpozisyon durumuna geçirir. Ardından iki kubiti dolanık yapmak için her iki kubite de CNOT geçidini CNOTuygulayın. İlk bağımsız değişken CNOT denetim kubiti ve ikinci bağımsız değişken target kubitidir.

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

5. DumpMachine işlevini kullanarak kübitleri dolaştırdıktan sonra hallerini görüntüleyin. Kubitlerde ölçüm gerçekleştirmediğini DumpMachine , bu nedenle DumpMachine kubit durumlarını etkilemediğini unutmayın.

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

6. M işlemini kubitleri ölçmek ve sonuçları m1 ve m2 içinde depolamak için kullanın. Ardından Reset işlemi kullanarak kubitleri sıfırlayın.

   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. Kubitlerin ölçüm sonuçlarını return deyimiyle döndürün. Main.qs dosyanızdaki son program aşağıdadır:

   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. Programınızı yerleşik simülatörde çalıştırmak için işlemin üzerindeki Kod merceciniMain çalıştır'ı seçin veya Ctrl + F5 tuşlarına basın. Çıkışınız hata ayıklama konsolunda görünür.

9. Ölçüm sonuçları bağıntılı olduğundan, programın sonunda (Zero, Zero) veya (One, One) sonucunu eşit olasılıkla alırsınız. Programı birden fazla kez tekrar çalıştırın ve bağıntıyı doğrulamak için çıktıyı gözlemleyin.

10. Devre diyagramını görselleştirmek için işlemin üzerindeki Devre kodu lensini Main seçin. Devre diyagramında ilk kubite uygulanan Hadamard kapısı ve her iki kubite de uygulanan CNOT kapısı gösterilir.

    

Diğer Zil durumlarını oluşturma

Başka Bell durumları oluşturmak için kubitlere ek Pauli $X$ veya $Z$ işlemler uygulayın.

Örneğin, Bell durumunu $\ket{\phi^-}=\frac1{\sqrt2}(\ket{00}-\ket{11})$oluşturmak için, Hadamard geçidini uyguladıktan sonra ancak CNOT uygulamadan önce denetim kubitine Pauli $Z$ işlemini uygulayın. İşlem durumu $Z$ olarak $\ket{+}$çevirir$\ket{-}$.

Uyarı

$\frac{1}{\sqrt{2}}(\ket{0}+\ket{1})$ ve $\frac{1}{\sqrt{2}}(\ket{0} - \ket{1})$ durumları sırasıyla $\ket{+}$ ve $\ket{-}$ olarak da bilinir.

İşte $\ket{\phi^-}$ durumunu oluşturmanın yolu:

1. Durum $\ket{00}$ içinde iki kübit oluşturun.

2. Denetim kubitini $H$ işlemiyle bir süperpozisyon durumuna yerleştirin.

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

3. $Z$ İşlemi denetim kubitine uygulayın.

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

4. CNOT işlemini denetim kubitine ve target durumundaki kubite $\ket{0_t}$ uygulayın.

   

$\ket{\phi^-}$ Bell durumunu Q# içinde oluşturmak için, Main.qs dosyanızdaki kodu aşağıdaki kodla değiştirin:

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

Benzer şekilde, Pauli $\ket{\psi^+}$ and $\ket{\psi^-}$ ve $X$ işlemlerini kubitlere uygulayarak Bell durumlarını $Z$ oluşturabilirsiniz.

• Bell durumunu $\ket{\psi^+}=\frac1{\sqrt2}(\ket{01}+\ket{10})$oluşturmak için, Hadamard geçidini denetim kubitine $X$ uyguladıktan sonra Pauli target geçidini kubite uygulayın. Ardından CNOT geçidini uygulayın.
• Bell durumunu $\ket{\psi^-}=\frac1{\sqrt2}(\ket{01}-\ket{10})$ oluşturmak için, denetim kübitine Hadamard kapısını uyguladıktan sonra, kontrol kübitine Pauli $Z$ ve $X$ kübitine Pauli target uygulayın. Ardından CNOT geçidini uygulayın.

Sonraki ünitede, kuantum ışınlaması olarak bilinen bir işlem olan kuantum bilgilerini göndermek için dolanıklığı kullanmayı öğreneceksiniz.