Tutorial: Menjelajahi entanglemen kuantum dengan Q#

Artikel
07/03/2024

Dalam tutorial ini, Anda menulis Q# program yang memanipulasi dan mengukur qubit dan menunjukkan efek superposisi dan entanglemen. Anda menyiapkan dua qubit dalam keadaan kuantum tertentu, mempelajari cara mengoperasikan qubit dengan Q# untuk mengubah keadaan mereka, dan menunjukkan efek superposisi dan entanglemen. Anda membangun program anda Q# sepotong demi sepotong untuk memperkenalkan status qubit, operasi, dan pengukuran.

Berikut adalah beberapa konsep utama yang perlu dipahami sebelum Anda mulai:

Di mana bit klasik memiliki nilai biner tunggal seperti 0 atau 1, status qubit dapat berada dalam superposisi dua status kuantum, 0 dan 1. Setiap keadaan kuantum yang mungkin memiliki amplitudo probabilitas yang terkait.
Tindakan mengukur qubit menghasilkan hasil biner dengan probabilitas tertentu, dan mengubah status qubit keluar dari superposisi.
Beberapa qubit dapat dijerat skema sehingga mereka tidak dapat dijelaskan secara independen satu sama lain. Artinya, apa pun yang terjadi pada satu qubit dalam pasangan yang terikat juga terjadi pada qubit lainnya.

Dalam tutorial ini, Anda akan mempelajari cara:

Buat Q# operasi untuk menginisialisasi qubit ke status yang diinginkan.
Memasukkan qubit ke dalam superposisi.
Ikat sepasang qubit.
Mengukur qubit dan mengamati hasilnya.

Tip

Jika Anda ingin mempercepat perjalanan komputasi kuantum Anda, lihat Kode dengan Azure Quantum, fitur unik dari situs web Azure Quantum. Di sini, Anda dapat menjalankan sampel bawaan Q# atau program Anda sendiri Q# , menghasilkan kode baru Q# dari perintah Anda, membuka dan menjalankan kode Anda di Visual Studio Code untuk Web dengan satu klik, dan mengajukan pertanyaan apa pun tentang komputasi kuantum.

Prasyarat

Untuk menjalankan sampel kode di Copilot untuk Azure Quantum, Anda memerlukan:

Akun email Microsoft (MSA).

Untuk informasi selengkapnya tentang Copilot, lihat Menjelajahi Azure Quantum.

Menginisialisasi qubit ke status yang diketahui

Langkah pertama ialah mendefinisikan operasi Q# yang akan menginisialisasi qubit ke status yang diketahui. Ini dapat dipanggil untuk mengatur qubit ke status klasik, yang berarti bahwa, ketika diukur, ia mengembalikan Zero 100% dari waktu atau mengembalikan One 100% dari waktu. Mengukur qubit mengembalikan Q# jenis Result, yang hanya dapat memiliki nilai Zero atau One.

Buka Copilot untuk Azure Quantum dan salin kode berikut ke jendela editor kode. Jangan klik Jalankan ; Anda akan menjalankan kode nanti dalam tutorial.

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, target : Qubit) : Unit {
           if desired != M(target) {
               X(target);
           }
       }
   }

Contoh kode memperkenalkan dua operasi standar, M dan X, yang mengubah status qubit.

Operasi SetQubitState:

Mengambil dua parameter: jenis Result, bernama desired, yang mewakili status yang diinginkan agar qubit berada di (Zero atau One), dan jenis Qubit.
Melakukan operasi pengukuran, M, yang mengukur status qubit (Zero atau One) dan membandingkan hasilnya dengan nilai yang ditentukan dalam desired.
Jika pengukuran tidak sesuai dengan nilai yang dibandingkan, ia menjalankan operasi X, yang membalik status qubit ke tempat peluang pengukuran mengembalikan Zero dan One dibalik. Dengan cara ini, SetQubitState selalu menempatkan qubit target dalam status yang diinginkan.

