Teleportasi kuantum dan pengkodean superdense

catatan

Kifumi Numata (26 Apr 2024)

Unduh pdf dari kuliah aslinya. Perlu diperhatikan bahwa beberapa cuplikan kode mungkin sudah usang karena ini adalah gambar statis.

Perkiraan waktu QPU untuk menjalankan eksperimen ini adalah 10 detik.

1. Pendahuluan

Untuk menyelesaikan masalah kuantum skala utilitas apa pun, kita perlu memindahkan informasi di dalam komputer kuantum dari satu qubit ke qubit lain. Ada protokol yang sudah dikenal untuk melakukan hal ini, dan beberapa yang paling mendasar dirumuskan dalam konteks pengiriman informasi antar pihak yang berjauhan. Sepanjang pelajaran ini, kita kadang akan menggunakan bahasa yang sesuai dengan konteks ini, seperti "teman yang berjauhan saling mengirim informasi". Tapi ingat bahwa protokol ini memiliki makna yang lebih luas dalam komputasi kuantum. Dalam pelajaran ini kita mempertimbangkan protokol komunikasi kuantum berikut:

• Teleportasi kuantum Menggunakan state belitan bersama (kadang disebut e-bit) untuk mengirimkan state kuantum yang tidak diketahui ke teman yang berjauhan, dengan membutuhkan komunikasi klasik tambahan.
• Pengkodean superdense kuantum Cara mengirimkan dua bit informasi hanya dengan mengirimkan satu qubit ke teman yang berjauhan (lagi-lagi menggunakan qubit belitan bersama yang sudah disiapkan sebelumnya).

Untuk latar belakang lebih lanjut yang relevan dengan topik-topik ini, kami merekomendasikan pelajaran 4 dalam Basics of Quantum Information tentang Entanglement in action.

Dalam deskripsi di atas, "state kuantum yang tidak diketahui" hanya merujuk pada state berbentuk seperti yang dijelaskan di pelajaran sebelumnya:

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

di mana $\alpha$ dan $\beta$ adalah bilangan kompleks sehingga $|\alpha|^2+|\beta|^2 = 1$. Ini memungkinkan kita menuliskan state 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)$$

Karena kita ingin bisa mentransfer informasi dalam state kuantum acak apa pun, membuat state semacam itu adalah titik awal pelajaran ini.

2. Matriks densitas

Kita juga bisa menuliskan state kuantum $|\psi \rangle$ sebagai matriks densitasnya. Bentuk ini berguna untuk menyatakan campuran probabilistik dari state kuantum murni. Untuk satu qubit, kita bisa menuliskan

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

Perhatikan bahwa matriks densitas $\rho$ adalah penjumlahan linear dari matriks Pauli, seperti di bawah ini,

$$\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 adalah $\textbf{r} = (r_{x}, r_{y}, r_{z})$.

Sekarang, mari kita buat state kuantum acak menggunakan bilangan acak.

# 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 bisa menampilkan vektor Bloch ini pada bola Bloch.

from qiskit.visualization import plot_bloch_vector

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

3. Tomografi state kuantum

Jika kamu hanya mengukur state kuantum dalam basis komputasi ($|0 \rangle$ dan $|1 \rangle$), informasi fase (informasi bilangan kompleks) akan hilang. Tapi jika kita punya banyak salinan $|\psi \rangle$ dengan mengulang proses persiapan (kita tidak bisa mengkloning state, tapi kita bisa mengulang proses persiapan), kita bisa memperkirakan nilai $r_{x}, r_{y}, r_{z}$ dengan melakukan tomografi state kuantum untuk matriks densitas $\rho$. Dengan bentuk:

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

berlaku bahwa

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

Untuk kasus $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 dari persamaan ini berlaku untuk $|\psi \rangle =\alpha|0\rangle+\beta|1\rangle$. Oleh karena itu, kita bisa mendapatkan $r_{z}$ dari probabilitas $|0 \rangle$ - Probabilitas $|1 \rangle$.

Estimasi nilai $r_z$

Untuk mengestimasi $r_z$, kita buat state kuantum dan mengukurnya. Kita ulangi persiapan dan pengukuran berkali-kali. Akhirnya kita gunakan statistik pengukuran untuk mengestimasi probabilitas di atas dan dengan demikian mengestimasi $r_z$.

