Teleportasi kuantum dan pengekodan superpadu

nota

Kifumi Numata (26 Apr 2024)

Muat turun pdf kuliah asal. Perlu diingat bahawa beberapa petikan kod mungkin sudah lapuk kerana ia adalah imej statik.

Anggaran masa QPU untuk menjalankan eksperimen ini ialah 10 saat.

1. Pengenalan

Untuk menyelesaikan sebarang masalah kuantum berskala utiliti, kita perlu memindahkan maklumat di dalam komputer kuantum dari satu qubit ke qubit yang lain. Terdapat protokol yang sudah diketahui umum untuk melakukan ini, tetapi beberapa yang paling asas digubal dalam konteks penghantaran maklumat antara pihak yang jauh. Sepanjang pelajaran ini, kita kadang-kadang akan menggunakan bahasa yang sesuai dengan konteks ini, seperti "rakan jauh yang menghantar maklumat". Tapi ingat bahawa protokol-protokol ini mempunyai kepentingan yang lebih luas dalam pengkomputeran kuantum. Dalam pelajaran ini kita mempertimbangkan protokol komunikasi kuantum berikut:

• Teleportasi kuantum Menggunakan keadaan yang terbelit dikongsi (kadang-kadang dipanggil e-bit) untuk menghantar keadaan kuantum yang tidak diketahui kepada rakan yang jauh, memerlukan komunikasi klasik tambahan.
• Pengekodan superpadu kuantum Cara menghantar dua bit maklumat dengan menghantar satu qubit tunggal kepada rakan yang jauh (sekali lagi menggunakan qubit yang terbelit dikongsi terlebih dahulu).

Untuk latar belakang lanjut berkaitan topik-topik ini, kami mengesyorkan pelajaran 4 dalam Asas Maklumat Kuantum mengenai Belitan dalam tindakan.

Dalam keterangan di atas, "keadaan kuantum yang tidak diketahui" merujuk kepada keadaan dalam bentuk yang diterangkan dalam pelajaran sebelumnya:

$$|\psi\rangle =\alpha|0\rangle+\beta|1\rangle$$

di mana $\alpha$ dan $\beta$ ialah nombor kompleks sedemikian sehingga $|\alpha|^2+|\beta|^2 = 1$. Ini membolehkan kita menulis keadaan kuantum sebagai

$$|\psi\rangle =\cos\frac{\theta}{2}|0\rangle+e^{i\varphi}\sin\frac{\theta}{2}|1\rangle= \left( \begin{matrix} \cos\frac{\theta}{2}\\ e^{i\varphi}\sin\frac{\theta}{2} \end{matrix} \right)$$

Oleh kerana kita ingin dapat memindahkan maklumat dalam mana-mana keadaan kuantum rawak, menjana keadaan sedemikian adalah tempat kita akan memulakan pelajaran ini.

2. Matriks ketumpatan

Kita juga boleh menulis keadaan kuantum $|\psi \rangle$ sebagai matriks ketumpatannya. Bentuk ini berguna untuk melambangkan campuran kebarangkalian bagi keadaan kuantum tulen. Dalam kes qubit tunggal, kita boleh menulis

$$|\psi \rangle \langle \psi| \equiv \rho = \left( \begin{pmatrix} \cos\frac{\theta}{2}\\ e^{i\varphi}\sin\frac{\theta}{2} \end{pmatrix} \right) \left( \begin{pmatrix} \cos\frac{\theta}{2} & e^{-i\varphi}\sin\frac{\theta}{2} \end{pmatrix} \right) =\frac{1}{2}\left(\begin{pmatrix} 1+\cos\theta & e^{-i\varphi}\sin\theta\\ e^{-i\varphi}\sin\theta & 1-\cos\theta \end{pmatrix}\right)$$

Perlu diperhatikan bahawa matriks ketumpatan $\rho$ adalah penjumlahan linear bagi matriks Pauli, seperti di bawah,

$$\rho = \frac{1}{2}\bigl( \textbf{I} + (\sin{\theta}\cos{\varphi})\textbf{X}+ (\sin{\theta}\sin{\varphi})\textbf{Y} + (\cos{\theta})\textbf{Z} \bigr)$$

Atau, secara umum,

$$\rho = \frac{1}{2}(\textbf{I} + r_{x}\textbf{X}+ r_{y}\textbf{Y} + r_{z}\textbf{Z})$$

di mana $r_{x}^2+r_{y}^2+r_{z}^2=1$.

Dan, vektor Bloch ialah $\textbf{r} = (r_{x}, r_{y}, r_{z})$.