Menulis operasi pengujian untuk menguji status Bell

Selanjutnya, untuk menunjukkan efek operasi SetQubitState, buat operasi lain bernama TestBellState. Operasi ini akan mengalokasikan dua qubit, panggilan SetQubitState untuk mengatur qubit pertama ke status yang diketahui, lalu mengukur qubit untuk melihat hasilnya.

Salin kode berikut ke jendela editor kode, di SetQubitState bawah operasi.

operation TestBellState() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            set numOnesQ1 += 1;
        }
        if resultQ2 == One {
            set numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

}

Dalam kode, count variabel dan initial diatur ke 1000 dan One masing-masing. Ini menginisialisasi qubit pertama ke One dan mengukur setiap qubit 1000 kali.

Operasi TestBellState:

Mengatur variabel untuk penghitung dan status qubit awal.
Memanggil pernyataan use untuk menginisialisasi dua qubit.
Berulang untuk iterasi count. Untuk setiap perulangan,
1. Memanggil SetQubitState untuk mengatur nilai initial tertentu pada qubit pertama.
2. Memanggil SetQubitState lagi untuk mengatur qubit kedua ke status Zero.
3. Menggunakan operasi M untuk mengukur setiap qubit.
4. Menyimpan jumlah pengukuran untuk setiap qubit yang mengembalikan One.
Setelah perulangan selesai, ia memanggil SetQubitState lagi untuk mengatur ulang qubit ke status yang diketahui (Zero) agar memungkinkan yang lain mengalokasikan qubit dalam status yang diketahui. Ini diwajibkan oleh pernyataan use.
Terakhir, ini menggunakan Message fungsi untuk mencetak hasil ke jendela output Copilot sebelum mengembalikan hasilnya.

Jalankan kode di Copilot untuk Azure Quantum

Sebelum beralih ke prosedur untuk superposisi dan penjeratan, Anda dapat menguji kode hingga titik ini untuk melihat inisialisasi dan pengukuran qubit.

Untuk menjalankan kode sebagai program mandiri, Q# pengkompilasi di Copilot perlu tahu di mana harus memulai program. Ini dilakukan dalam Q# file dengan menambahkan @EntryPoint() operasi sebelumnya yang ingin Anda jalankan terlebih dahulu. Misalnya, dalam hal ini adalah TestBellState operasi.

Catatan

@EntryPoint() hanya diperlukan untuk program Q# mandiri. Saat menjalankan Q# program di Jupyter Notebooks, atau memanggil Q# program dari file host Python, itu tidak diperlukan dan akan melemparkan kesalahan jika disertakan.

@EntryPoint() Tambahkan segera sebelum TestBellState operasi dan program Anda Q# hingga titik ini sekarang akan terlihat seperti ini:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

    @EntryPoint()
    operation TestBellState() : (Int, Int, Int, Int) {
        mutable numOnesQ1 = 0;
        mutable numOnesQ2 = 0;
        let count = 1000;
        let initial = One;

        // allocate the qubits
        use (q1, q2) = (Qubit(), Qubit());   
        for test in 1..count {
            SetQubitState(initial, q1);
            SetQubitState(Zero, q2);
            
            // measure each qubit
            let resultQ1 = M(q1);            
            let resultQ2 = M(q2);           
    
            // Count the number of 'Ones' returned:
            if resultQ1 == One {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set numOnesQ2 += 1;
            }
        }
    
        // reset the qubits
        SetQubitState(Zero, q1);             
        SetQubitState(Zero, q2);
        
    
        // Display the times that |0> is returned, and times that |1> is returned
        Message($"Q1 - Zeros: {count - numOnesQ1}");
        Message($"Q1 - Ones: {numOnesQ1}");
        Message($"Q2 - Zeros: {count - numOnesQ2}");
        Message($"Q2 - Ones: {numOnesQ2}");
        return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }
}