Untuk membuat state kuantum acak, kita akan menggunakan gate unitary umum $U$ dengan parameter $\theta, \varphi$. (Lihat U-gate untuk informasi lebih 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 basis komputasi untuk mengestimasi $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 metode tomografi state kuantum, kita mengestimasi nilai $r_z$. Dalam hal ini, karena kita memilih parameter untuk state "acak", kita mengetahui nilai $r_z$ dan bisa memeriksa pekerjaan kita. Tapi pada hakikatnya, pekerjaan skala utilitas tidak selalu semudah itu untuk diperiksa. Kita akan membahas lebih lanjut tentang memeriksa hasil kuantum nanti dalam kursus ini. Untuk sekarang, cukup perhatikan bahwa estimasi kita cukup akurat.

Latihan 1: Estimasi nilai $r_x$

Ingat bahwa komputer kuantum IBM® mengukur sepanjang sumbu $z$ (kadang dinyatakan "dalam basis $z$" atau "dalam basis komputasi"). Namun, dengan menggunakan rotasi sebelum pengukuran, kita juga bisa mengukur proyeksi state kuantum pada sumbu x. Lebih tepatnya, jika kita memutar sistem kita sehingga hal-hal yang semula menunjuk ke arah $x$ kini menunjuk ke arah $z$, maka kita bisa tetap menggunakan hardware pengukuran yang sama sepanjang $z$, tapi belajar tentang state yang baru saja berada di sepanjang $x$ sesaat yang lalu. Inilah cara sebagian besar komputer kuantum (dan semua komputer kuantum IBM) melakukan pengukuran sepanjang beberapa sumbu.

Dengan pemahaman ini, coba tulis kode untuk mengestimasi nilai $r_x,$ menggunakan tomografi state kuantum.

Solusi:

# 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: Estimasi nilai $r_y$

Menggunakan argumen logis yang sama seperti sebelumnya, kita bisa memutar sistem sebelum pengukuran untuk mempelajari $r_y$. Coba tulis kode sendiri untuk mengestimasi nilai $r_y$ menggunakan tomografi state kuantum. Kamu bisa mulai dari contoh sebelumnya, tapi dengan rotasi yang berbeda. (Untuk informasi lebih lanjut tentang berbagai gate yang digunakan, termasuk sdg, lihat referensi API.)

Solusi:

# 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 sekarang telah mengestimasi semua komponen $\vec{r}$ dan bisa menuliskan vektor lengkapnya.

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).

Kamu berhasil mendapatkan estimasi vektor acak asli dengan cukup akurat menggunakan metode tomografi state kuantum ini.

4. Teleportasi kuantum

Mari kita bayangkan situasi di mana Alice ingin mengirimkan state kuantum yang tidak diketahui $|\psi \rangle$ ke temannya Bob yang berada jauh. Asumsikan mereka hanya bisa berkomunikasi secara klasikal (seperti email atau telepon). Alice tidak bisa menyalin state kuantum tersebut (karena teorema no-cloning). Kalau dia mengulangi proses persiapan yang sama berkali-kali, dia bisa mengumpulkan statistik seperti yang baru saja kita lakukan. Tapi bagaimana kalau hanya ada satu state yang tidak diketahui? State ini mungkin muncul dari proses fisik yang ingin kamu pelajari. Atau bisa jadi bagian dari komputasi kuantum yang lebih besar. Dalam kasus itu, bagaimana Alice bisa mengirim state tersebut ke Bob? Dia bisa, jika dia dan Bob berbagi sumber daya kuantum yang berharga: state terkait (entangled) yang sama, seperti Bell state yang diperkenalkan di pelajaran sebelumnya: $\frac {|00\rangle + |11\rangle}{\sqrt 2}.$ Kadang kamu juga melihat ini disebut sebagai "pasangan EPR" atau "e-bit" (satuan dasar dari keterkaitan/entanglement). Jika Alice berbagi state terkait seperti itu dengan Bob, dia bisa menteleportasikan state kuantum yang tidak diketahui ke Bob dengan melakukan serangkaian operasi kuantum dan mengirimkan dua bit informasi klasikal.

4.1 Protokol teleportasi kuantum

