Teleportasi kuantum

Untuk modul Qiskit dalam Bilik Darjah ini, pelajar perlu mempunyai persekitaran Python yang berfungsi dengan pakej-pakej berikut dipasang:

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

Untuk menyediakan dan memasang pakej-pakej di atas, lihat panduan Pasang Qiskit. Untuk menjalankan kerja pada komputer kuantum sebenar, pelajar perlu membuat akaun dengan IBM Quantum® dengan mengikuti langkah-langkah dalam panduan Sediakan akaun IBM Cloud anda.

Modul ini telah diuji dan menggunakan 14 saat masa QPU. Ini adalah anggaran sahaja. Penggunaan sebenar anda mungkin berbeza.

# 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, atau klik di sini untuk menontonnya di YouTube.

---

Pengenalan dan latar belakang

Teleportasi kuantum adalah teknik dalam fizik kuantum yang membolehkan pemindahan maklumat kuantum dari satu lokasi ke lokasi lain tanpa menggerakkan zarah secara fizikal. Tidak seperti konsep teleportasi dalam fiksyen sains, proses ini tidak melibatkan pengangkutan jirim. Sebaliknya, ia bergantung pada prinsip pemerangkapan kuantum, di mana dua zarah menjadi terhubung tanpa mengira jarak. Melalui siri pengukuran yang tepat dan komunikasi klasik, keadaan kuantum satu zarah boleh dicipta semula dalam zarah lain di lokasi yang jauh, secara berkesan "menteleport" maklumat kuantum tersebut. Dalam modul ini, kita akan melihat bagaimana ini berfungsi secara matematik, kemudian kita akan melaksanakan teleportasi kuantum pada komputer kuantum sebenar. Pengenalan di sini akan ringkas; untuk latar belakang lebih lanjut mengenai maklumat kuantum, dan penjelasan lebih lanjut tentang teleportasi, kami mengesyorkan kursus John Watrous tentang Asas maklumat kuantum, khususnya bahagian tentang Teleportasi.

Bit klasik boleh berada dalam keadaan 0 atau 1. Bit kuantum (Qubit) boleh berada dalam keadaan kuantum yang ditandai $|0\rangle$ dan $|1\rangle$ dan juga gabungan linear keadaan-keadaan ini, dipanggil "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.$ Walaupun keadaan-keadaan boleh wujud dalam superposisi ini, pengukuran keadaan akan "meruntuhkan"nya ke dalam sama ada keadaan $|0\rangle$ atau $|1\rangle$. Parameter $a$ dan $b$ berkaitan dengan kebarangkalian setiap hasil pengukuran mengikut

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

Maka kekangan bahawa $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Ciri penting lain ialah bit kuantum boleh "diperam", yang bermaksud pengukuran satu Qubit boleh mempengaruhi hasil pengukuran Qubit lain yang diperam. Memahami bagaimana pemerangkapan berbeza daripada korelasi klasik mudah adalah agak rumit. Mari kita jelaskan dahulu notasi kita. Panggil dua Qubit milik rakan 0 (Alice) dan rakan 1 (Bob), dan masing-masing dalam keadaan $|0\rangle$

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

atau

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

kadangkala dipendekkan kepada sahaja

$$|00\rangle$$

Perhatikan bahawa Qubit bernombor terkecil (atau bersuratkan) berada paling kanan. Ini adalah konvensyen yang dipanggil notasi "little-endian", digunakan di seluruh Qiskit. Jika keadaan dua Qubit rakan-rakan adalah $|00\rangle,$ dan mereka mengukur keadaan Qubit masing-masing, mereka masing-masing akan mendapat 0. Begitu juga jika Qubit-Qubit berada dalam keadaan $|11\rangle,$ setiap pengukuran mereka akan menghasilkan 1. Itu tidak berbeza daripada kes klasik. Walau bagaimanapun, dalam pengkomputeran kuantum, kita boleh menggabungkan ini dengan superposisi untuk mendapatkan keadaan seperti

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

Dalam keadaan seperti ini, sama ada Qubit Alice dan Bob berada dalam keadaan 0 atau 1 belum diketahui, bahkan belum ditentukan oleh alam semula jadi, namun kita tahu mereka akan mengukur keadaan yang sama untuk Qubit mereka. Sebagai contoh, jika Bob mengukur Qubitnya dalam keadaan $|0\rangle,$ satu-satunya cara untuk itu berlaku adalah jika pengukuran telah meruntuhkan keadaan dua Qubit ke salah satu daripada dua keadaan yang mungkin, khususnya ke $|00\rangle.$ Itu menyebabkan Qubit Alice juga dalam keadaan $|0\rangle$.

Pemerangkapan Qubit-Qubit dengan cara ini tidak memerlukan Qubit-Qubit tersebut kekal secara fizikal berdekatan antara satu sama lain. Dengan kata lain, kita boleh merangkap Qubit-Qubit, kemudian memisahkannya dengan jarak yang jauh, dan menggunakan pemerangkapan mereka untuk menghantar maklumat. Keadaan terperangkap seperti yang di atas adalah unit asas pemerangkapan, dan kadang-kadang dirujuk sebagai "e-bit", satu bit pemerangkapan. E-bit ini boleh difikirkan sebagai sumber dalam komunikasi kuantum, kerana setiap e-bit yang dikongsi antara rakan-rakan yang jauh boleh digunakan, seperti yang kita gariskan di sini, untuk menggerakkan maklumat dari satu lokasi ke lokasi lain.

Fikiran pertama bagi ramai orang yang mempelajari ini buat kali pertama adalah tentang melanggar relativiti: bolehkah kita menggunakan ini untuk menghantar maklumat lebih laju daripada cahaya? Dengan segala cara, teruskan mempersoalkan dan menyelidik peraturan saintifik, tetapi malangnya ini tidak akan membolehkan kita menghantar maklumat lebih laju daripada cahaya, atas sebab-sebab yang akan menjadi jelas dalam perjalanan modul ini. Spoiler: secara menakjubkan ia BUKAN kerana kelajuan keruntuhan ini merebak, yang kelihatan berlaku lebih laju daripada cahaya [1]. Kita mulai dengan dua orang rakan Alice dan Bob, yang pada mulanya berada di lokasi yang sama dan boleh bekerja bersama pada Qubit yang sama. Rakan-rakan ini akan merangkap Qubit mereka. Kemudian mereka akan berpisah ke dua lokasi geografi yang berbeza, membawa Qubit masing-masing bersama mereka. Alice kemudian akan mendapat maklumat kuantum pada Qubit Q yang baru. Kita tidak membuat sebarang andaian tentang maklumat pada Q. Keadaan Q boleh menjadi rahsia yang tidak diketahui Alice; ia boleh tidak diketahui semua orang. Tetapi Alice diberi tugas untuk memindahkan maklumat pada Q kepada Bob. Dia akan melakukan ini menggunakan teleportasi kuantum.

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

Pengendali kuantum (Gate)

Jangan ragu untuk melangkau bahagian ini jika anda sudah biasa dengan Gate kuantum. Jika anda ingin memahami Gate-Gate ini dengan lebih baik, semak Asas maklumat kuantum, terutamanya dua pelajaran pertama, di IBM Quantum Learning.

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

Modul ini boleh diselesaikan dengan latar belakang aljabar linear yang sangat terhad, tetapi kadang-kadang memvisualisasikan Gate mekanikal kuantum menggunakan matriks dan vektor boleh membantu. Jadi kita bentangkan di sini bentuk matriks/vektor Gate/keadaan kuantum juga.

Keadaan-keadaan yang telah kita bentangkan dipilih (sebahagiannya berdasarkan konvensyen dan sebahagiannya berdasarkan kekangan) untuk mempunyai bentuk vektor:

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

Dengan cara ini, keadaan sewenang-wenangnya $|\psi\rangle = a|0\rangle+b|1\rangle$ boleh ditulis sebagai

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

Ada beberapa pilihan dalam cara melanjutkan notasi ke keadaan berbilang Qubit, tetapi pilihan di bawah adalah cukup standard:

$$|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 dalam fikiran, kita boleh memperkenalkan Gate kuantum yang diperlukan, kesannya pada keadaan kuantum, dan bentuk matriks mereka.

Gate H Hadamard: Mencipta 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}$$

Sebuah Circuit dengan Gate Hadamard dibina seperti berikut:

from qiskit import QuantumCircuit

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

Gate CNOT Controlled-NOT: Gate ini menggunakan dua Qubit: kawalan dan sasaran. Memeriksa keadaan Qubit kawalan yang tidak diubah. Tetapi jika Qubit kawalan berada dalam keadaan $|1\rangle$, Gate mengubah keadaan Qubit sasaran; jika keadaan Qubit kawalan adalah $|0\rangle$ tiada perubahan langsung dibuat. Dalam notasi di bawah, anggap Qubit $A$ (Qubit paling kanan) adalah kawalan, dan Qubit $B$ (Qubit paling kiri) adalah sasaran. Di bawah, notasi yang digunakan ialah $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$$

Anda mungkin kadang-kadang melihat CNOT ditulis dengan urutan kawalan dan sasaran hanya tersirat. Tetapi tiada kekaburan sedemikian dalam kod atau dalam gambar rajah Circuit.

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

Gate CNOT kelihatan agak berbeza dalam sebuah Circuit, kerana ia memerlukan dua Qubit. Beginilah cara ia dilaksanakan:

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

Uji kefahaman anda

Baca soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Kebanyakan Gate mempunyai bentuk matriks yang sama dalam Qiskit seperti di mana-mana sahaja. Tetapi Gate CNOT bertindak pada dua Qubit, dan tiba-tiba konvensyen pengurutan Qubit menjadi isu. Teks yang mengatur Qubit $|q_0,q_1,...\rangle$ akan menunjukkan bentuk matriks yang berbeza untuk Gate CNOT mereka. Sahkan melalui pendaraban matriks eksplisit bahawa matriks CNOT di atas mempunyai tindakan yang betul pada keadaan $|01\rangle.$

Jawapan:

$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$: Bersamaan 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}$$

Dalam Qiskit, membuat Circuit dengan Gate $X$ kelihatan seperti ini:

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

Gate $Z$: Menambah "fasa" pada keadaan (faktor praawalan, yang dalam kes keadaan eigen Z $|0\rangle$ dan $|1\rangle$ adalah sama ada 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}$$

Dalam Qiskit, membuat Circuit dengan Gate $Z$ kelihatan seperti ini:

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

Teori

Mari kita gariskan protokol untuk teleportasi kuantum menggunakan matematik. Kemudian, dalam bahagian seterusnya, kita akan merealisasikan persediaan ini menggunakan komputer kuantum.

Alice dan Bob merangkap Qubit mereka: Pada mulanya, Qubit Alice dan Qubit Bob masing-masing berada dalam keadaan $|0\rangle$ secara berasingan (andaian yang baik dan juga permulaan yang betul untuk komputer kuantum IBM®). Kita boleh menulisnya sebagai $|0\rangle_B|0\rangle_A$ atau ringkasnya sebagai $|00\rangle$. Mari kita kira apa yang berlaku apabila Alice dan Bob bertindak dengan Gate Hadamard pada Qubit Alice, kemudian Gate CNOT dengan Qubit Alice sebagai kawalan dan Qubit Bob sebagai sasaran:

$$\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 bahawa kini Qubit Alice dan Bob telah diperam. Walaupun belum ditentukan oleh alam semula jadi sama ada kedua-dua Qubit mereka berada dalam keadaan $|0\rangle$ atau keadaan $|1\rangle$, diketahui bahawa Qubit mereka berada dalam keadaan yang sama. Alice dan Bob berpisah: Dua orang rakan itu menggerakkan Qubit mereka ke lokasi baru, mungkin sangat jauh. Ini datang dengan banyak amaran: ia tidak mudah untuk menggerakkan maklumat kuantum tanpa mengganggunya. Tetapi ia boleh digerakkan, dan memang anda akan menggerakkannya dalam modul ini. Tetapi ingatlah sebagai amaran bahawa kita dijangka menghadapi beberapa ralat apabila kita menggerakkan maklumat kuantum banyak-banyak.

Q diperkenalkan: Keadaan rahsia disediakan pada Qubit Q:

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

Pada ketika ini Q hanya bersebelahan dengan Qubit Alice (A). Tiada pemerangkapan berlaku, jadi keadaan kuantum ketiga-tiga Qubit bersama-sama boleh 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).$$

Matlamatnya adalah untuk menggerakkan maklumat pada Q dari lokasi Alice ke lokasi Bob. Pada ketika ini, kita tidak membuat sebarang tuntutan atau keperluan tentang kerahsiaan atau kelajuan pemindahan maklumat. Kita hanya meneroka bagaimana maklumat boleh berpindah dari Alice kepada Bob. Kerana maklumat bermula pada Q, kita akan mengandaikan Q diberikan nombor terkecil dalam nombor Qubit, supaya notasi little endian menyebabkan Q menjadi Qubit paling kanan dalam matematik di bawah.

Alice merangkap Qubit A dan Q: Alice kini beroperasi dengan Gate CNOT dengan Qubitnya sendiri sebagai kawalan dan Q sebagai sasaran, kemudian menerapkan Gate Hadamard pada Q. Mari kita kira keadaan tiga Qubit selepas operasi itu:

$$\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}$$

Kerana A dan Q berada di lokasi yang sama, marilah kita kumpulkan sebutan di atas mengikut 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 kefahaman anda

Baca soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Berdasarkan ungkapan di atas untuk keadaan ketiga-tiga Qubit, berapakah kebarangkalian pengukuran Qubit A dan Q menghasilkan $|0\rangle_A|0\rangle_Q?$

Jawapan:

25%. Untuk melihat ini, ingat bahawa keadaan Bob mesti dinormalisasi, jadi $|_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}$

Kini, Alice boleh mengukur Qubit A dan Q. Dia tidak boleh mengawal hasil pengukuran itu, kerana pengukuran kuantum adalah kebarangkalian. Jadi apabila dia mengukur, terdapat 4 hasil yang mungkin dan kesemua 4 adalah sama berkemungkinan: $|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 bahawa setiap hasil mempunyai implikasi yang berbeza untuk Qubit Bob. Sebagai contoh, jika Alice mendapati Qubitnya dalam keadaan $|0\rangle_A|0\rangle_Q,$ itu telah meruntuhkan keseluruhan keadaan kuantum 3 Qubit kepada $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Hasil pengukuran lain oleh Alice menghasilkan keadaan yang berbeza untuk Bob. Ini dikumpulkan bersama dalam jadual di bawah.

Hasil Alice	Keadaan Bob	Arahan kepada Bob	Keputusan
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Tiada	$\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$ kemudian $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Bagi semua hasil pengukuran yang mungkin pada Qubit Alice, Qubit Bob ditinggalkan dalam keadaan yang samar-samar menyerupai keadaan rahsia yang asalnya pada Q. Dalam kes di mana Alice mengukur $	0\rangle_C	0\rangle_A$(baris pertama jadual), Qubit Bob ditinggalkan dalam keadaan rahsia tepat-tepat! Dalam kes-kes lain, ada sesuatu yang tidak kena dengan keadaan. Pekali ($\alpha$) ditukar, atau ada tanda "-" di mana sepatutnya ada tanda "+", atau kedua-duanya. Untuk mengubah suai Qubit Bob supaya tepat sama dengan keadaan rahsia, Alice mesti menghubungi Bob (menggunakan beberapa cara komunikasi klasik) dan memberitahu Bob untuk melakukan operasi tambahan pada Qubitnya, seperti yang digariskan dalam jadual. Sebagai contoh, dalam baris ketiga pekali ditukar. Jika Alice menghubungi Bob dan memberitahunya untuk menerapkan Gate$X$pada Qubitnya, ia menukar$	0\rangle$kepada$

Sekarang harus jelas mengapa kita tidak boleh menggunakan persediaan ini untuk menghantar maklumat lebih laju daripada cahaya. Kita mungkin bernasib baik dan mengukur $|0\rangle_A|0\rangle_Q,$ bermakna Bob mempunyai keadaan rahsia tepat-tepat, serta-merta. Tetapi Bob tidak tahu itu sehingga kita menghubunginya dan memberitahunya "Kami mengukur $|0\rangle_A|0\rangle_Q$, jadi anda tidak perlu melakukan apa-apa."

Dalam eksperimen pemikiran, Qubit-Qubit sering dipisahkan secara fizikal dan dibawa ke lokasi baru. Komputer kuantum IBM® menggunakan Qubit keadaan pepejal pada cip yang tidak boleh dipisahkan. Jadi daripada menggerakkan Alice dan Bob ke lokasi yang berbeza, kita akan memisahkan maklumat pada cip itu sendiri dengan menggunakan apa yang dipanggil "gate swap" untuk menggerakkan maklumat dari satu Qubit ke Qubit yang lain.

Eksperimen 1: Teleportasi asas

IBM Quantum mengesyorkan menangani masalah pengkomputeran kuantum menggunakan rangka kerja yang kita panggil "corak Qiskit". Ia terdiri daripada langkah-langkah berikut.

• Langkah 1: Petakan masalah anda ke Circuit kuantum
• Langkah 2: Optimumkan Circuit anda untuk dijalankan pada perkakasan kuantum sebenar
• Langkah 3: Laksanakan kerja anda pada komputer kuantum IBM menggunakan Runtime Primitives
• Langkah 4: Proses pasca keputusan

Langkah 1: Petakan masalah anda ke Circuit kuantum

Semua matematik yang kita lakukan di atas adalah menggariskan langkah 1. Kita akan melaksanakannya sekarang, membina Circuit kuantum kita menggunakan Qiskit! Kita mulakan dengan membuat Circuit kuantum dengan tiga Qubit, dan merangkap dua Qubit Alice dan Bob. Kita akan mengambil ini sebagai Qubit 1 dan 2, dan kita akan menyimpan Qubit 0 untuk keadaan rahsia.

# 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 mendapatkan keadaan Alice diteleport kepada Bob. Walau bagaimanapun, ingat bahawa apabila kita mengukur keadaan kuantum $\alpha_0 |0\rangle+\alpha_1|1\rangle$ kita mendapati sama ada $|0\rangle$ atau $|1\rangle.$ Jadi pada akhir semua ini, Bob pasti mempunyai keadaan rahsia Alice, tetapi kita tidak dapat mengesahkan ini dengan mudah melalui pengukuran. Untuk membolehkan pengukuran memberitahu kita bahawa kita melakukan ini dengan betul, kita perlu melakukan satu helah. Kita mempunyai pengendali berlabel "U" untuk "uniter" yang kita gunakan untuk menyediakan keadaan rahsia Alice. Kita boleh menerapkan songsang U pada akhir Circuit kita. Jika U memetakan keadaan $|0\rangle$ Alice kepada $\alpha_0 |0\rangle+\alpha_1|1\rangle$, maka songsang U akan memetakan $\alpha_0 |0\rangle+\alpha_1|1\rangle$ Bob kembali kepada $|0\rangle.$ Jadi bahagian terakhir ini tidak semestinya perlu dilakukan jika matlamatnya hanya untuk menggerakkan maklumat kuantum. Ini hanya dilakukan untuk kita menyemak diri kita.

# 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 betul, pengukuran kita pada Qubit Bob seharusnya menghasilkan keadaan $|0\rangle$. Sudah tentu, pengukuran ini adalah kebarangkalian. Jadi jika terdapat walaupun peluang kecil untuk mengukur Qubit Bob dalam keadaan $|1\rangle$, maka satu pengukuran boleh menghasilkan $|1\rangle.$ Kita sebenarnya mahukan banyak pengukuran untuk memastikan kebarangkalian $|0\rangle$ adalah cukup tinggi.

Langkah 2: Optimumkan masalah untuk pelaksanaan kuantum

Langkah ini mengambil operasi yang ingin kita lakukan dan menyatakannya dari segi fungsi komputer kuantum tertentu. Ia juga memetakan masalah kita pada susun atur komputer kuantum.

Kita akan mulakan dengan memuatkan beberapa pakej yang diperlukan untuk berkomunikasi dengan komputer kuantum IBM. Kita juga mesti memilih Backend untuk dijalankan. Kita boleh memilih Backend paling sibuk, atau memilih Backend tertentu yang sifat-sifatnya kita ketahui.

Terdapat kod di bawah untuk menyimpan kelayakan anda pada penggunaan pertama. Pastikan untuk memadamkan maklumat ini dari buku nota setelah menyimpannya ke persekitaran anda, supaya kelayakan anda tidak tersebar secara tidak sengaja apabila anda berkongsi buku nota. Lihat Sediakan akaun IBM Cloud anda dan Mulakan perkhidmatan dalam persekitaran yang tidak dipercayai untuk panduan 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 membolehkan logik secara eksplisit pada pengukuran.

from qiskit.circuit import IfElseOp

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

Kini kita perlu "transpile" Circuit kuantum. Ini melibatkan banyak sub-langkah dan merupakan topik yang menarik. Sekadar memberikan contoh sub-langkah: tidak semua komputer kuantum boleh melaksanakan secara langsung semua Gate logik dalam Qiskit. Kita mesti menulis Gate-Gate dari Circuit kita dari segi Gate yang boleh dilaksanakan oleh komputer kuantum. Kita boleh menjalankan proses itu, dan yang lain, menggunakan pengurus laluan praset. Menetapkan optimization = 3 (tahap pengoptimuman tertinggi) memastikan pemetaan dari Circuit kuantum abstrak kita kepada arahan yang diberikan kepada komputer kuantum adalah seefisien mungkin dalam pra-pemprosesan 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 primitif yang direka untuk mengambil sampel keadaan yang mungkin terhasil dari Circuit kuantum, dan mengumpulkan statistik tentang keadaan-keadaan yang mungkin diukur dan dengan kebarangkalian berapa. Kita import 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 pengiraan pada komputer kuantum boleh disimulasikan secara munasabah pada komputer klasik. Teleportasi mudah ini tentulah boleh, tetapi tidak menghairankan sama sekali bahawa kita boleh menyimpan maklumat klasik di satu tempat atau tempat lain. Kami amat mengesyorkan melaksanakan pengiraan ini menggunakan komputer kuantum IBM yang sebenar. Tetapi sekiranya anda telah menghabiskan penggunaan bulanan percuma anda, atau jika sesuatu mesti diselesaikan dalam kelas dan tidak boleh menunggu dalam giliran, modul ini boleh diselesaikan menggunakan simulator. Untuk melakukan ini, jalankan sahaja sel di bawah dan nyahkomen baris yang berkaitan dalam langkah-langkah "Laksanakan".

# 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: Laksanakan

Guna Sampler untuk menjalankan kerja anda, dengan Circuit sebagai hujah.

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

Langkah 4: Pemprosesan pasca dan analisis

Mari kita plot keputusan dan tafsirkannya.

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

plot_histogram(counts)

Uji kefahaman anda

Baca soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Antara keadaan-keadaan di atas, yang mana menunjukkan teleportasi berjaya, dan bagaimana anda boleh tahu?

Jawapan:

Keadaan $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ semuanya konsisten dengan teleportasi yang berjaya. Ini kerana kita menambah Gate untuk membatalkan persediaan awal keadaan rahsia. Jika keadaan rahsia berjaya diteleport ke Qubit Bob, Gate tambahan itu seharusnya mengembalikan Qubit Bob ke keadaan $|0\rangle$. Jadi mana-mana keadaan di atas dengan Qubit Bob (Qubit 0, juga diukur ke komponen ke-0 daftar klasik, dan oleh itu yang tertinggi/paling kanan) dalam keadaan $|0\rangle$ menunjukkan kejayaan.

Plot ini menunjukkan semua hasil pengukuran untuk tiga Qubit, sepanjang 5,000 percubaan atau "shot". Kita telah menyatakan sebelum ini bahawa Alice akan mengukur semua keadaan yang mungkin untuk Qubit A dan Q dengan kemungkinan yang sama. Kita menetapkan Qubit 0-2 dalam Circuit kepada Q, A, dan B, mengikut urutan itu. Dalam notasi little-endian, Qubit Bob adalah yang paling kiri/terendah. Jadi empat bar di sebelah kiri sepadan dengan Qubit Bob dalam keadaan $|0\rangle$, dan dua Qubit lain berada dalam semua kombinasi yang mungkin dengan kebarangkalian yang lebih kurang sama. Perhatikan bahawa hampir semua (biasanya ~95%) pengukuran menghasilkan Qubit Bob dalam keadaan $|0\rangle$, bermakna persediaan kita berjaya! Terdapat segelintir shot (~5%) yang menghasilkan Qubit Bob dalam keadaan $|1\rangle$. Itu secara logiknya tidak seharusnya mungkin. Walau bagaimanapun, semua komputer kuantum moden mengalami hingar dan ralat ke tahap yang jauh lebih besar daripada komputer klasik. Dan pembetulan ralat kuantum masih merupakan bidang yang sedang berkembang.

Eksperimen 2: Teleportasi merentasi pemproses

Boleh dikatakan, bahagian paling menarik tentang teleportasi kuantum ialah keadaan kuantum boleh diteleportasi merentasi jarak jauh dengan serta-merta (walaupun komunikasi klasik untuk gate tambahan bukanlah serta-merta). Seperti yang telah dinyatakan, kita tidak boleh menanggalkan Qubit dari pemproses dan memindahkannya. Tetapi kita boleh memindahkan maklumat dari satu Qubit ke Qubit lain, sehingga Qubit yang terlibat dalam teleportasi berada di hujung bertentangan pemproses. Mari kita ulangi langkah-langkah yang telah kita ambil di atas, tetapi kali ini kita akan membina Circuit yang lebih besar dengan Qubit yang mencukupi untuk merentasi pemproses.

Langkah 1: Petakan masalah anda ke Circuit kuantum

Kali ini, Qubit yang sepadan dengan Alice dan Bob akan berubah. Oleh itu, kita tidak akan menamakan satu Qubit sebagai "A" dan satu lagi "B". Sebaliknya, kita akan menomborkan Qubit dan menggunakan pembolehubah untuk mewakili kedudukan semasa maklumat pada Qubit milik Alice dan Bob. Semua langkah lain kecuali swap gate adalah seperti yang diterangkan sebelum ini.

# 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")

Anda boleh lihat dalam gambar rajah Circuit bahawa langkah-langkah logik adalah sama. Satu-satunya perbezaan ialah kita menggunakan swap gate untuk memindahkan keadaan Qubit Alice dari Qubit 6 ($A_5$) ke Qubit 1 ($A_0$), bersebelahan dengan Q. Dan kita menggunakan swap gate untuk memindahkan keadaan awal Bob dari Qubit 7 ($B_0$) ke Qubit 12 ($B_5$). Perlu diambil perhatian bahawa keadaan pada Qubit 12 tidak ada kaitannya dengan keadaan rahsia Q sehingga pengukuran dibuat pada Qubit 0 dan 1 yang jauh, dan keadaan pada Qubit 12 tidak sama dengan keadaan rahsia sehingga gate $X$ dan $Z$ bersyarat diterapkan.

Langkah 2: Optimumkan Circuit anda

Biasanya, apabila kita menggunakan pass manager untuk transpile dan mengoptimumkan Circuit kita, adalah masuk akal untuk menetapkan optimization_level = 3, kerana kita mahu Circuit kita seefisien mungkin. Dalam kes ini, tiada sebab pengiraan bagi kita untuk memindahkan keadaan dari Qubit 6 dan 7 ke Qubit 1 dan 12. Itu hanyalah sesuatu yang kita lakukan untuk menunjukkan teleportasi merentasi jarak. Jika kita meminta pass manager untuk mengoptimumkan Circuit kita, ia akan menyedari tiada sebab logik untuk swap gate ini, dan ia akan membuangnya serta menjalankan operasi gate pada Qubit yang bersebelahan. Jadi untuk kes khas ini, kita gunakan 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 boleh menggambarkan di mana pada pemproses kuantum Qubit-Qubit ini berada menggunakan fungsi plot_circuit_layout.

Langkah 3: Laksanakan

Seperti sebelum ini, kami mengesyorkan menjalankan pada komputer kuantum IBM yang sebenar. Jika penggunaan percuma bulanan anda telah mencapai had, jangan segan untuk menyahkomen sel simulator bagi menjalankan pada 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: Pemprosesan pasca klasik

Sekali lagi kita melihat bahawa kebarangkalian untuk hasil yang mungkin bagi Qubit Alice adalah agak seragam. Terdapat kecenderungan yang kuat untuk mendapati Qubit Bob dalam $|0\rangle$ selepas menyongsangkan kod rahsia, bermakna terdapat kebarangkalian yang tinggi bahawa kita berjaya menteleportasi keadaan rahsia merentasi pemproses dari Q ke Bob (Qubit 0 hingga 12). Walau bagaimanapun, kita perhatikan bahawa kini terdapat peluang yang lebih tinggi untuk tidak mengukur $|0\rangle$ bagi Bob. Ini adalah pengajaran penting dalam pengkomputeran kuantum: lebih banyak gate yang anda ada, terutamanya gate berbilang Qubit seperti swap gate, lebih banyak hingar dan ralat yang akan anda hadapi.

Soalan

Pengajar boleh meminta versi buku nota ini dengan kunci jawapan dan panduan penempatan dalam kurikulum biasa dengan mengisi tinjauan ringkas ini tentang cara buku nota digunakan.