Salin dan tempel sampel kode lengkap ke jendela Kode Copilot untuk Azure Quantum , atur slide untuk jumlah bidikan ke "1", dan klik Jalankan. Hasilnya ditampilkan dalam histogram dan di bidang Hasil .

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

Karena qubit belum dimanipulasi, mereka telah mempertahankan nilai awalnya: qubit pertama mengembalikan One setiap saat, dan qubit kedua mengembalikan Zero.

Jika Anda mengubah nilai initial menjadi Zero dan menjalankan program lagi, Anda harus mengamati bahwa qubit pertama juga kembali Zero setiap saat.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Masukkan qubit ke dalam superposisi

Saat ini, qubit dalam program ini semuanya dalam status klasik, yaitu, mereka berupa 1 atau 0. Anda tahu ini karena program menginisialisasi qubit ke status yang diketahui, dan Anda belum menambahkan proses apa pun untuk memanipulasinya. Sebelum menjerat kubit, Anda akan menempatkan qubit pertama ke dalam status superposisi, di mana pengukuran kubit akan mengembalikan Zero ~50% dari waktu dan One ~50% dari waktu. Secara konseptual, qubit dapat dianggap memiliki probabilitas yang sama untuk mengukur baik Zero atau One.

Untuk menempatkan qubit dalam superposisi, Q# menyediakan H, atau Hadamard, operasi. X Ingat operasi dari Inisialisasi qubit ke prosedur status yang diketahui sebelumnya, yang membalikkan qubit dari 0 hingga 1 (atau sebaliknya); H operasi membalik qubit setengah jalan ke dalam keadaan probabilitas Zero yang sama atau One. Ketika diukur, qubit dalam superposisi harus mengembalikan hasil kira-kira jumlah Zero dan One yang sama.

Ubah kode dalam TestBellState operasi dengan mengatur ulang nilai awal ke One dan menyisipkan baris untuk H operasi:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Sekarang ketika Anda menjalankan program, Anda dapat melihat hasil qubit pertama dalam superposisi.

Q1 - Zeros: 523            // results will vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Setiap kali Anda menjalankan program, hasil untuk qubit pertama akan sedikit berbeda, tetapi akan mendekati 50% One dan 50% Zero, sedangkan hasil untuk qubit kedua akan tetap Zero sepanjang waktu.

Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0

Lakukan inisialisasi qubit pertama untuk mengembalikan Zero hasil yang sama.

Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0

Catatan

Dengan memindahkan slider di Copilot untuk Azure Quantum dan meningkatkan jumlah bidikan, Anda dapat melihat bagaimana hasil superposisi sedikit bervariasi selama distribusi bidikan.

Ikat dua qubit

Seperti disebutkan sebelumnya, qubit terikat disambungkan sehingga qubit tersebut tidak dapat dijelaskan secara tersendiri satu sama lain. Artinya, apa pun yang terjadi pada satu qubit juga terjadi pada qubit yang terkait. Ini memungkinkan Anda untuk mengetahui status yang dihasilkan dari satu qubit tanpa mengukurnya, hanya dengan mengukur status qubit lainnya. (Contoh ini menggunakan dua qubit; namun, dimungkinkan juga untuk mengikat tiga qubit atau lebih).

Untuk mengaktifkan keterikatan, Q# menyediakan operasi CNOT, yang merupakan singkatan dari Controlled-NOT. Hasil menjalankan operasi ini pada dua qubit ialah membalik qubit kedua jika qubit pertama adalah One.