Asumsi: Alice punya state kuantum yang tidak diketahui $|\psi \rangle$ yang akan dikirim ke Bob. Alice dan Bob berbagi state terkait 2-Qubit, atau e-bit, masing-masing memegang satu Qubit secara fisik di lokasi mereka.

Berikut ini garis besar prosedurnya tanpa penjelasan. Ini akan diimplementasikan secara detail di bawah.

1. Alice meng-entangle $|\psi \rangle$ dengan bagiannya dari e-bit menggunakan Gate CNOT.
2. Alice menerapkan Gate Hadamard ke $|\psi \rangle$, dan mengukur kedua Qubit-nya dalam basis komputasional.
3. Alice mengirimkan hasil pengukurannya ke Bob (bisa "00", "01", "10", atau "11")
4. Bob melakukan operator koreksi berdasarkan dua bit informasi dari Alice pada bagiannya dari pasangan e-bit.
   • Kalau "00", Bob tidak melakukan apa-apa
   • Kalau "01", Bob menerapkan Gate X
   • Kalau "10", Bob menerapkan Gate Z
   • Kalau "11", Bob menerapkan iY = ZX gate
5. Bagian Bob dari e-bit menjadi $|\psi \rangle$.

Ini juga dibahas lebih detail di Dasar-dasar Informasi Kuantum. Tapi situasinya akan semakin jelas saat kita mengimplementasikannya di Qiskit.

4.2 Circuit kuantum yang mensimulasikan teleportasi kuantum

Seperti biasa, kita akan menerapkan kerangka pola Qiskit. Bagian ini akan fokus pada pemetaan saja.

Langkah 1: Petakan masalah ke Circuit dan operator kuantum

Untuk menggambarkan skenario di atas, kita perlu Circuit dengan tiga Qubit: dua untuk pasangan terkait yang dibagikan oleh Alice dan Bob, dan satu untuk state 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")

Di awal, Alice punya state kuantum yang tidak diketahui $|\psi \rangle.$ Kita akan membuatnya 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 bisa memvisualisasikan state yang telah kita buat, tapi hanya karena kita tahu parameter apa yang digunakan di Gate $U$. Kalau state ini muncul dari proses kuantum yang rumit, state tersebut tidak bisa diketahui tanpa menjalankan proses untuk membuat state itu berkali-kali dan mengumpulkan statistik seperti pada 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 dimulai, kita asumsikan Alice dan Bob sudah berbagi pasangan terkait. Kalau Alice dan Bob benar-benar berada di lokasi berbeda, mereka mungkin sudah menyiapkan state yang dibagikan sebelum state yang tidak diketahui $|\psi\rangle$ pernah dibuat. Karena hal-hal itu terjadi pada Qubit yang berbeda, urutannya di sini tidak akan berpengaruh, dan urutan ini nyaman 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")

Selanjutnya, Alice meng-entangle $|\psi \rangle$ dengan bagiannya dari e-bit yang dibagikan, menggunakan Gate $CX$ dan Gate $H$, lalu mengukur keduanya dalam basis komputasional.

# 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 mengirimkan hasil pengukurannya ke Bob (bisa "00", "01", "10", atau "11"), dan Bob melakukan operator koreksi berdasarkan dua bit informasi dari Alice pada bagiannya dari e-bit yang dibagikan. Kemudian, milik 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")

Kamu sudah menyelesaikan Circuit teleportasi kuantum! Mari kita lihat state output dari Circuit 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)

Kamu bisa melihat bahwa state kuantum yang dibuat oleh Gate $U$ pada Qubit 0 (Qubit yang awalnya menyimpan state rahasia) telah dipindahkan ke Qubit 2 (Qubit Bob).

Kamu bisa menjalankan sel di atas beberapa kali untuk memastikannya. Kamu mungkin memperhatikan bahwa Qubit 0 dan 1 berganti state, tapi Qubit 2 selalu berada dalam state $|\psi\rangle$.

4.3 Jalankan dan konfirmasi hasilnya dengan menerapkan invers U

Di atas, kita sudah memeriksa secara visual bahwa state yang diteleportasikan terlihat benar. Cara lain untuk memeriksa apakah state kuantum telah diteleportasikan dengan benar adalah dengan menerapkan invers Gate $U$ pada Qubit Bob sehingga kita bisa mengukur '0'. Yaitu, karena $U^{-1}U$ adalah identitas, jika Qubit Bob berada dalam state yang dibuat dari $U|0\rangle,$ maka menerapkan inversnya seharusnya 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 menjalankan Circuit terlebih dahulu menggunakan AerSimulator, sebelum beralih ke komputer kuantum nyata.

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 bahwa dalam notasi little endian, Qubit 2 adalah Qubit paling kiri (atau paling bawah, dalam label kolom). Perhatikan bahwa Qubit paling kiri dan paling bawah dalam label kolom adalah 0 untuk semua kemungkinan hasil. Ini menunjukkan kita memiliki probabilitas 100% untuk mengukur $q_2$ dalam state $|0\rangle$. Ini adalah hasil yang diharapkan, dan menunjukkan protokol teleportasi telah bekerja dengan benar.

4.4 Teleportasi pada komputer kuantum nyata

Selanjutnya, kita akan melakukan teleportasi pada komputer kuantum nyata. Menggunakan fungsi circuit dinamis, kita bisa beroperasi di tengah Circuit menggunakan hasil pengukuran, mengimplementasikan secara real-time operasi kondisional dalam Circuit teleportasi. Untuk menyelesaikan masalah dengan komputer kuantum nyata, kita akan mengikuti empat langkah pola Qiskit.

1. Petakan masalah ke Circuit dan operator kuantum
2. Optimalkan untuk perangkat keras target
3. Jalankan pada perangkat keras target
4. Proses pasca hasil

Latihan 3: Bangun Circuit teleportasi

Coba bangun seluruh Circuit teleportasi dari awal untuk menguji pemahamanmu. Scroll ke atas jika kamu butuh pengingat.

Solusi:

# 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 pengingat, menerapkan invers Gate $U$ hanya untuk memverifikasi perilaku yang diharapkan. Ini bukan bagian dari pengiriman state ke Bob, dan kita tidak akan menggunakan Gate invers $U$ tersebut jika tujuannya hanya memindahkan informasi kuantum.

Langkah 2: Optimalkan untuk perangkat keras target

Untuk dijalankan pada perangkat keras, import QiskitRuntimeService dan muat kredensial tersimpanmu. Pilih Backend dengan jumlah job paling sedikit dalam antrian.

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')

Mari kita lihat coupling map dari perangkat yang kamu pilih.

from qiskit.visualization import plot_gate_map

plot_gate_map(backend)

Perangkat yang berbeda mungkin memiliki coupling map yang berbeda, dan setiap perangkat punya beberapa Qubit dan coupler yang kinerjanya lebih baik dari yang lain. Selain itu, komputer kuantum yang berbeda mungkin memiliki gate native yang berbeda (gate yang bisa dijalankan oleh perangkat keras). Transpilasi Circuit menulis ulang Circuit kuantum abstrak menggunakan gate yang bisa dijalankan oleh komputer kuantum target, dan memilih pemetaan optimal ke Qubit fisik (dan hal lainnya). Transpilasi adalah topik yang kaya dan rumit. Untuk info lebih lanjut tentang transpilasi, lihat referensi 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: Jalankan Circuit.

Menggunakan primitif Runtime Sampler, kita akan menjalankan Circuit target.

# 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'

Kamu juga bisa memeriksa status job dari dashboard IBM Quantum®.

# 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'

Kalau kamu melihat 'DONE' ditampilkan, kamu bisa mendapatkan hasilnya dengan menjalankan 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 hasil

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

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

Kamu bisa menginterpretasikan hasil di atas secara langsung. Atau, menggunakan marginal_count, kamu bisa menelusuri hasil 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, ada beberapa hasil di mana kita mengukur $|1 \rangle$. Ini disebabkan oleh noise dan kesalahan. Khususnya, circuit dinamis cenderung memiliki tingkat kesalahan yang lebih tinggi karena pengukuran di tengah Circuit yang memakan waktu.

4.5 Poin penting tentang teleportasi kuantum

Kita bisa memindahkan state kuantum ke teman yang jauh dengan berbagi sepasang Qubit yang terkait (e-bit).

1. Apakah teleportasi kuantum bisa mengirimkan state kuantum lebih cepat dari cahaya? Tidak, karena Alice harus memberitahu Bob hasil pengukurannya secara klasikal.

2. Apakah teleportasi kuantum melanggar "teorema no-cloning", yang melarang penyalinan state kuantum? Tidak, karena state kuantum asli yang diberikan ke Alice pada salah satu Qubit-nya hilang dalam pengukuran. State itu runtuh menjadi $|0\rangle$ atau $|1\rangle$.

5. Pengkodean superdense

Hampir pengaturan yang sama bisa digunakan untuk tujuan yang berbeda. Misalkan Alice ingin mengirimkan dua bit informasi klasikal ke Bob, tapi dia tidak punya cara komunikasi klasikal dengan Bob. Namun, dia berbagi pasangan terkait dengan Bob dan dia diizinkan untuk mengirimkan Qubit-nya ke lokasi Bob. Perhatikan kontrasnya dengan protokol teleportasi kuantum. Dalam teleportasi, komunikasi klasikal tersedia bagi mereka, dan tujuannya adalah mengirimkan state kuantum. Di sini, komunikasi klasikal tidak tersedia dan mereka menggunakan pemindahan Qubit untuk berbagi dua bit informasi klasikal.

5.1 Protokol pengkodean superdense

Asumsi: Alice punya dua bit informasi, misalkan $a_1a_2 \in \{00, 01, 10, 11\}$. Alice dan Bob berbagi pasangan terkait (e-bit), tapi mereka tidak bisa berkomunikasi secara klasikal.

1. Alice melakukan salah satu operasi berikut pada bagiannya dari e-bit.
   • Kalau $a_1a_2 = 00$, dia tidak melakukan apa-apa
   • Kalau $a_1a_2 = 01$, dia menerapkan Gate Z
   • Kalau $a_1a_2 = 10$, dia menerapkan Gate X
   • Kalau $a_1a_2 = 11$, dia menerapkan Gate Z dan Gate X.
2. Alice mengirimkan bagiannya dari e-bit ke lokasi Bob.
3. Bob menerapkan Gate CNOT dengan Qubit dari Alice sebagai kontrol dan Qubit-nya sebagai target, lalu menerapkan Gate H ke Qubit dari Alice, dan mengukur kedua Qubit. State awal yang mungkin 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 bahwa tanda negatif dari $-|11\rangle$ adalah fase global, sehingga tidak bisa diukur.

5.2 Circuit kuantum yang mensimulasikan pengkodean superdense

Berdasarkan protokol pengkodean superdense, kamu bisa membangun Circuit pengkodean superdense seperti di bawah ini. Coba ubah pesan, msg, yang ingin Alice kirimkan ke Bob.

from qiskit import QuantumCircuit

Langkah-langkah pola Qiskit diidentifikasi dalam komentar kode.

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

Kamu bisa melihat bahwa Bob menerima pesan yang ingin Alice kirimkan kepadanya.

Selanjutnya, mari kita coba dengan komputer kuantum nyata.

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 sesuai yang kita harapkan. Perhatikan bahwa pengkodean superdense pada komputer kuantum nyata menunjukkan lebih sedikit kesalahan dibandingkan kasus teleportasi kuantum pada komputer kuantum nyata. Salah satu alasannya mungkin karena teleportasi kuantum menggunakan circuit dinamis, sedangkan pengkodean superdense tidak. Kita akan mempelajari lebih lanjut tentang kesalahan dalam Circuit kuantum di pelajaran-pelajaran selanjutnya.

6. Ringkasan

Dalam sesi ini, kita telah mengimplementasikan dua protokol kuantum. Meski skenario keduanya yang melibatkan teman-teman yang berjauh agak berbeda dari komputasi kuantum pada satu QPU, keduanya memiliki aplikasi dalam komputasi kuantum, dan membantu kita memahami pemindahan informasi kuantum dengan lebih baik.

• Teleportasi kuantum: Meski kita tidak bisa menyalin state kuantum, kita bisa menteleportasikan state kuantum yang tidak diketahui dengan memiliki keterkaitan (entanglement) yang dibagikan.
• Pengkodean superdense kuantum: Pasangan terkait yang dibagikan, dan pemindahan satu Qubit, memungkinkan komunikasi dua bit informasi klasikal.

# See the version of Qiskit
import qiskit

qiskit.__version__

'2.0.2'