Teleportasi kuantum

Untuk modul Qiskit in Classrooms ini, siswa harus memiliki lingkungan Python yang berfungsi dengan paket-paket berikut yang sudah terpasang:

• qiskit v2.1.0 atau lebih baru
• qiskit-ibm-runtime v0.40.1 atau lebih baru
• qiskit-aer v0.17.0 atau lebih baru
• qiskit.visualization
• numpy
• pylatexenc

Untuk mengatur dan memasang paket-paket di atas, lihat panduan Pasang Qiskit. Untuk menjalankan pekerjaan di komputer kuantum nyata, siswa perlu membuat akun di IBM Quantum® dengan mengikuti langkah-langkah di panduan Siapkan akun IBM Cloud-mu.

Modul ini telah diuji dan menggunakan 14 detik waktu QPU. Ini hanya perkiraan. Penggunaan aktualmu bisa berbeda.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Tonton panduan modul oleh Dr. Katie McCormick di bawah ini, atau klik di sini untuk menontonnya di YouTube.

---

Pendahuluan dan latar belakang

Teleportasi kuantum adalah teknik dalam fisika kuantum yang memungkinkan transfer informasi kuantum dari satu lokasi ke lokasi lain tanpa secara fisik memindahkan partikel. Berbeda dari konsep teleportasi ala sci-fi, proses ini tidak melibatkan pemindahan materi. Sebaliknya, proses ini mengandalkan prinsip keterikatan kuantum, di mana dua partikel menjadi terhubung tanpa memandang jarak. Melalui serangkaian pengukuran presisi dan komunikasi klasik, keadaan kuantum satu partikel dapat diciptakan ulang di partikel lain di lokasi yang jauh, secara efektif "menteleportasi" informasi kuantum. Dalam modul ini, kita akan melihat bagaimana hal ini bekerja secara matematis, kemudian kita akan mengimplementasikan teleportasi kuantum di komputer kuantum nyata. Pendahuluan di sini akan singkat; untuk latar belakang lebih lengkap tentang informasi kuantum dan penjelasan lebih mendalam tentang teleportasi, kami merekomendasikan kursus John Watrous tentang Dasar-dasar informasi kuantum, khususnya bagian tentang Teleportasi.

Bit klasik bisa berada di keadaan 0 atau 1. Bit kuantum (Qubit) bisa berada di keadaan kuantum yang dilambangkan $|0\rangle$ dan $|1\rangle$ serta kombinasi linear dari keadaan-keadaan ini, yang disebut "superposisi", seperti $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, dengan $\alpha_0,\alpha_1 \in \mathbb{C},$ dan $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Meskipun keadaan dapat berada dalam superposisi ini, pengukuran terhadap keadaan tersebut akan "meruntuhkannya" ke keadaan $|0\rangle$ atau $|1\rangle$. Parameter $a$ dan $b$ berkaitan dengan probabilitas setiap hasil pengukuran sesuai dengan

$$P_0 = |\alpha_0|^2$$ $$P_1 = |\alpha_1|^2$$

Maka syaratnya adalah $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Fitur penting lainnya adalah bahwa bit kuantum bisa "terikat satu sama lain" (entangled), yang berarti pengukuran satu Qubit bisa memengaruhi hasil pengukuran Qubit lain yang terikat. Memahami bagaimana keterikatan berbeda dari korelasi klasik biasa agak rumit. Mari kita jelaskan notasinya dulu. Sebut dua Qubit milik teman 0 (Alice) dan teman 1 (Bob), masing-masing dalam keadaan $|0\rangle$

$$|0\rangle_B|0\rangle_A$$

atau

$$|0\rangle_1|0\rangle_0$$

kadang disingkat menjadi

$$|00\rangle$$

Perhatikan bahwa Qubit bernomor terkecil (atau huruf terkecil) berada paling kanan. Ini adalah konvensi yang disebut notasi "little-endian", yang digunakan di seluruh Qiskit. Jika keadaan dua-Qubit teman-teman adalah $|00\rangle$, dan mereka mengukur keadaan Qubit masing-masing, keduanya akan menemukan angka 0. Demikian pula jika Qubit berada dalam keadaan $|11\rangle$, setiap pengukuran mereka akan menghasilkan angka 1. Itu tidak berbeda dari kasus klasik. Namun, dalam komputasi kuantum, kita bisa menggabungkan ini dengan superposisi untuk mendapatkan keadaan seperti

$$\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$

Dalam keadaan seperti ini, apakah Qubit Alice dan Bob berada di keadaan 0 atau 1 belum diketahui, bahkan belum ditentukan oleh alam, namun kita tahu mereka akan mengukur keadaan yang sama untuk Qubit mereka. Misalnya, jika Bob mengukur Qubit-nya dalam keadaan $|0\rangle$, satu-satunya cara hal itu terjadi adalah jika pengukuran telah meruntuhkan keadaan dua-Qubit ke salah satu dari dua kemungkinan keadaan, khususnya ke $|00\rangle$. Itu membuat Qubit Alice juga berada dalam keadaan $|0\rangle$.

