Alıştırma - Işınlanma için dolanıklığı kullanarak Q#

  • 9 dakika

Önceki ünitede kuantum ışınlama protokolünün adımlarını öğrendinsiniz. Şimdi Alice ve Bob'un kuantum ışınlama denemelerini gerçekleştirmesine yardımcı olacaksınız!

Bu ünitede, Ayla'dan Bob'a Q# ileti kubitinin durumunu göndermek için kuantum ışınlama protokolünün kullanıldığı bir program oluşturacaksınız. Program, ışınlamayı gerçekleştirmek için birlikte çalışan dört işlem içerir.

içinde kuantum ışınlama programı oluşturma Q#

Teleportasyon programınızı kullanmaya başlamak için şu adımları izleyin:

  1. Visual Studio Code'ı (VS Code) 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.

Gerekli kitaplıkları içeri aktarma

Programınızı yazmanız gereken işlemleri ve işlevleri içeren Q# kitaplıkları içeri aktarmak için aşağıdaki kodu Main.qs dosyanıza kopyalayın:

import Std.Diagnostics.*;
import Std.Intrinsic.*;
import Std.Measurement.*;

Teleport İşlemi tanımlama

Kuantum ışınlama protokolunu uygulayan adlı Teleport bir işlem oluşturun. İşlem giriş olarak iki kubit alır: message ışınlanan durumu içeren kubit ve bob ışınlanan durumu alan kubit.

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

Şimdi işlemimizdeki Teleport adımları ayıralım:

  1. alice kubit oluştur. Artık kuantum ışınlaması gerçekleştirmek için ihtiyacımız olan üç kubitimiz var: alice, bobve message.

  2. ve alice kubitlerini dolandırınbob. Bunu her zamanki gibi yaparız: alice kubitini süperpozisyon durumuna getirmek için Hadamard kapısı uygularız.

  3. Qubit message'i alice ve bob qubitlerinin oluşturduğu dolanık çiftin içine kodla. Bunu yapmak için, message'ı kontrol kubiti ve alice'i target kubiti olarak kullanarak bir CNOT geçidi uygularız. alice ve message kubit durumları artık Bell temelindedir.

  4. Bell durumlarını hesaplama durumlarına dönüştürün. Bunu yaparız çünkü Q#, Bell durumlarında doğrudan ölçüm gerçekleştiremiyoruz. Hadamard kapısını message kubitine uygulayarak durumları hesaplama tabanına dönüştürün. Aşağıdaki tablo Bell durumlarını ilgili hesaplama durumlarıyla ilişkilendirmektedir:

    Zil durumu Hesaplama temeli durumu
    $\ket{\phi^+}$ $\ket{00}$
    $\ket{\phi^-}$ $\ket{01}$
    $\ket{\psi^+}$ $\ket{10}$
    $\ket{\psi^-}$ $\ket{11}$

  5. alice ve message kubitlerini ölçün ve ölçüm sonuçlarına göre bob kubitine uygun kapıları uygulayın. İlk olarak, M ölçmek için message işlemini kullanın. Sonuç 1 ise, Z$ geçidini $öğesine bobuygulayın. Ardından, alice'ı M işlemiyle ölçün. Sonuç 1 ise, X$ geçidini $öğesine bobuygulayın.

Bu protokol, message kübitinin ilk durumunu bob kübitine ışınlar.

SetToPlus ve SetToMinus işlemlerini tanımlama

Gerçek hayattaki bir ışınlama protokolünde mesaj kubiti herhangi bir süperpoze durumda olabilir. Ne Alice ne de Bob ileti kubitinin durumunu bilmiyor. Durum bilinmese bile ileti kubitinden Bob'ın kubitine ışınlanır. Ancak içinde Q#, ileti kubitinin durumunu ışınlama protokolünden önce ayarlamalıyız.

Örneğin, 0⟩, 1⟩, +⟩ ve −⟩ gibi çeşitli başlangıç durumlarında ileti kubitiyle ışınlama protokolümüzü test etmek için SetToPlus ve SetToMinus işlemlerini oluştururuz. Bu işlemler, mesaj kubitini ışınlamadan önce istenen başlangıç durumuna getirir.

Aşağıdaki kodu SetToPlus ve SetToMinus işlemleri için Main.qs dosyanıza kopyalayın:

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

Main İşlemi tanımlama

Her Q# programında bir giriş noktası işlemi olmalıdır, varsayılan olarak bu işlem Main olacaktır. Burada, işlemimiz Main ileti kubitinin$\ket{{0}$, , , $\ket{1}$$\ket{+}$ ve $\ket{-}$farklı ilk durumları için ışınlama protokollerini çalıştırır. Protokol başarılı olursa, Bob'ın kubiti başlangıçta ileti kubitini ayarladığımız durumla aynı durumda olur.

Kuantum ışınlama programı için işlem şu Main şekildedir:

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

Hadi Main işlemin bileşenlerini parçalarına ayıralım.

  1. İki kubit message ve bob ayırın.
  2. Kuantum durumunu, kubiti istenen duruma başlatan message işlemi ve ölçümün temelini içeren tanımlama kümelerinin listesini oluşturun. Başlatma işlemleri I için $\ket{0}$, X için $\ket{1}$, SetToPlus için $\ket{+}$, ve SetToMinus için $\ket{-}$ şeklindedir.
  3. Tuple listesini yineleyerek message kubiti başlatın ve başlangıç durumunu görüntüleyin. Ardından Teleport işlemini çağırarak message kubitinin durumunu bob kubite aktarın.
  4. Kubiti bob ilgili bazda ölçün, ardından teleportasyon işlemi için kubitleri tekrar kullanabilmeniz adına sıfırlayın.
  5. Her ışınlanma için ölçüm sonuçlarını döndürür.

Protokol düzgün çalışıyorsa, bob için ölçüm sonuçlarınız message başlatılan durumlarla eşleşir.

Programı çalıştırma

Kuantum ışınlama programınız hazır! İleti kubitinin farklı başlangıç durumlarına yönelik kuantum ışınlamanın nasıl çalıştığını görmek için programı çalıştırın.

Tam program, Teleport işlemini, SetToPlus ve SetToMinus işlemlerini ve Main işlemini içerir. Kodunuzu çalıştırmak ve sonuçları analiz etmek için şu adımları izleyin:

  1. Main.qs dosyanızın içeriğini aşağıdaki Q# kodla değiştirin:

    /// This Q# program implements quantum teleportation
import Std.Diagnostics.*;
import Std.Intrinsic.*;
import Std.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);
}

  2. Programınızı yerleşik simülatörde çalıştırmak için işlemin üstünde bulunan Çalıştır kod lensini seçin. Veya Ctrl + F5 tuşlarına basın. Çıkışınız hata ayıklama konsolunda görünür.

  3. Alınan durumların ışınlanan durumlarla eşleştiğinden emin olun. Örneğin:

    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

Tebrikler! Alice'in kubitinin durumunu kuantum ışınlama protokolü aracılığıyla Bob'un kubitine başarıyla ışınladınız. Kuantum dolanıklığı sayesinde!