Sekarang, mari kita buat keadaan kuantum sewenang-wenangnya menggunakan nombor rawak.

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

import numpy as np

# create a random 1-qubit state from a random (theta, varphi) to define r vector
np.random.seed(1)  # fixing seed for repeatibility

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

def get_r_vec(theta, varphi):
    rx = np.sin(theta) * np.cos(varphi)
    ry = np.sin(theta) * np.sin(varphi)
    rz = np.cos(theta)
    return (rx, ry, rz)

# get r vector
rx, ry, rz = get_r_vec(theta, varphi)

print("theta=" + str(theta), ",varphi=" + str(varphi))
print("(rx, ry, rz) = (" + str(rx) + ", " + str(ry) + ", " + str(rz) + ")")

theta=1.3101132663588946 ,varphi=4.525932273597346
(rx, ry, rz) = (-0.1791150283307452, -0.9494670044331133, 0.2577405946274022)

Kita boleh tunjukkan vektor Bloch ini pada sfera Bloch.

from qiskit.visualization import plot_bloch_vector

r = [rx, ry, rz]
plot_bloch_vector(r)

3. Tomografi keadaan kuantum

Jika Anda hanya mengukur keadaan kuantum dalam asas pengiraan ($|0 \rangle$ dan $|1 \rangle$), maklumat fasa (maklumat nombor kompleks) akan hilang. Tetapi jika kita mempunyai banyak salinan $|\psi \rangle$ dengan mengulangi proses persediaan (kita tidak boleh mengklon keadaan, tetapi kita boleh mengulangi proses persediaan), kita boleh menganggar nilai $r_{x}, r_{y}, r_{z}$ dengan melakukan tomografi keadaan kuantum untuk matriks ketumpatan $\rho$. Dengan bentuk:

$$\rho = \frac{1}{2}(\textbf{I} + r_{x}\textbf{X}+ r_{y}\textbf{Y} + r_{z}\textbf{Z})$$

ia berlaku bahawa

$$Tr(\textbf{X} \rho) = r_{x}, \quad Tr(\textbf{Y} \rho) = r_{y}, \quad Tr(\textbf{Z} \rho) = r_{z}$$

Dalam kes $r_{z}$,

$$Tr(\textbf{Z} \rho) = \langle 0|\textbf{Z} \rho|0 \rangle + \langle 1|\textbf{Z} \rho|1 \rangle$$ $$= \langle 0|(|0 \rangle\langle 0|-|1 \rangle\langle 1|) \rho|0 \rangle +\langle 1|(|0 \rangle\langle 0|-|1 \rangle\langle 1|) \rho|1 \rangle$$ $$=\langle 0|\rho|0 \rangle- \langle 1| \rho|1 \rangle$$ $$=\langle 0|\psi\rangle\langle \psi|0 \rangle - \langle 1| \psi\rangle\langle \psi|1 \rangle$$ $$=|\alpha|^2-|\beta|^2$$

Transformasi terakhir persamaan ini adalah untuk $|\psi \rangle =\alpha|0\rangle+\beta|1\rangle$. Oleh itu, kita boleh mendapatkan $r_{z}$ dengan kebarangkalian $|0 \rangle$ - Kebarangkalian $|1 \rangle$.

Menganggar nilai $r_z$

Untuk menganggar $r_z$, kita mencipta keadaan kuantum dan mengukurnya. Kemudian kita ulangi persediaan dan pengukuran berkali-kali. Akhirnya kita gunakan statistik pengukuran untuk menganggar kebarangkalian di atas dan dengan itu menganggar $r_z$.

Untuk mencipta keadaan kuantum rawak, kita akan menggunakan get uniter umum $U$ dengan parameter $\theta, \varphi$. (Rujuk U-gate untuk maklumat lanjut.)

from qiskit import QuantumCircuit

# create a 1-qubit quantum state psi from theta, varphi parameters
qc = QuantumCircuit(1, 1)
qc.u(theta, varphi, 0.0, 0)

# measure in computational basis
qc.measure(0, 0)

qc.draw(output="mpl")

Menggunakan AerSimulator, kita akan mengukurnya dalam asas pengiraan untuk menganggar $r_z$.

# see if the expected value of measuring in the computational basis
# approaches the limit of rz
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Sampler
from qiskit.visualization import plot_histogram

# Define backend
backend = AerSimulator()
nshots = 1000  # or 10000
# nshots = 10000

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=nshots)
result = job.result()

# Extract counts data
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram

plot_histogram(counts)

{'1': 375, '0': 625}