Tambahkan operasi CNOT ke program Anda segera setelah operasi H. Program penuh Anda akan terlihat seperti ini:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, target : Qubit) : Unit {
           if desired != M(target) {
               X(target);
           }
       }

    @EntryPoint()
    operation TestBellState() : (Int, Int, Int, Int) {
        mutable numOnesQ1 = 0;
        mutable numOnesQ2 = 0;
        let count = 1000;
        let initial = Zero;

        // allocate the qubits
        use (q1, q2) = (Qubit(), Qubit());   
        for test in 1..count {
            SetQubitState(initial, q1);
            SetQubitState(Zero, q2);
        
            H(q1);            
            CNOT(q1, q2);      // Add the CNOT operation after the H operation

            // measure each qubit
            let resultQ1 = M(q1);            
            let resultQ2 = M(q2);           
    
            // Count the number of 'Ones' returned:
            if resultQ1 == One {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set numOnesQ2 += 1;
            }
        }
    
        // reset the qubits
        SetQubitState(Zero, q1);             
        SetQubitState(Zero, q2);
        
    
        // Display the times that |0> is returned, and times that |1> is returned
        Message($"Q1 - Zeros: {count - numOnesQ1}");
        Message($"Q1 - Ones: {numOnesQ1}");
        Message($"Q2 - Zeros: {count - numOnesQ2}");
        Message($"Q2 - Ones: {numOnesQ2}");
        return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }
}

Sekarang ketika Anda menjalankan program, Anda akan melihat sesuatu seperti:

Q1 - Zeros: 502           // results will vary
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Perhatikan bahwa statistik untuk kubit pertama belum berubah (masih ada peluang ~ 50/50 dari atau Zero One setelah pengukuran), tetapi hasil pengukuran untuk kubit kedua selalu sama dengan pengukuran kubit pertama, tidak peduli berapa kali Anda menjalankan program. Operasi CNOT telah mengikat dua qubit, sehingga apa pun yang terjadi pada salah satu dari mereka, terjadi pada yang lain.

Prasyarat

Untuk mengembangkan dan menjalankan sampel kode di lingkungan pengembangan lokal Anda:

Versi terbaru Visual Studio Code atau buka VISUAL Code di Web.
Versi terbaru ekstensi Azure Quantum Development Kit. Untuk detail penginstalan, lihat Menginstal QDK di Visual Studio Code.

Membuat file baru Q#

Buka Visual Studio Code dan pilih File > Teks Baru untuk membuat file baru.
Simpan file sebagai CreateBellStates.qs. File ini akan berisi Q# kode untuk program Anda.

Menginisialisasi qubit ke status yang diketahui

Langkah pertama ialah mendefinisikan operasi Q# yang akan menginisialisasi qubit ke status yang diketahui. Ini bisa dipanggil untuk mengatur qubit ke status klasik, yang berarti mengembalikan Zero 100% dari waktu yang ada atau mengembalikan One 100% dari waktu yang ada. Zero dan One adalah nilai-nilai Q# yang mewakili hanya dua kemungkinan hasil pengukuran qubit.

Buka CreateBellStates.qs dan salin kode berikut:

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, target : Qubit) : Unit {
           if desired != M(target) {
               X(target);
           }
       }
   }

Contoh kode memperkenalkan dua operasi standar, M dan X, yang mengubah status qubit.

Operasi SetQubitState:

Mengambil dua parameter: jenis Result, bernama desired, yang mewakili status yang diinginkan agar qubit berada di (Zero atau One), dan jenis Qubit.
Melakukan operasi pengukuran, M, yang mengukur status qubit (Zero atau One) dan membandingkan hasilnya dengan nilai yang ditentukan dalam desired.
Jika pengukuran tidak sesuai dengan nilai yang dibandingkan, ia menjalankan operasi X, yang membalik status qubit ke tempat peluang pengukuran mengembalikan Zero dan One dibalik. Dengan cara ini, SetQubitState selalu menempatkan qubit target dalam status yang diinginkan.

Menulis operasi pengujian untuk menguji status Bell

Tambahkan operasi berikut ke file CreateBellStates.qs Anda setelah operasi SetQubitState:

operation TestBellState() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            set numOnesQ1 += 1;
        }
        if resultQ2 == One {
            set numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

}