Konsep penting

• Qubit boleh dibelit, bermakna pengukuran satu Qubit mempengaruhi atau bahkan menentukan keadaan Qubit lain.
• Belitan berbeza daripada korelasi klasik; contohnya, Qubit A dan B boleh berada dalam superposisi keadaan seperti $\alpha_0|00\rangle+\alpha_1|11\rangle.$ Keadaan A atau B mungkin tidak ditentukan oleh alam, namun A dan B masih dijamin berada dalam keadaan yang sama.
• Melalui gabungan belitan dan pengukuran, kita boleh memindahkan keadaan (yang boleh menyimpan maklumat) dari satu Qubit ke Qubit lain. Pemindahan ini bahkan boleh dilakukan merentasi jarak jauh, dan ini dipanggil teleportasi kuantum.
• Teleportasi kuantum bergantung pada pengukuran kuantum, yang bersifat kebarangkalian. Oleh itu, komunikasi klasik mungkin diperlukan untuk melaraskan keadaan yang diteleportasi. Ini menghalang teleportasi kuantum daripada memindahkan maklumat lebih laju daripada cahaya. Teleportasi kuantum tidak melanggar relativiti atau sebab-musabab.
• Komputer kuantum moden lebih terdedah kepada hingar dan ralat berbanding komputer klasik. Jangkakan ralat beberapa peratus.
• Lebih banyak gate yang anda tambah secara berurutan (terutamanya gate 2-Qubit), lebih banyak ralat dan hingar yang boleh dijangkakan.

Soalan Betul/Salah

1. B/S Teleportasi kuantum boleh digunakan untuk menghantar maklumat lebih laju daripada cahaya.
2. B/S Bukti moden mencadangkan bahawa keruntuhan keadaan kuantum merebak lebih laju daripada cahaya.
3. B/S Dalam Qiskit, Qubit diatur dalam keadaan dengan Qubit bernombor terendah di sebelah kanan, seperti dalam $|q_3,q_2,q_1, q_0\rangle$

Soalan pelbagai pilihan

1. Qubit A dan B dibelit, kemudian dipisahkan pada jarak jauh $d$. Qubit A diukur. Pernyataan manakah yang betul tentang kelajuan keadaan Qubit B terpengaruh?

• a. Qubit B terpengaruh dengan serta-merta, dalam toleransi eksperimen, dalam eksperimen yang dijalankan setakat ini.
• b. Qubit B terpengaruh selepas masa $d/c$, bermakna keadaan kuantum "runtuh" pada kira-kira kelajuan cahaya, dalam toleransi eksperimen.
• c. Qubit B terpengaruh hanya selepas komunikasi klasik berlaku, bermakna ia berlaku dalam masa lebih panjang daripada $d/c$.
• d. Tiada satu pun di atas

2. Ingat semula bahawa kebarangkalian pengukuran berkaitan dengan amplitud dalam keadaan kuantum. Contohnya, jika Qubit pada mulanya berada dalam keadaan $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ kebarangkalian mengukur keadaan $|0\rangle$ ialah $|\alpha_0|^2.$ Tidak semua set pengukuran akan tepat sepadan dengan kebarangkalian ini, disebabkan pensampelan terhingga (sama seperti melempar syiling mungkin menghasilkan kepala dua kali berturut-turut). Histogram pengukuran di bawah boleh sepadan dengan keadaan kuantum yang mana? Pilih jawapan 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. Antara keadaan berikut, yang manakah menunjukkan Qubit A dan B dibelit? Pilih semua yang berkenaan.

• 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 menyediakan keadaan belit: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Tetapi terdapat banyak keadaan belit lain yang boleh digunakan untuk protokol yang serupa. Antara keadaan di bawah, yang manakah boleh menghasilkan histogram pengukuran 2-Qubit seperti berikut? Pilih jawapan 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$

Soalan perbincangan

1. Terangkan protokol teleportasi kuantum, dari awal hingga akhir, kepada rakan/kumpulan anda. Lihat sama ada mereka ada sesuatu untuk ditambah, atau jika mereka ada soalan.

2. Adakah terdapat sesuatu yang unik tentang keadaan belit 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, apakah yang unik tentangnya? Jika tidak, apakah keadaan belit lain yang boleh kita gunakan?