rz_approx = (counts["0"] - counts["1"]) / nshots

print("rz = ", rz, " and approx of rz = ", rz_approx)

rz =  0.2577405946274022  and approx of rz =  0.25

Menggunakan kaedah tomografi keadaan kuantum, kita menganggar nilai $r_z$. Dalam kes ini, kerana kita memilih parameter untuk keadaan "rawak", kita mengetahui nilai $r_z$ dan boleh menyemak kerja kita. Tetapi pada dasarnya, kerja berskala utiliti tidak selalu semudah itu untuk disemak. Kita akan membincangkan lebih lanjut tentang menyemak keputusan kuantum kemudian dalam kursus ini. Buat masa ini, perhatikan sahaja bahawa anggaran kita agak tepat.

Latihan 1: Menganggar nilai $r_x$

Ingat bahawa komputer kuantum IBM® mengukur sepanjang paksi $z$ (kadang-kadang dinyatakan "dalam asas $z$" atau "dalam asas pengiraan"). Walau bagaimanapun, dengan menggunakan putaran sebelum pengukuran, kita boleh mengukur unjuran keadaan kuantum pada paksi-x juga. Lebih tepat lagi, jika kita memutar sistem kita supaya perkara yang menunjuk sepanjang $x$ kini menunjuk sepanjang $z$, maka kita boleh menggunakan perkakasan pengukuran yang sama sepanjang $z$, tetapi belajar tentang keadaan yang tadi menunjuk sepanjang $x$. Beginilah cara kebanyakan komputer kuantum (dan semua komputer kuantum IBM) melakukan pengukuran sepanjang pelbagai paksi.

Dengan pemahaman ini, cuba tulis kod untuk menganggar nilai $r_x,$ menggunakan tomografi keadaan kuantum.

Penyelesaian:

# create a 1-qubit quantum state psi from theta, varphi parameters
qc = QuantumCircuit(1, 1)
qc.u(theta, varphi, 0.0, 0)

qc.h(0)
qc.measure(0, 0)

qc.draw(output="mpl")

# Define backend
backend = AerSimulator()
nshots = 10000

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=nshots)
result = job.result()

# Extract counts data
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'1': 5925, '0': 4075}

rx_approx = (counts["0"] - counts["1"]) / nshots

print("rx = ", rx, " and approx of rx = ", rx_approx)

rx =  -0.1791150283307452  and approx of rx =  -0.185

Latihan 2: Menganggar nilai $r_y$

Menggunakan hujah logik yang sama seperti sebelumnya, kita boleh memutar sistem sebelum pengukuran untuk mengetahui tentang $r_y$.

Cuba tulis kod sendiri untuk menganggar nilai $r_y$ menggunakan tomografi keadaan kuantum. Anda boleh mulakan dengan contoh sebelumnya, tetapi buat putaran yang berbeza. (Untuk maklumat lanjut tentang pelbagai get yang digunakan, termasuk sdg, rujuk kepada rujukan API.)

Penyelesaian:

# create a 1-qubit quantum state psi from theta, varphi parameters
qc = QuantumCircuit(1, 1)
qc.u(theta, varphi, 0.0, 0)

qc.sdg(0)
qc.h(0)
qc.measure(0, 0)

qc.draw(output="mpl")

# Define backend
backend = AerSimulator()
nshots = 10000

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=nshots)
result = job.result()

# Extract counts data
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'1': 9759, '0': 241}

ry_approx = (counts["0"] - counts["1"]) / nshots

print("ry = ", ry, " and approx of ry = ", ry_approx)

ry =  -0.9494670044331133  and approx of ry =  -0.9518

Kita kini telah menganggar semua komponen $\vec{r}$ dan boleh menulis vektor penuh.

print("Estimated vector is (", rx_approx, ",", ry_approx, ",", rz_approx, ").")
print("Original random vector was (" + str(rx) + ", " + str(ry) + ", " + str(rz) + ").")

Estimated vector is ( -0.185 , -0.9518 , 0.25 ).
Original random vector was (-0.1791150283307452, -0.9494670044331133, 0.2577405946274022).

Anda berjaya mendapatkan anggaran vektor rawak asal dengan cukup tepat menggunakan kaedah tomografi keadaan kuantum ini.

4. Teleportasi kuantum

Mari kita bayangkan situasi di mana seorang watak bernama Alice ingin menghantar keadaan kuantum yang tidak diketahui $|\psi \rangle$ kepada rakannya Bob, yang berada jauh darinya. Anggap mereka hanya boleh berkomunikasi menggunakan komunikasi klasik (seperti e-mel atau telefon). Alice tidak boleh menyalin keadaan kuantum itu (disebabkan teorem tiada pengklonan). Jika dia mengulangi proses persediaan yang sama berkali-kali, dia boleh membina statistik seperti yang kita lakukan tadi. Tetapi bagaimana jika hanya ada satu keadaan yang tidak diketahui? Keadaan ini mungkin muncul daripada proses fizikal yang ingin Anda pelajari. Atau ia mungkin sebahagian daripada pengiraan kuantum yang lebih besar. Dalam kes itu, bagaimana Alice boleh menghantar keadaan tersebut kepada Bob? Dia boleh, jika dia dan Bob berkongsi sumber kuantum yang berharga: keadaan terbelit yang dikongsi bersama, seperti keadaan Bell yang diperkenalkan dalam pelajaran sebelumnya: $\frac {|00\rangle + |11\rangle}{\sqrt 2}.$ Kadang-kadang Anda juga akan melihat ini dirujuk sebagai "pasangan EPR" atau "e-bit" (unit asas keterbelitan). Jika Alice berkongsi keadaan terbelit sedemikian dengan Bob, dia boleh menteleportasi keadaan kuantum yang tidak diketahui itu kepada Bob dengan melakukan satu siri operasi kuantum dan menghantar dua bit maklumat klasik kepadanya.

4.1 Protokol teleportasi kuantum

Andaian: Alice mempunyai keadaan kuantum yang tidak diketahui $|\psi \rangle$ untuk dihantar kepada Bob. Alice dan Bob berkongsi keadaan terbelit 2-qubit, atau e-bit, dengan setiap seorang memiliki satu qubit secara fizikal di lokasi masing-masing.

Berikut ialah prosedurnya tanpa penjelasan. Ini akan dilaksanakan secara terperinci di bawah.

1. Alice membelitkan $|\psi \rangle$ dengan bahagian e-bitnya menggunakan gate CNOT.
2. Alice menggunakan gate Hadamard pada $|\psi \rangle$, dan mengukur kedua-dua Qubitnya dalam asas pengiraan.
3. Alice menghantar keputusan pengukurannya kepada Bob (sama ada "00", "01", "10", atau "11")
4. Bob melakukan operator pembetulan berdasarkan dua-bit maklumat daripada Alice pada bahagian pasangan e-bitnya.
   • Jika "00", Bob tidak buat apa-apa
   • Jika "01", Bob menggunakan gate X
   • Jika "10", Bob menggunakan gate Z
   • Jika "11", Bob menggunakan gate iY = ZX
5. Bahagian e-bit Bob menjadi $|\psi \rangle$.

Ini juga diperincikan dengan lebih lanjut dalam Asas Maklumat Kuantum. Tetapi situasinya akan menjadi lebih jelas apabila kita melaksanakannya dalam Qiskit.

4.2 litar kuantum yang mensimulasikan teleportasi kuantum

Seperti biasa, kita akan menggunakan rangka kerja corak Qiskit. Subseksyen ini akan memfokuskan pada pemetaan sahaja.

Langkah 1: Petakan masalah kepada litar dan pengendali kuantum

Untuk menggambarkan senario di atas, kita perlukan litar dengan tiga qubit: dua untuk pasangan terbelit yang dikongsi oleh Alice dan Bob, dan satu untuk keadaan kuantum yang tidak diketahui $|\psi\rangle$.

from qiskit import QuantumCircuit
import numpy as np

# create 3-qubits circuit
qc = QuantumCircuit(3, 3)

qc.draw(output="mpl")

Pada mulanya, Alice mempunyai keadaan kuantum yang tidak diketahui $|\psi \rangle.$ Kita akan menciptanya menggunakan gate $U$.

# Create the unknown quantum state using the u-gate. Alice has this.
qc.u(theta, varphi, 0.0, 0)
qc.barrier()  # for visual separation

qc.draw(output="mpl")

Kita boleh memvisualisasikan keadaan yang telah kita cipta, tetapi hanya kerana kita tahu parameter yang digunakan dalam gate $U$. Jika keadaan ini muncul daripada proses kuantum yang rumit, keadaan itu tidak boleh diketahui tanpa menjalankan proses tersebut berkali-kali dan mengumpul statistik seperti dalam tomografi.

# show the quantum state on bloch sphere
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector

out_vector = Statevector(qc)

plot_bloch_multivector(out_vector)

Sebelum protokol ini bermula, kita andaikan Alice dan Bob sudah mempunyai pasangan terbelit yang dikongsi. Jika Alice dan Bob benar-benar berada di lokasi yang berbeza, mereka mungkin telah menyediakan keadaan yang dikongsi sebelum keadaan yang tidak diketahui $|\psi\rangle$ pernah dicipta. Kerana perkara-perkara itu berlaku pada qubit yang berbeza, susunannya di sini tidak akan memberi kesan, dan susunan ini mudah untuk visualisasi.

# Alice and Bob are together in the same place and set up an entangled pair.
qc.h(1)
qc.cx(1, 2)
qc.barrier()  # for visual separation.
# We can consider that Alice and Bob might move their qubits to different physical locations, now.

qc.draw(output="mpl")

Seterusnya, Alice membelitkan $|\psi \rangle$ dengan bahagian e-bit yang dikongsi menggunakan gate $CX$ dan gate $H$, dan mengukurnya dalam asas pengiraan.

# Alice entangles the unknown state with her part of the e-bit, using the CNOT gate and H gate.
qc.cx(0, 1)
qc.h(0)
qc.barrier()

# Alice measures the two qubits.
qc.measure(0, 0)
qc.measure(1, 1)

qc.draw(output="mpl")

Alice menghantar keputusan pengukurannya kepada Bob (sama ada "00", "01", "10", atau "11"), dan Bob melakukan operator pembetulan berdasarkan dua bit maklumat daripada Alice pada bahagian e-bit yang dikongsi. Kemudian, bahagian Bob menjadi $|\psi \rangle$.

# Alice sent the results to Bob. Bob applies correction
with qc.if_test((0, 1)):
    qc.z(2)
with qc.if_test((1, 1)):
    qc.x(2)
qc.barrier()

qc.draw(output="mpl")

Anda telah menyiapkan litar teleportasi kuantum! Jom tengok keadaan output litar ini menggunakan simulator statevector.

from qiskit_aer import StatevectorSimulator

backend = StatevectorSimulator()
out_vector = backend.run(qc, shots=1).result().get_statevector()  # set shots = 1

plot_bloch_multivector(out_vector)

Anda boleh lihat bahawa keadaan kuantum yang dicipta oleh gate $U$ pada qubit 0 (qubit yang pada asalnya menyimpan keadaan rahsia) telah dipindahkan kepada qubit 2 (qubit Bob).

Anda boleh jalankan sel di atas beberapa kali untuk memastikannya. Anda mungkin perasan bahawa qubit 0 dan 1 menukar keadaan, tetapi qubit 2 sentiasa dalam keadaan $|\psi\rangle$.

4.3 Laksanakannya dan sahkan hasilnya dengan menggunakan songsangan U

Di atas, kita memeriksa secara visual bahawa keadaan yang diteleportasi kelihatan betul. Cara lain untuk memeriksa sama ada keadaan kuantum telah diteleportasi dengan betul ialah dengan menggunakan songsangan gate $U$ pada qubit Bob supaya kita boleh mengukur '0'. Iaitu, kerana $U^{-1}U$ adalah identiti, jika qubit Bob berada dalam keadaan yang dicipta daripada $U|0\rangle,$ maka menggunakan songsangannya sepatutnya menghasilkan $U^{-1}U|0\rangle=|0\rangle.$

# Apply the inverse of u-gate to measure |0>
qc.u(theta, varphi, 0.0, 2).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(2, 2)  # add measurement gate

qc.draw(output="mpl")

Kita akan melaksanakan litar tersebut terlebih dahulu menggunakan AerSimulator, sebelum beralih kepada komputer kuantum sebenar.

from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Sampler
from qiskit.visualization import plot_histogram

# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=nshots)
result = job.result()

# Extract counts data
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'011': 2510, '010': 2417, '000': 2635, '001': 2438}

Ingat bahawa dalam notasi endian kecil, qubit 2 adalah qubit paling kiri (atau paling bawah, dalam label lajur). Perhatikan bahawa qubit paling kiri dan paling bawah dalam label lajur adalah 0 untuk semua kemungkinan hasil. Ini menunjukkan kita mempunyai kebarangkalian 100% untuk mengukur $q_2$ dalam keadaan $|0\rangle$. Ini adalah hasil yang dijangkakan, dan menunjukkan protokol teleportasi telah berjalan dengan betul.

4.4 Teleportasi pada komputer kuantum sebenar

Seterusnya, kita akan melakukan teleportasi pada komputer kuantum sebenar. Menggunakan fungsi circuit dinamik, kita boleh beroperasi di pertengahan litar menggunakan hasil pengukuran, melaksanakan operasi bersyarat secara masa nyata dalam litar teleportasi. Untuk menyelesaikan masalah dengan komputer kuantum sebenar, kita akan mengikuti empat langkah corak Qiskit.

1. Petakan masalah kepada litar dan pengendali kuantum
2. Optimumkan untuk perkakasan sasaran
3. Laksanakan pada perkakasan sasaran
4. Proses pasca hasilnya

Latihan 3: Bina litar teleportasi

Cuba bina keseluruhan litar teleportasi dari awal untuk menguji kefahaman Anda. Tatal ke atas jika Anda perlukan peringatan.

Penyelesaian:

# Step 1: Map problem to quantum circuits and operators
# Create the circuit with 3-qubits and 1-bit
qc = QuantumCircuit(3, 3)

# Alice creates an unknown quantum state using the u-gate.
qc.u(theta, varphi, 0.0, 0)
qc.barrier()  # for visual separation

# Eve creates EPR pair and sends q1 to Alice and q2 to Bob
##your code goes here##
qc.h(1)
qc.cx(1, 2)
qc.barrier()

# Alice entangles the unknown state with her EPR part, using the CNOT gate and H gate.
##your code goes here##
qc.cx(0, 1)
qc.h(0)
qc.barrier()

# Alice measures the two qubits.
##your code goes here##
qc.measure(0, 0)
qc.measure(1, 1)

# Alice sent the results to Bob. Now, Bob applies correction
##your code goes here##
with qc.if_test((0, 1)):
    qc.z(2)
with qc.if_test((1, 1)):
    qc.x(2)
qc.barrier()

# Apply the inverse of u-gate to measure |0>
qc.u(theta, varphi, 0.0, 2).inverse()
qc.measure(2, 2)

qc.draw(output="mpl")

Sebagai peringatan, menggunakan songsangan gate $U$ hanyalah untuk kita dapat mengesahkan tingkah laku yang dijangkakan. Ia bukan sebahagian daripada menghantar keadaan kepada Bob, dan kita tidak akan menggunakan gate songsangan $U$ itu jika matlamat hanyalah untuk memindahkan maklumat kuantum.

Langkah 2: Optimumkan untuk perkakasan sasaran

Untuk menjalankan pada perkakasan, import QiskitRuntimeService dan muatkan kelayakan yang telah disimpan. Pilih Backend dengan bilangan tugas paling sedikit dalam baris gilir.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
service.backends()

[<IBMBackend('ibm_brisbane')>,
 <IBMBackend('ibm_torino')>]

# You can also identify the least busy device
backend = service.least_busy(operational=True)
print("The least busy device is ", backend)

The least busy device is  <IBMBackend('ibm_brisbane')>

# You can specify the device
# backend = service.backend('ibm_brisbane')

Jom tengok peta gandingan peranti yang Anda pilih.

from qiskit.visualization import plot_gate_map

plot_gate_map(backend)

Peranti yang berbeza mungkin mempunyai peta gandingan yang berbeza, dan setiap peranti mempunyai beberapa qubit dan penghubung yang lebih berprestasi daripada yang lain. Akhirnya, komputer kuantum yang berbeza mungkin mempunyai gate natif yang berbeza (gate yang boleh dilaksanakan oleh perkakasan). Pentranspilasian litar menulis semula litar kuantum abstrak menggunakan gate yang boleh dilaksanakan oleh komputer kuantum sasaran, dan memilih pemetaan optimum kepada qubit fizikal (antara perkara lain). Transpilasi adalah topik yang kaya dan kompleks. Untuk maklumat lanjut tentang Transpilasi, lihat rujukan API.

# Step 2: Optimize for target hardware
# Transpile the circuit into basis gates executable on the hardware
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

pm = generate_preset_pass_manager(backend=backend, optimization_level=2)
qc_compiled = pm.run(qc)

qc_compiled.draw("mpl", idle_wires=False, fold=-1)

Langkah 3: Laksanakan litar tersebut.

Menggunakan primitif Runtime Sampler, kita akan melaksanakan litar sasaran.

# Step 3: Execute the target circuit
sampler = Sampler(backend)
job = sampler.run([qc_compiled])
job_id = job.job_id()
print("job id:", job_id)

job id: d13nkhpn2txg008jt0d0

# Check the job status
job.status()

'DONE'

Anda juga boleh semak status tugas dari papan pemuka IBM Quantum® Anda.

# If the Notebook session got disconnected you can also check your job status
# by running the following code

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
job_real = service.job(job.job_id())  # Input your job-id between the quotations
job_real.status()

'DONE'

Jika Anda nampak 'DONE' dipaparkan, Anda boleh mendapatkan hasil dengan melaksanakan sel di bawah.

# Execute after 'DONE' is displayed
result_real = job_real.result()
print(result_real[0].data.c.get_counts())

{'001': 992, '110': 430, '011': 579, '010': 605, '111': 402, '000': 925, '100': 57, '101': 106}

Langkah 4: Proses pasca hasilnya

# Step 4: Post-process the results
from qiskit.visualization import plot_histogram

plot_histogram(result_real[0].data.c.get_counts())

Anda boleh mentafsirkan keputusan di atas secara terus. Atau, menggunakan marginal_count, Anda boleh menyingkap keputusan Bob pada qubit 2.

# trace out Bob's results on qubit 2
from qiskit.result import marginal_counts

bobs_qubit = 2
real_counts = result_real[0].data.c.get_counts()
bobs_counts = marginal_counts(real_counts, [bobs_qubit])
plot_histogram(bobs_counts)

Seperti yang kita lihat di sini, terdapat beberapa keputusan di mana kita mengukur $|1 \rangle$. Ini disebabkan oleh hingar dan ralat. Khususnya, litar dinamik cenderung mempunyai kadar ralat yang lebih tinggi kerana pengukuran yang memakan masa di pertengahan litar.

4.5 Pengambilan utama mengenai teleportasi kuantum

Kita boleh mengangkut keadaan kuantum kepada rakan yang jauh dengan berkongsi sepasang qubit yang terbelit (e-bit).

1. Bolehkah teleportasi kuantum menghantar keadaan kuantum lebih laju daripada cahaya? Tidak, kerana Alice perlu memberitahu Bob keputusan pengukuran dengan cara klasik.

2. Adakah teleportasi kuantum akan melanggar "teorem tiada pengklonan", yang melarang penyalinan keadaan kuantum? Tidak, kerana keadaan kuantum asal yang diberikan kepada Alice pada salah satu Qubitnya telah hilang semasa pengukuran. Ia telah runtuh kepada $|0\rangle$ atau $|1\rangle$.

5. Pengekodan superdense

Persediaan yang hampir sama boleh digunakan untuk tujuan yang berbeza. Katakan Alice ingin menghantar dua bit maklumat klasik kepada Bob, tetapi dia tiada cara komunikasi klasik dengan Bob. Namun, mereka berkongsi pasangan terbelit dan Alice dibenarkan menghantar qubitnya ke lokasi Bob. Perhatikan perbezaan dengan protokol teleportasi kuantum. Dalam teleportasi, komunikasi klasik memang tersedia untuk mereka berdua, dan matlamatnya adalah untuk menghantar keadaan kuantum. Di sini, komunikasi klasik tidak boleh diakses dan mereka menggunakan pemindahan satu qubit untuk berkongsi dua bit maklumat klasik.

5.1 Protokol pengekodan superdense

Andaian: Alice mempunyai dua bit maklumat, katakan, $a_1a_2 \in \{00, 01, 10, 11\}$. Alice dan Bob berkongsi pasangan terbelit (e-bit), tetapi mereka tidak boleh berkomunikasi secara klasik.

1. Alice melakukan salah satu operasi berikut pada bahagiannya dalam e-bit.
   • Jika $a_1a_2 = 00$, dia tidak buat apa-apa
   • Jika $a_1a_2 = 01$, dia menerapkan get Z
   • Jika $a_1a_2 = 10$, dia menerapkan get X
   • Jika $a_1a_2 = 11$, dia menerapkan get Z dan get X.
2. Alice menghantar bahagiannya dalam e-bit ke lokasi Bob.
3. Bob menerapkan get CNOT dengan qubit dari Alice sebagai kawalan dan Qubitnya sebagai sasaran, kemudian menerapkan get H pada qubit dari Alice, dan mengukur dua qubit tersebut. Kemungkinan keadaan permulaan dan hasil operasi Bob adalah:

$$\frac {|00\rangle + |11\rangle}{\sqrt 2} \rightarrow CX_{01}\otimes H_0 \rightarrow |00\rangle$$ $$\frac {|00\rangle - |11\rangle}{\sqrt 2} \rightarrow CX_{01}\otimes H_0 \rightarrow |01\rangle$$ $$\frac {|10\rangle + |01\rangle}{\sqrt 2} \rightarrow CX_{01}\otimes H_0 \rightarrow |10\rangle$$ $$\frac {|10\rangle - |01\rangle}{\sqrt 2} \rightarrow CX_{01}\otimes H_0 \rightarrow -|11\rangle$$