Dalam kode, count variabel dan initial diatur ke 1000 dan One masing-masing. Ini menginisialisasi qubit pertama ke One dan mengukur setiap qubit 1000 kali.

Operasi TestBellState:

Menggunakan dua parameter: count, berapa kali untuk menjalankan pengukuran, dan initial, status yang diinginkan untuk menginisialisasi qubit.
Memanggil pernyataan use untuk menginisialisasi dua qubit.
Berulang untuk iterasi count. Untuk setiap perulangan,
1. Memanggil SetQubitState untuk mengatur nilai initial tertentu pada qubit pertama.
2. Memanggil SetQubitState lagi untuk mengatur qubit kedua ke status Zero.
3. Menggunakan operasi M untuk mengukur setiap qubit.
4. Menyimpan jumlah pengukuran untuk setiap qubit yang mengembalikan One.
Setelah perulangan selesai, ia memanggil SetQubitState lagi untuk mengatur ulang qubit ke status yang diketahui (Zero) agar memungkinkan yang lain mengalokasikan qubit dalam status yang diketahui. Ini diwajibkan oleh pernyataan use.
Akhirnya, ia menggunakan fungsi Message untuk mencetak pesan ke konsol sebelum mengembalikan hasil.

Menjalankan kode

Sebelum beralih ke prosedur untuk superposisi dan ikatan, uji kode hingga titik ini untuk melihat inisialisasi dan pengukuran qubit.

Ini dilakukan dalam Q# file dengan menambahkan @EntryPoint() operasi sebelumnya yang ingin Anda jalankan secara langsung. Misalnya, dalam hal ini adalah TestBellState operasi.

Catatan

Sekarang file CreateBellStates.qs Anda akan terlihat seperti ini:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, target : Qubit) : Unit {
           if desired != M(target) {
               X(target);
           }
       }

    @EntryPoint()
    operation TestBellState() : (Int, Int, Int, Int) {
        mutable numOnesQ1 = 0;
        mutable numOnesQ2 = 0;
        let count = 1000;
        let initial = One;

        // allocate the qubits
        use (q1, q2) = (Qubit(), Qubit());   
        for test in 1..count {
            SetQubitState(initial, q1);
            SetQubitState(Zero, q2);

            // measure each qubit
            let resultQ1 = M(q1);            
            let resultQ2 = M(q2);           

            // Count the number of 'Ones' returned:
            if resultQ1 == One {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set numOnesQ2 += 1;
            }
        }

        // reset the qubits
        SetQubitState(Zero, q1);             
        SetQubitState(Zero, q2);


        // Display the times that |0> is returned, and times that |1> is returned
        Message($"Q1 - Zeros: {count - numOnesQ1}");
        Message($"Q1 - Ones: {numOnesQ1}");
        Message($"Q2 - Zeros: {count - numOnesQ2}");
        Message($"Q2 - Ones: {numOnesQ2}");
        return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }
}

Sebelum menjalankan program, Anda perlu mengatur profil target ke Tidak Dibatasi. Pilih Tampilkan -> Palet Perintah, cari QIR, pilih Q#: Atur profil target QIR Azure Quantum, lalu pilih Q#: tidak dibatasi.

Catatan

Jika profil target tidak diatur ke Tidak Dibatasi, Anda akan mendapatkan kesalahan saat menjalankan program.
Untuk menjalankan program, pilih Jalankan Q# File dari menu drop-down ikon putar di kanan atas, klik Jalankan dari daftar perintah di bawah @EntryPoint(), atau tekan Ctrl+F5. Program ini menjalankan operasi atau fungsi yang ditandai dengan @EntryPoint() atribut pada simulator default.
Output Anda muncul di konsol debug.
```
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Karena qubit belum dimanipulasi, mereka telah mempertahankan nilai awalnya: qubit pertama mengembalikan One setiap saat, dan qubit kedua mengembalikan Zero.
Jika Anda mengubah nilai initial menjadi Zero dan menjalankan program lagi, Anda harus mengamati bahwa qubit pertama juga kembali Zero setiap saat.
```
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Tip