Keterikatan Qubit seperti ini tidak mengharuskan Qubit tetap berada secara fisik berdekatan satu sama lain. Dengan kata lain, kita bisa mengikat Qubit, kemudian memisahkannya pada jarak yang jauh, dan menggunakan keterikatan mereka untuk mengirim informasi. Keadaan terikat seperti di atas adalah unit dasar keterikatan, dan kadang disebut sebagai "e-bit", satu bit keterikatan. E-bit ini bisa dianggap sebagai sumber daya dalam komunikasi kuantum, karena setiap e-bit yang dibagi antara mitra yang berjauhan bisa digunakan, seperti yang kita uraikan di sini, untuk memindahkan informasi dari satu lokasi ke lokasi lain.

Pikiran pertama bagi banyak orang yang mempelajari ini untuk pertama kalinya adalah tentang pelanggaran relativitas: apakah kita bisa menggunakannya untuk mengirim informasi lebih cepat dari cahaya? Dengan segala cara, teruslah mempertanyakan dan menyelidiki aturan ilmiah, tapi sayangnya ini tidak akan memungkinkan kita mengirim informasi lebih cepat dari cahaya, karena alasan yang akan menjadi jelas sepanjang modul ini. Spoiler: sungguh mengejutkan hal itu BUKAN karena kecepatan penyebaran keruntuhan ini, yang tampaknya memang terjadi lebih cepat dari cahaya [1]. Kita mulai dengan dua kolaborator Alice dan Bob, yang awalnya berada di lokasi yang sama dan bisa bekerja sama pada Qubit yang sama. Para kolaborator ini akan mengikat Qubit mereka. Kemudian mereka akan berpisah ke dua lokasi geografis yang berbeda, membawa Qubit masing-masing bersama mereka. Alice kemudian akan mendapatkan informasi kuantum pada Qubit baru Q. Kita tidak membuat asumsi apa pun tentang informasi pada Q. Keadaan Q bisa menjadi rahasia yang tidak diketahui Alice; bisa jadi tidak diketahui oleh siapa pun. Tapi Alice diberi tugas untuk mentransfer informasi pada Q ke Bob. Dia akan melakukan ini menggunakan teleportasi kuantum.

Untuk mencapai ini, kita perlu mengetahui beberapa operasi kuantum atau "Gate".

Operator kuantum (Gate)

Silakan lewati bagian ini jika kamu sudah familiar dengan Gate kuantum. Jika kamu ingin memahami Gate ini lebih baik, lihat Dasar-dasar informasi kuantum, khususnya dua pelajaran pertama, di IBM Quantum Learning.

Untuk protokol teleportasi ini kita terutama akan menggunakan dua jenis Gate kuantum: Gate Hadamard dan Gate CNOT. Beberapa Gate lain memainkan peran yang lebih kecil: Gate $X$, Gate $Z$, dan Gate SWAP.

Modul ini bisa diselesaikan dengan latar belakang aljabar linear yang sangat terbatas, tapi terkadang memvisualisasikan Gate mekanika kuantum menggunakan matriks dan vektor bisa membantu. Jadi kami sajikan di sini bentuk matriks/vektor dari Gate/keadaan kuantum juga.

Keadaan yang sudah kita sajikan dipilih (sebagian berdasarkan konvensi dan sebagian berdasarkan batasan) untuk memiliki bentuk vektor:

$$|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$$ $$|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$$

Dengan cara ini, keadaan sembarang $|\psi\rangle = a|0\rangle+b|1\rangle$ bisa ditulis sebagai

$$|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$$

Ada beberapa pilihan dalam cara memperluas notasi ke keadaan multi-Qubit, tapi pilihan di bawah ini cukup standar:

$$|00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix},|01\rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, |10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\0\end{pmatrix},|11\rangle = \begin{pmatrix}0 \\ 0 \\ 0 \\ 1\end{pmatrix}.$$

Dengan pilihan notasi vektor ini, kita bisa memperkenalkan Gate kuantum yang diperlukan, efeknya pada keadaan kuantum, dan bentuk matriksnya.

Gate H Hadamard: Menciptakan keadaan superposisi. Gate satu-Qubit.

$$H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right),$$ $$H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$$ $$H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Circuit dengan Gate Hadamard dibuat sebagai berikut:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.h(0)
qc.draw("mpl")

Gate CNOT Controlled-NOT: Gate ini menggunakan dua Qubit: kontrol dan target. Memeriksa keadaan Qubit kontrol yang tidak berubah. Tapi jika Qubit kontrol berada dalam keadaan $|1\rangle$, Gate mengubah keadaan Qubit target; jika keadaan Qubit kontrol adalah $|0\rangle$ tidak ada perubahan sama sekali. Dalam notasi di bawah ini, asumsikan Qubit $A$ (Qubit paling kanan) adalah kontrol, dan Qubit $B$ (Qubit paling kiri) adalah target. Di bawah ini, notasi yang digunakan adalah $CNOT(q_{control},q_{target})|BA\rangle.$

$$CNOT(A,B)|00\rangle = |00\rangle, \\ CNOT(A,B)|01\rangle = |11\rangle, \\ CNOT(A,B)|10\rangle = |10\rangle, \\ CNOT(A,B)|11\rangle = |01\rangle$$

Kadang kamu melihat CNOT ditulis dengan urutan kontrol dan target yang hanya tersirat. Tapi tidak ada ambiguitas seperti itu dalam kode atau diagram Circuit.

$$CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}$$

Gate CNOT terlihat sedikit berbeda dalam Circuit, karena membutuhkan dua Qubit. Begini cara mengimplementasikannya:

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")

Uji pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Kebanyakan Gate memiliki bentuk matriks yang sama di Qiskit seperti di tempat lain. Tapi Gate CNOT bekerja pada dua Qubit, sehingga konvensi pengurutan Qubit tiba-tiba menjadi masalah. Teks yang mengurutkan Qubit $|q_0,q_1,...\rangle$ akan menunjukkan bentuk matriks yang berbeda untuk Gate CNOT mereka. Verifikasi dengan perkalian matriks eksplisit bahwa matriks CNOT di atas memiliki aksi yang benar pada keadaan $|01\rangle.$

Jawaban:

$CNOT|01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = |11\rangle$

Gate $X$: Setara dengan operasi NOT. Gate satu-Qubit.

$$X|0\rangle = |1\rangle,\\X|1\rangle=|0\rangle$$ $$X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$

Di Qiskit, membuat Circuit dengan Gate $X$ terlihat seperti ini:

qc = QuantumCircuit(1)
qc.x(0)
qc.draw("mpl")

Gate $Z$: Menambahkan "fase" ke suatu keadaan (faktor prefaktor, yang dalam kasus eigenstate Z $|0\rangle$ dan $|1\rangle$ berupa 1, atau -1, masing-masing). Gate satu-Qubit.

$$Z|0\rangle = |0\rangle,\\Z|1\rangle=-|1\rangle$$ $$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$

Di Qiskit, membuat Circuit dengan Gate $Z$ terlihat seperti ini:

qc = QuantumCircuit(1)
qc.z(0)
qc.draw("mpl")

Teori

Mari kita uraikan protokol teleportasi kuantum menggunakan matematika. Kemudian, di bagian berikutnya, kita akan mewujudkan pengaturan ini menggunakan komputer kuantum.

Alice dan Bob mengikat Qubit mereka: Awalnya, Qubit Alice dan Qubit Bob masing-masing, secara terpisah dalam keadaan $|0\rangle$ (asumsi yang baik dan juga inisialisasi yang benar untuk komputer kuantum IBM®). Kita bisa menulisnya sebagai $|0\rangle_B|0\rangle_A$ atau cukup sebagai $|00\rangle$. Mari kita hitung apa yang terjadi ketika Alice dan Bob menerapkan Gate Hadamard pada Qubit Alice, kemudian Gate CNOT dengan Qubit Alice sebagai kontrol dan Qubit Bob sebagai target:

$$\begin{aligned} CNOT(A,B)H_A |0\rangle_B|0\rangle_A &= CNOT(A,B)|0\rangle_B\frac{1}{\sqrt{2}}\left(|0\rangle_A+|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(CNOT(A,B)|0\rangle_B|0\rangle_A+CNOT(A,B)|0\rangle_B|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right) \end{aligned}$$

Perhatikan bahwa sekarang Qubit Alice dan Bob terikat. Meskipun belum ditentukan oleh alam apakah kedua Qubit mereka berada dalam keadaan $|0\rangle$ atau $|1\rangle$, diketahui bahwa Qubit mereka berada dalam keadaan yang sama. Alice dan Bob berpisah: Dua teman memindahkan Qubit mereka ke lokasi baru, mungkin sangat jauh. Ini disertai banyak peringatan: tidak mudah memindahkan informasi kuantum tanpa mengganggunya. Tapi informasi bisa dipindahkan, dan memang kamu akan memindahkannya dalam modul ini. Tapi ingatlah sebagai peringatan bahwa kita berharap mengalami beberapa kesalahan ketika memindahkan informasi kuantum ke mana-mana.

Q diperkenalkan: Keadaan rahasia dipersiapkan pada Qubit Q:

$$|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q$$

Pada titik ini Q hanya berdampingan dengan Qubit Alice (A). Tidak ada keterikatan, sehingga keadaan kuantum ketiga Qubit bersama-sama bisa ditulis sebagai:

$$|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).$$

Tujuannya adalah memindahkan informasi pada Q dari lokasi Alice ke lokasi Bob. Pada titik ini, kita tidak membuat klaim atau persyaratan apa pun tentang kerahasiaan atau kecepatan transfer informasi. Kita hanya mengeksplorasi bagaimana informasi bisa berpindah dari Alice ke Bob. Karena informasi dimulai pada Q, kita akan mengasumsikan Q diberi nomor terendah dalam nomor Qubit, sehingga notasi little endian menyebabkan Q menjadi Qubit paling kanan dalam matematika di bawah ini.

Alice mengikat Qubit A dan Q: Alice sekarang beroperasi dengan Gate CNOT dengan Qubit-nya sendiri sebagai kontrol dan Q sebagai target, kemudian menerapkan Gate Hadamard ke Q. Mari kita hitung keadaan tiga-Qubit setelah operasi tersebut:

$$\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}$$

Karena A dan Q berada di lokasi yang sama, mari kita kelompokkan suku-suku di atas berdasarkan hasil pengukuran pada Qubit A dan Q:

$$\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}$$

Uji pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Berdasarkan ekspresi di atas untuk keadaan ketiga Qubit, berapa probabilitas bahwa pengukuran Qubit A dan Q menghasilkan $|0\rangle_A|0\rangle_Q?$

Jawaban:

25%. Untuk melihat ini, ingat bahwa keadaan Bob harus ternormalisasi, sehingga $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Sekarang, Alice bisa mengukur Qubit A dan Q. Dia tidak bisa mengontrol hasil pengukuran itu, karena pengukuran kuantum bersifat probabilistik. Jadi ketika dia mengukur, ada 4 kemungkinan hasil dan semuanya sama kemungkinannya: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q,$ dan $|1\rangle_A|1\rangle_Q.$ Perhatikan bahwa setiap hasil memiliki implikasi yang berbeda untuk Qubit Bob. Misalnya, jika Alice menemukan Qubit-nya berada dalam $|0\rangle_A|0\rangle_Q,$ itu telah meruntuhkan seluruh keadaan kuantum 3-Qubit menjadi $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Hasil pengukuran lain untuk Alice menghasilkan keadaan yang berbeda untuk Bob. Ini semua dikumpulkan dalam tabel di bawah ini.

Hasil Alice	Keadaan Bob	Instruksi untuk Bob	Hasil
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Tidak ada	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ lalu $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Untuk semua kemungkinan hasil pengukuran pada Qubit Alice, Qubit Bob tertinggal dalam keadaan yang samar-samar menyerupai keadaan rahasia yang awalnya ada di Q. Dalam kasus di mana Alice mengukur $	0\rangle_C	0\rangle_A$(baris pertama tabel), Qubit Bob tertinggal persis dalam keadaan rahasia! Dalam kasus lain, ada sesuatu yang salah pada keadaan. Koefisien ($\alpha$) tertukar, atau ada tanda "-" di mana seharusnya ada tanda "+", atau keduanya. Untuk memodifikasi Qubit Bob agar persis sama dengan keadaan rahasia, Alice harus menelepon Bob (menggunakan beberapa cara komunikasi klasik) dan memberi tahu Bob untuk melakukan operasi tambahan pada Qubit-nya, seperti yang diuraikan dalam tabel. Misalnya, dalam baris ketiga koefisien tertukar. Jika Alice menelepon Bob dan memberitahunya untuk menerapkan Gate$X$pada Qubit-nya, itu mengubah$	0\rangle$menjadi$

Sekarang sudah jelas mengapa kita tidak bisa menggunakan pengaturan ini untuk mengirim informasi lebih cepat dari cahaya. Kita mungkin beruntung dan mengukur $|0\rangle_A|0\rangle_Q,$ artinya Bob memiliki persis keadaan rahasia, secara instan. Tapi Bob tidak tahu itu sampai kita meneleponnya dan memberi tahu dia "Kita mengukur $|0\rangle_A|0\rangle_Q$, jadi kamu tidak perlu melakukan apa-apa."

Dalam eksperimen pikiran, Qubit sering dipisahkan secara fisik dan dibawa ke lokasi baru. Komputer kuantum IBM® menggunakan Qubit keadaan padat pada chip yang tidak bisa dipisahkan. Jadi alih-alih memindahkan Alice dan Bob ke lokasi berbeda, kita akan memisahkan informasi pada chip itu sendiri menggunakan apa yang disebut "swap gate" untuk memindahkan informasi dari satu Qubit ke Qubit lain.

Eksperimen 1: Teleportasi dasar

IBM Quantum merekomendasikan penanganan masalah komputasi kuantum menggunakan kerangka kerja yang kita sebut "Qiskit patterns". Ini terdiri dari langkah-langkah berikut.

• Langkah 1: Petakan masalahmu ke Circuit kuantum
• Langkah 2: Optimalkan Circuit-mu untuk dijalankan di hardware kuantum nyata
• Langkah 3: Jalankan pekerjaanmu di komputer kuantum IBM menggunakan Runtime Primitives
• Langkah 4: Pasca-proses hasilnya

Langkah 1: Petakan masalahmu ke Circuit kuantum

Semua matematika yang kita lakukan di atas adalah menguraikan langkah 1. Kita akan mengimplementasikannya sekarang, membangun Circuit kuantum menggunakan Qiskit! Kita mulai membuat Circuit kuantum dengan tiga Qubit, dan mengikat dua Qubit Alice dan Bob. Kita akan ambil Qubit 1 dan 2 untuk ini, dan kita akan menyimpan Qubit 0 untuk keadaan rahasia.

# Step 1: Map your problem to a quantum circuit

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np

# Define registers
secret = QuantumRegister(1, "Q")
Alice = QuantumRegister(1, "A")
Bob = QuantumRegister(1, "B")

cr = ClassicalRegister(3, "c")

qc = QuantumCircuit(secret, Alice, Bob, cr)

# We entangle Alice's and Bob's qubits as in our work above. We apply a Hadamard gate and then a CNOT gate.
# Note that the second argument in the CNOT gate is the target.
qc.h(Alice)
qc.cx(Alice, Bob)

# Inserting a barrier changes nothing about the logic. It just allows us to force gates to be positioned in "layers".
qc.barrier()

# Now we will use random variables to create the secret state. Don't worry about the "u" gate and the details.
np.random.seed(42)  # fixing seed for repeatability
theta = np.random.uniform(0.0, 1.0) * np.pi  # from 0 to pi
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q
qc.u(theta, varphi, 0.0, secret)
qc.barrier()

# Now entangle Q and Alice's qubits as in the discussion above.
qc.cx(secret, Alice)
qc.h(secret)
qc.barrier()

# Now Alice measures her qubits, and stores the outcomes in the "classical registers" cr[]
qc.measure(Alice, cr[1])
qc.measure(secret, cr[0])

# Now we insert some conditional logic. If Alice measures Q in a "1" we need a Z gate, and if Alice measures A in a "1" we need an X gate (see the table).
with qc.if_test((cr[1], 1)):
    qc.x(Bob)
with qc.if_test((cr[0], 1)):
    qc.z(Bob)

qc.draw(output="mpl")

Itulah semua yang perlu kita lakukan untuk menteleportasi keadaan Alice ke Bob. Namun, ingat bahwa ketika kita mengukur keadaan kuantum $\alpha_0 |0\rangle+\alpha_1|1\rangle$ kita menemukan $|0\rangle$ atau $|1\rangle.$ Jadi di akhir semua ini, Bob pasti memiliki keadaan rahasia Alice, tapi kita tidak bisa dengan mudah memverifikasi ini dengan pengukuran. Agar pengukuran bisa memberi tahu kita bahwa kita melakukan ini dengan benar, kita harus melakukan trik. Kita memiliki operator berlabel "U" untuk "unitary" yang kita gunakan untuk mempersiapkan keadaan rahasia Alice. Kita bisa menerapkan invers U di akhir Circuit kita. Jika U memetakan keadaan $|0\rangle$ Alice menjadi $\alpha_0 |0\rangle+\alpha_1|1\rangle$, maka invers U akan memetakan $\alpha_0 |0\rangle+\alpha_1|1\rangle$ Bob kembali ke $|0\rangle.$ Jadi bagian terakhir ini tidak harus dilakukan jika tujuannya hanya untuk memindahkan informasi kuantum. Ini hanya dilakukan agar kita bisa memeriksa diri sendiri.

# Add the inverse of U and measure Bob's qubit.
qc.barrier()

qc.u(theta, varphi, 0.0, Bob).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(Bob, cr[2])  # add measurement gate

qc.draw(output="mpl")

Jadi jika kita melakukan ini dengan benar, pengukuran kita pada Qubit Bob seharusnya menghasilkan keadaan $|0\rangle$. Tentu saja, pengukuran ini bersifat probabilistik. Jadi jika ada bahkan kemungkinan kecil untuk mengukur Qubit Bob berada dalam keadaan $|1\rangle$, maka satu pengukuran bisa menghasilkan $|1\rangle.$ Kita benar-benar ingin melakukan banyak pengukuran untuk memastikan bahwa probabilitas $|0\rangle$ cukup tinggi.

Langkah 2: Optimalkan masalah untuk eksekusi kuantum

Langkah ini mengambil operasi yang ingin kita lakukan dan mengungkapkannya dalam bentuk fungsionalitas komputer kuantum tertentu. Langkah ini juga memetakan masalah kita ke tata letak komputer kuantum.

Kita akan mulai dengan memuat beberapa paket yang diperlukan untuk berkomunikasi dengan komputer kuantum IBM. Kita juga harus memilih Backend untuk dijalankan. Kita bisa memilih Backend yang paling tidak sibuk, atau memilih Backend tertentu yang propertinya sudah kita ketahui.

Ada kode di bawah ini untuk menyimpan kredensial kamu saat pertama kali digunakan. Pastikan untuk menghapus informasi ini dari notebook setelah menyimpannya ke lingkunganmu, agar kredensialmu tidak terekspos secara tidak sengaja saat kamu berbagi notebook. Lihat Set up your IBM Cloud account dan Initialize the service in an untrusted environment untuk panduan lebih lanjut.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_sherbrooke

Kita secara eksplisit mengaktifkan logika pada pengukuran.

from qiskit.circuit import IfElseOp

backend.target.add_instruction(IfElseOp, name="if_else")

Sekarang kita harus "mentranspile" Circuit kuantum. Proses ini melibatkan banyak sub-langkah dan merupakan topik yang menarik. Sebagai contoh sub-langkah: tidak semua komputer kuantum dapat langsung mengimplementasikan semua gate logis di Qiskit. Kita harus menulis gate dari Circuit kita dalam bentuk gate yang dapat diimplementasikan oleh komputer kuantum. Kita dapat melakukan proses tersebut, dan proses lainnya, menggunakan preset pass manager. Menetapkan optimization = 3 (tingkat optimasi tertinggi) memastikan bahwa pemetaan dari Circuit kuantum abstrak kita ke instruksi yang diberikan ke komputer kuantum seefisien mungkin dalam pra-pemrosesan kita.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

"Sampler" adalah primitive yang dirancang untuk mengambil sampel kemungkinan state yang dihasilkan dari Circuit kuantum, dan mengumpulkan statistik tentang state apa saja yang mungkin diukur beserta probabilitasnya. Kita mengimpor Qiskit Runtime Sampler di sini:

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Tidak semua komputasi pada komputer kuantum dapat disimulasikan secara wajar di komputer klasik. Teleportasi sederhana ini memang bisa, tetapi sama sekali tidak mengherankan bahwa kita dapat menyimpan informasi secara klasik di satu tempat atau tempat lain. Kami sangat menyarankan untuk melakukan perhitungan ini menggunakan komputer kuantum IBM yang nyata. Namun jika penggunaan gratis bulananmu sudah habis, atau jika sesuatu harus diselesaikan di kelas dan tidak bisa menunggu dalam antrean, modul ini bisa diselesaikan menggunakan simulator. Untuk melakukan ini, cukup jalankan sel di bawah ini dan hapus komentar pada baris terkait di langkah "Execute".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

Langkah 3: Eksekusi

Gunakan Sampler untuk menjalankan job-mu, dengan Circuit sebagai argumen.

job = sampler.run([qc_isa])
# job = sampler_sim.run([qc_isa])
res = job.result()
counts = res[0].data.c.get_counts()

Langkah 4: Pasca-pemrosesan dan analisis

Mari kita plot hasilnya dan interpretasikan.

# This required 5 s to run on a Heron r2 processor on 10-28-24
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

State mana di atas yang menunjukkan teleportasi berhasil, dan bagaimana cara kamu mengetahuinya?

Jawaban:

State $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ semuanya konsisten dengan teleportasi yang berhasil. Ini karena kita menambahkan gate untuk membatalkan persiapan awal state rahasia. Jika state rahasia berhasil diteleportasikan ke Qubit Bob, gate tambahan tersebut seharusnya mengembalikan Qubit Bob ke state $|0\rangle$. Jadi state mana pun di atas dengan Qubit Bob (Qubit 0, juga diukur ke komponen ke-0 dari register klasik, dan karenanya yang tertinggi/paling kanan) dalam state $|0\rangle$ menunjukkan keberhasilan.

Plot ini menampilkan semua hasil pengukuran untuk ketiga Qubit, selama 5.000 percobaan atau "shot". Kita sudah menyebutkan sebelumnya bahwa Alice akan mengukur semua kemungkinan state untuk Qubit A dan Q dengan probabilitas yang sama. Kita menetapkan Qubit 0–2 dalam Circuit ke Q, A, dan B, secara berurutan. Dalam notasi little-endian, Qubit Bob adalah yang paling kiri/terendah. Jadi empat batang di sebelah kiri sesuai dengan Qubit Bob yang berada dalam state $|0\rangle$, dan dua Qubit lainnya dalam semua kombinasi yang mungkin dengan probabilitas yang kira-kira sama. Perhatikan bahwa hampir semua (biasanya ~95%) pengukuran menghasilkan Qubit Bob dalam state $|0\rangle$, artinya pengaturan kita berhasil! Ada sejumlah kecil shot (~5%) yang menghasilkan Qubit Bob dalam state $|1\rangle$. Itu seharusnya secara logis tidak mungkin. Namun, semua komputer kuantum modern mengalami noise dan error jauh lebih besar daripada komputer klasik. Dan koreksi error kuantum masih merupakan bidang yang sedang berkembang.

Eksperimen 2: Teleportasi melintasi prosesor

Yang paling menarik dari teleportasi kuantum adalah bahwa state kuantum dapat diteleportasikan jarak jauh secara instan (meskipun komunikasi klasik gate tambahan tidak instan). Seperti yang sudah disebutkan, kita tidak bisa memisahkan Qubit dari prosesor dan memindahkannya. Namun kita bisa memindahkan informasi dari satu Qubit ke Qubit lain, sampai Qubit yang terlibat dalam teleportasi berada di sisi berlawanan dari prosesor. Mari kita ulangi langkah-langkah yang sudah kita ambil di atas, tetapi sekarang kita akan membuat Circuit yang lebih besar dengan Qubit yang cukup untuk merentangi prosesor.

Langkah 1: Petakan masalahmu ke Circuit kuantum

Kali ini, Qubit yang sesuai dengan Alice dan Bob akan berubah. Jadi kita tidak akan menamai satu Qubit "A" dan yang lain "B". Sebaliknya, kita akan menomori Qubit dan menggunakan variabel untuk mewakili posisi informasi saat ini pada Qubit milik Alice dan Bob. Semua langkah lain kecuali gate swap adalah seperti yang dijelaskan sebelumnya.

# Step 1: Map

# Define registers
qr = QuantumRegister(13, "q")

qc = QuantumCircuit(qr, cr)

# Define registers
secret = QuantumRegister(1, "Q")
ebitsa = QuantumRegister(6, "A")
ebitsb = QuantumRegister(6, "B")
# q = ClassicalRegister(1, "q meas")
# a = ClassicalRegister(1, "a")
# b = ClassicalRegister(1, "b")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)

# We'll start Alice in the middle of the circuit, then move information outward in both directions.
Alice = 5
Bob = 0
qc.h(ebitsa[Alice])
qc.cx(ebitsa[Alice], ebitsb[Bob])

# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits, until the information is on distant qubits.

for n in range(Alice):
    qc.swap(ebitsb[Bob], ebitsb[Bob + 1])
    qc.swap(ebitsa[Alice], ebitsa[Alice - 1])
    Alice = Alice - 1
    Bob = Bob + 1

qc.barrier()

# Create a random state for Alice (qubit zero)
np.random.seed(42)  # fixing seed for repeatability
# theta = np.random.uniform(0.0, 1.0) * np.pi    #from 0 to pi
theta = 0.3
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

qc.u(theta, varphi, 0.0, secret)

# Entangle Alice's two qubits
qc.cx(secret, ebitsa[Alice])
qc.h(secret)

qc.barrier()

# Make measurements of Alice's qubits and store the results in the classical register.
qc.measure(ebitsa[Alice], cr[1])
qc.measure(secret, cr[0])

# Send instructions to Bob's qubits based on the outcome of Alice's measurements.
with qc.if_test((cr[1], 1)):
    qc.x(ebitsb[Bob])
with qc.if_test((cr[0], 1)):
    qc.z(ebitsb[Bob])

qc.barrier()

# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.
qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(ebitsb[Bob], cr[2])  # add measurement gate

qc.draw("mpl")

Kamu bisa melihat dalam diagram Circuit bahwa langkah-langkah logisnya sama. Satu-satunya perbedaan adalah bahwa kita menggunakan gate swap untuk membawa state Qubit Alice dari Qubit 6 ($A_5$) ke Qubit 1 ($A_0$), tepat di sebelah Q. Dan kita menggunakan gate swap untuk membawa state awal Bob dari Qubit 7 ($B_0$) ke Qubit 12 ($B_5$). Perhatikan bahwa state pada Qubit 12 bahkan tidak terkait dengan state rahasia Q sampai pengukuran dilakukan pada Qubit 0 dan 1 yang jauh, dan state pada Qubit 12 tidak sama dengan state rahasia sampai gate $X$ dan $Z$ kondisional diterapkan.

Langkah 2: Optimalkan Circuit-mu

Biasanya, ketika kita menggunakan pass manager untuk mentranspile dan mengoptimalkan Circuit kita, masuk akal untuk menetapkan optimization_level = 3, karena kita ingin Circuit kita seefisien mungkin. Dalam kasus ini, tidak ada alasan komputasional bagi kita untuk mentransfer state dari Qubit 6 dan 7 ke Qubit 1 dan 12. Itu hanya sesuatu yang kita lakukan untuk mendemonstrasikan teleportasi jarak jauh. Jika kita meminta pass manager untuk mengoptimalkan Circuit kita, ia akan menyadari tidak ada alasan logis untuk gate swap ini, dan akan menghapusnya serta melakukan operasi gate pada Qubit yang berdekatan. Jadi untuk kasus khusus ini, kita menggunakan optimization_level = 0.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pmzero = generate_preset_pass_manager(target=target, optimization_level=0)

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Kita bisa memvisualisasikan di mana Qubit ini berada pada prosesor kuantum menggunakan fungsi plot_circuit_layout.

Langkah 3: Eksekusi

Seperti sebelumnya, kami menyarankan untuk menjalankan pada komputer kuantum IBM yang nyata. Jika penggunaan gratis bulananmu sudah habis, silakan hapus komentar pada sel simulator untuk menjalankan di simulator.

# This required 5 s to run on a Heron r2 processor on 10-28-24
job = sampler.run([qc_isa_zero])
# job = sampler_sim.run([qc_isa_zero])
counts = job.result()[0].data.c.get_counts()

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Langkah 4: Pasca-pemrosesan klasik

Sekali lagi kita melihat bahwa probabilitas untuk kemungkinan hasil Qubit Alice cukup seragam. Ada preferensi kuat untuk menemukan Qubit Bob dalam $|0\rangle$ setelah membalikkan kode rahasia, artinya ada probabilitas tinggi bahwa kita berhasil menteleportasikan state rahasia melintasi prosesor dari Q ke Bob (Qubit 0 ke 12). Namun, kita mencatat bahwa sekarang ada peluang yang lebih tinggi untuk tidak mengukur $|0\rangle$ bagi Bob. Ini adalah pelajaran penting dalam komputasi kuantum: semakin banyak gate yang kamu miliki, terutama gate multi-Qubit seperti gate swap, semakin banyak noise dan error yang akan kamu temui.

Pertanyaan

Instruktur dapat meminta versi notebook ini dengan kunci jawaban dan panduan penempatan dalam kurikulum umum dengan mengisi survei singkat tentang bagaimana notebook digunakan.

Konsep kritis

• Qubit dapat terjerat, artinya pengukuran satu Qubit mempengaruhi atau bahkan menentukan state Qubit lain.
• Keterjeratan berbeda dari korelasi klasik; misalnya, Qubit A dan B bisa berada dalam superposisi state seperti $\alpha_0|00\rangle+\alpha_1|11\rangle.$ State A atau B mungkin tidak ditentukan oleh alam, namun A dan B masih bisa dijamin berada dalam state yang sama.
• Melalui kombinasi keterjeratan dan pengukuran, kita dapat mentransfer state (yang dapat menyimpan informasi) dari satu Qubit ke Qubit lain. Transfer ini bahkan bisa dilakukan jarak jauh, dan ini disebut teleportasi kuantum.
• Teleportasi kuantum bergantung pada pengukuran kuantum, yang bersifat probabilistik. Dengan demikian, komunikasi klasik mungkin diperlukan untuk menyesuaikan state yang diteleportasikan. Hal ini mencegah teleportasi kuantum memindahkan informasi lebih cepat dari cahaya. Teleportasi kuantum tidak melanggar relativitas atau kausalitas.
• Komputer kuantum modern lebih rentan terhadap noise dan error dibandingkan komputer klasik. Perkirakan beberapa persen error.
• Semakin banyak gate yang kamu tambahkan secara berurutan (terutama gate 2-Qubit), semakin banyak error dan noise yang bisa kamu harapkan.

Pertanyaan Benar/Salah

1. B/S Teleportasi kuantum dapat digunakan untuk mengirim informasi lebih cepat dari cahaya.
2. B/S Bukti modern menunjukkan bahwa runtuhnya state kuantum merambat lebih cepat dari cahaya.
3. B/S Di Qiskit, Qubit diurutkan dalam state dengan Qubit bernomor terendah di sebelah kanan, seperti dalam $|q_3,q_2,q_1, q_0\rangle$

Pertanyaan pilihan ganda

1. Qubit A dan B terjerat, lalu dipisahkan oleh jarak yang jauh $d$. Qubit A diukur. Pernyataan mana yang benar tentang kecepatan state Qubit B terpengaruh?

• a. Qubit B terpengaruh secara instan, dalam toleransi eksperimental, dalam eksperimen yang telah dijalankan sejauh ini.
• b. Qubit B terpengaruh setelah waktu $d/c$, artinya state kuantum "runtuh" dengan kecepatan kira-kira cahaya, dalam toleransi eksperimental.
• c. Qubit B hanya terpengaruh setelah komunikasi klasik terjadi, artinya terjadi dalam waktu yang lebih lama dari $d/c$.
• d. Tidak ada yang di atas

2. Ingat bahwa probabilitas pengukuran terkait dengan amplitudo dalam state kuantum. Misalnya, jika sebuah Qubit awalnya berada dalam state $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ probabilitas mengukur state $|0\rangle$ adalah $|\alpha_0|^2.$ Tidak semua set pengukuran akan cocok persis dengan probabilitas ini, karena pengambilan sampel yang terbatas (seperti melempar koin bisa menghasilkan kepala dua kali berturut-turut). Histogram pengukuran di bawah bisa sesuai dengan state kuantum mana di bawah ini? Pilih opsi terbaik.

• a. $|0\rangle$
• b. $\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$
• d. $\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle$
• e. $\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle$

3. State mana di bawah ini yang menunjukkan Qubit A dan B terjerat? Pilih semua yang berlaku.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)$
• e. $|0\rangle_B|0\rangle_A$

4. Dalam modul ini, kita menyiapkan state terjerat: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Namun ada banyak state terjerat lain yang bisa digunakan untuk protokol serupa. State mana di bawah ini yang bisa menghasilkan histogram pengukuran 2-Qubit seperti berikut? Pilih respons terbaik.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A$
• e. $|0\rangle_B|0\rangle_A$

Pertanyaan diskusi

1. Jelaskan protokol teleportasi kuantum, dari awal hingga akhir, kepada pasangan/kelompokmu. Lihat apakah mereka punya sesuatu untuk ditambahkan, atau jika mereka punya pertanyaan.

2. Apakah ada sesuatu yang unik tentang state terjerat awal antara Alice dan Bob: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Jika ya, apa yang unik? Jika tidak, state terjerat lain apa yang bisa kita gunakan?