Perhatikan bahawa tanda negatif pada $-|11\rangle$ adalah fasa global, jadi ia tidak boleh diukur.

5.2 litar kuantum yang mensimulasikan pengekodan superdense

Berdasarkan protokol pengekodan superdense, Anda boleh membina litar pengekodan superdense seperti di bawah. Cuba tukar mesej, msg, yang Alice ingin hantar kepada Bob.

from qiskit import QuantumCircuit

Langkah-langkah corak Qiskit dikenal pasti dalam ulasan kod.

# Step 1: Map problem to quantum circuits and operators
# Create 2-qubits circuit
qc = QuantumCircuit(2, 2)

# Eve creates EPR pair and send q0 to Alice and q1 to Bob
qc.h(0)
qc.cx(0, 1)
qc.barrier()

# set message which Alice wants to transform to Bob
msg = "11"  # You can change the message

if msg == "00":
    pass
elif msg == "10":
    qc.x(0)
elif msg == "01":
    qc.z(0)
elif msg == "11":
    qc.z(0)
    qc.x(0)

qc.barrier()
# Bob receives EPR qubit from Alice and performs unitary operations
qc.cx(0, 1)
qc.h(0)
qc.barrier()

# Bob measures q0 and q1
qc.measure(0, 0)
qc.measure(1, 1)

qc.draw(output="mpl")

# We will execute on a simulator first
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Sampler

# Define backend
backend = AerSimulator()
shots = 1000

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job_sim = sampler.run([isa_qc], shots=shots)
result_sim = job_sim.result()

# Extract counts data
counts = result_sim[0].data.c.get_counts()
print(counts)

{'11': 1000}

# Visualize the results
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Anda boleh lihat bahawa Bob berjaya menerima mesej yang Alice ingin hantar kepadanya.

Seterusnya, jom cuba dengan komputer kuantum sebenar.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True)
print("The least busy device is ", backend)

The least busy device is  <IBMBackend('ibm_brisbane')>

# Step 1 was already completed before the simulator job above.
# Step 2: Optimize for target hardware
# Transpile the circuit into basis gates executable on the hardware
pm = generate_preset_pass_manager(backend=backend, optimization_level=2)
qc_compiled = pm.run(qc)

qc_compiled.draw("mpl", idle_wires=False)

# Step 3:Execute the target circuit
sampler = Sampler(backend)
job = sampler.run([qc_compiled])
job_id = job.job_id()
print("job id:", job_id)

job id: d13nnyq3grvg008j0zag

# Check the job status
job.status()

'DONE'

# If the Notebook session got disconnected you can also check your job status
# by running the following code

# from qiskit_ibm_runtime import QiskitRuntimeService
# service = QiskitRuntimeService()
job = service.job(job_id)  # Input your job-id between the quotations
job.status()

'DONE'

# Execute after job has successfully run
real_result = job.result()
print(real_result[0].data.c.get_counts())

{'11': 3942, '01': 107, '10': 41, '00': 6}

# Step 4: post-process the results
from qiskit.visualization import plot_histogram

plot_histogram(real_result[0].data.c.get_counts())

Hasilnya adalah seperti yang kita jangkakan. Perhatikan bahawa pengekodan superdense pada komputer kuantum sebenar menunjukkan lebih sedikit ralat berbanding teleportasi kuantum pada komputer kuantum sebenar. Salah satu sebabnya mungkin kerana teleportasi kuantum menggunakan litar dinamik, manakala pengekodan superdense tidak. Kita akan belajar lebih lanjut tentang ralat dalam litar kuantum dalam pelajaran kemudian.

6. Ringkasan

Dalam sesi ini, kita telah melaksanakan dua protokol kuantum. Walaupun senario untuk kedua-duanya yang melibatkan rakan-rakan yang berjauhan agak jauh dari pengkomputeran kuantum pada satu QPU, mereka mempunyai aplikasi dalam pengkomputeran kuantum, dan membantu kita memahami pemindahan maklumat kuantum dengan lebih baik.

• Teleportasi kuantum: Walaupun kita tidak boleh menyalin keadaan kuantum, kita boleh menteleport keadaan kuantum yang tidak diketahui dengan berkongsi keterbelitan.
• Pengekodan superdense kuantum: Pasangan terbelit yang dikongsi, dan pemindahan satu qubit, membolehkan komunikasi dua bit maklumat klasik.

# See the version of Qiskit
import qiskit

qiskit.__version__

'2.0.2'