Ingat untuk menyimpan file Anda setiap kali Anda memperkenalkan perubahan pada kode sebelum menjalankannya lagi.

Masukkan qubit ke dalam superposisi

Saat ini, qubit dalam program ini semuanya dalam status klasik, yaitu, mereka berupa 1 atau 0. Anda tahu ini karena program menginisialisasi qubit ke status yang diketahui, dan Anda belum menambahkan proses apa pun untuk memanipulasinya. Sebelum mengikat qubit, Anda akan memasukkan qubit pertama ke dalam status superposisi, di mana pengukuran qubit akan mengembalikan Zero 50% dari waktu yang ada dan One 50% dari waktu yang ada. Secara konseptual, qubit dapat dianggap sebagai setengah jalan antara Zero dan One.

Untuk menempatkan qubit dalam superposisi, Q# menyediakan H, atau Hadamard, operasi. X Ingat operasi dari Inisialisasi qubit ke prosedur status yang diketahui sebelumnya, yang membalikkan qubit dari Zero ke One (atau sebaliknya); H operasi membalik qubit setengah jalan ke dalam keadaan probabilitas Zero yang sama atau One. Ketika diukur, qubit dalam superposisi harus mengembalikan hasil kira-kira jumlah Zero dan One yang sama.

Ubah kode dalam operasi TestBellState untuk menyertakan operasi H:

    for test in 1..count {
        use (q1, q2) = (Qubit(), Qubit());   
        for test in 1..count {
            SetQubitState(initial, q1);
            SetQubitState(Zero, q2);

            H(q1);                // Add the H operation after initialization and before measurement

            // measure each qubit
            let resultQ1 = M(q1);            
            let resultQ2 = M(q2); 
            ...

Sekarang ketika Anda menjalankan program, Anda dapat melihat hasil qubit pertama dalam superposisi:
```
Q1 - Zeros: 523            // results will vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Setiap kali Anda menjalankan program, hasil untuk qubit pertama akan sedikit berbeda, tetapi akan mendekati 50% One dan 50% Zero, sedangkan hasil untuk qubit kedua akan tetap Zero sepanjang waktu.
```
Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Lakukan inisialisasi qubit pertama untuk mengembalikan Zero hasil yang sama.
```
Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Ikat dua qubit

Tambahkan operasi CNOT ke program Anda segera setelah operasi H. Program penuh Anda akan terlihat seperti ini:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, target : Qubit) : Unit {
           if desired != M(target) {
               X(target);
           }
       }

    @EntryPoint()
    operation TestBellState() : (Int, Int, Int, Int) {
        mutable numOnesQ1 = 0;
        mutable numOnesQ2 = 0;
        let count = 1000;
        let initial = One;

        // allocate the qubits
        use (q1, q2) = (Qubit(), Qubit());   
        for test in 1..count {
            SetQubitState(initial, q1);
            SetQubitState(Zero, q2);

            H(q1);            
            CNOT(q1, q2);      // Add the CNOT operation after the H operation

            // measure each qubit
            let resultQ1 = M(q1);            
            let resultQ2 = M(q2);           

            // Count the number of 'Ones' returned:
            if resultQ1 == One {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set numOnesQ2 += 1;
            }
        }

        // reset the qubits
        SetQubitState(Zero, q1);             
        SetQubitState(Zero, q2);


        // Display the times that |0> is returned, and times that |1> is returned
        Message($"Q1 - Zeros: {count - numOnesQ1}");
        Message($"Q1 - Ones: {numOnesQ1}");
        Message($"Q2 - Zeros: {count - numOnesQ2}");
        Message($"Q2 - Ones: {numOnesQ2}");
        return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }
}

Q1 - Zeros: 502           
Q1 - Ones: 498       // results will vary
Q2 - Zeros: 502
Q2 - Ones: 498

Statistik untuk qubit pertama tidak berubah (kemungkinan 50/50 dari Zero atau One setelah pengukuran), tetapi hasil pengukuran untuk qubit kedua selalu sama dengan pengukuran qubit pertama. Operasi CNOT telah mengikat dua qubit, sehingga apa pun yang terjadi pada salah satu dari mereka, terjadi pada yang lain.

Plot histogram frekuensi

Mari kita visualisasikan distribusi hasil yang diperoleh dari menjalankan program kuantum beberapa kali. Histogram frekuensi membantu memvisualisasikan distribusi probabilitas hasil ini.

Pilih Tampilkan -> Palet Perintah, atau tekan Ctrl+Shift+P, dan ketik "histogram" yang akan memunculkan Q#opsi : Jalankan file dan tampilkan histogram . Anda juga dapat mengklik Histogram dari daftar perintah di bawah ini @EntryPoint(). Pilih opsi ini untuk membuka jendela Q# histogram.
Masukkan sejumlah bidikan untuk menjalankan program, misalnya, 100 bidikan, dan tekan Enter. Histogram akan ditampilkan di Q# jendela histogram.
Setiap bilah dalam histogram sesuai dengan kemungkinan hasil, dan tingginya mewakili berapa kali hasil tersebut diamati. Dalam hal ini, ada 50 hasil unik yang berbeda. Perhatikan bahwa untuk setiap hasil hasil pengukuran untuk qubit pertama dan kedua selalu sama.

Tip

Anda dapat memperbesar histogram menggunakan roda gulir mouse atau gerakan trackpad. Saat diperbesar, Anda dapat menggeser bagan dengan menekan 'Alt' saat menggulir.
Klik bilah untuk menampilkan persentase hasil tersebut.
Klik ikon pengaturan kiri atas untuk menampilkan opsi. Anda dapat menampilkan 10 hasil teratas, 25 hasil teratas, atau semua hasil. Anda juga dapat mengurutkan hasil dari tinggi ke rendah, atau rendah ke tinggi.

Jelajahi tutorial Q# lainnya:

Algoritma pencarian Grover menunjukkan cara menulis Q# program yang menggunakan algoritma pencarian Grover.
Quantum Fourier Transform mengeksplorasi cara menulis Q# program yang secara langsung membahas qubit tertentu.
Quantum Katas adalah tutorial dan latihan pemrograman mandiri yang bertujuan untuk mengajarkan elemen komputasi dan Q# pemrograman kuantum secara bersamaan.

Bagikan melalui

Tutorial: Menjelajahi entanglemen kuantum dengan Q#

Prasyarat

Menginisialisasi qubit ke status yang diketahui

Menulis operasi pengujian untuk menguji status Bell

Jalankan kode di Copilot untuk Azure Quantum

Masukkan qubit ke dalam superposisi

Ikat dua qubit

Prasyarat

Membuat file baru Q#

Menginisialisasi qubit ke status yang diketahui

Menulis operasi pengujian untuk menguji status Bell

Menjalankan kode

Masukkan qubit ke dalam superposisi

Ikat dua qubit

Plot histogram frekuensi

Saran dan Komentar

Sumber Daya Tambahan:

Bagikan melalui

Tutorial: Menjelajahi entanglemen kuantum dengan Q#

Prasyarat

Menginisialisasi qubit ke status yang diketahui

Menulis operasi pengujian untuk menguji status Bell

Jalankan kode di Copilot untuk Azure Quantum

Masukkan qubit ke dalam superposisi

Ikat dua qubit

Prasyarat

Membuat file baru Q#

Menginisialisasi qubit ke status yang diketahui

Menulis operasi pengujian untuk menguji status Bell

Menjalankan kode

Masukkan qubit ke dalam superposisi

Ikat dua qubit

Plot histogram frekuensi

Konten terkait

Saran dan Komentar

Sumber Daya Tambahan: