Quantum teleportation at superdense coding

tala

Kifumi Numata (26 Apr 2024)

I-download ang pdf ng orihinal na lektura. Tandaan na ang ilang code snippet ay maaaring ma-deprecate dahil static na imahe ang mga ito.

Ang tinatayang QPU time para patakbuhin ang eksperimentong ito ay 10 segundo.

1. Panimula

Para malutas ang anumang quantum na problema sa utility-scale, kailangan nating maglipat ng impormasyon sa loob ng quantum computer mula sa isang qubit patungo sa isa pa. May mga kilalang protocol para dito, ngunit ang ilan sa pinaka-pundasyon ay nailatag sa konteksto ng pagpapadala ng impormasyon sa pagitan ng magkalalayong partido. Sa buong araling ito, gagamit tayo ng mga terminong angkop sa kontekstong ito, tulad ng "magkalalayong kaibigan na nagpapadala ng impormasyon." Ngunit tandaan na ang mga protocol na ito ay may mas malawak na kahalagahan sa quantum computing. Sa araling ito, titingnan natin ang mga sumusunod na quantum communication protocol:

• Quantum teleportation Paggamit ng shared entangled state (tinatawag din minsan na e-bit) para maipadala ang isang hindi kilalang quantum state sa isang malalayong kaibigan, na nangangailangan ng karagdagang klasikal na komunikasyon.
• Quantum superdense coding Paano magpadala ng dalawang bit ng impormasyon sa pamamagitan ng pagpapadala ng isang qubit sa isang malalayong kaibigan (gamit din ang dating shared entangled qubits).

Para sa karagdagang background na may kaugnayan sa mga paksang ito, inirerekomenda namin ang leksyon 4 sa Basics of Quantum Information tungkol sa Entanglement in action.

Sa paglalarawan sa itaas, ang "hindi kilalang quantum state" ay tumutukoy lamang sa isang state ng anyo na inilarawan sa nakaraang aralin:

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

kung saan ang $\alpha$ at $\beta$ ay mga kumplikadong numero na nagtutugon sa $|\alpha|^2+|\beta|^2 = 1$. Nagbibigay-daan ito sa atin na isulat ang quantum state bilang

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

Dahil gusto nating makapagpadala ng impormasyon sa anumang random na quantum state, dito tayo magsisimula ng araling ito.

2. Density matrices

Maaari rin nating isulat ang quantum state na $|\psi \rangle$ bilang density matrix nito. Ang form na ito ay kapaki-pakinabang para sa pagtukoy ng probabilistikong halo ng mga purong quantum state. Para sa isang qubit, maaari nating isulat ang:

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

Tandaan na ang density matrix na $\rho$ ay isang linear na kabuuan ng mga Pauli matrix, tulad ng nasa ibaba,

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

O, sa pangkalahatan,

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

kung saan $r_{x}^2+r_{y}^2+r_{z}^2=1$.

At, ang Bloch vector ay $\textbf{r} = (r_{x}, r_{y}, r_{z})$.

Ngayon, gumawa tayo ng isang arbitrary na quantum state gamit ang mga random na numero.

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

Maaari nating ipakita ang Bloch vector na ito sa Bloch sphere.

from qiskit.visualization import plot_bloch_vector

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

3. Quantum state tomography

Kung susukatin mo lamang ang quantum state sa computational basis ($|0 \rangle$ at $|1 \rangle$), mawawala ang impormasyon ng phase (ang impormasyon ng complex number). Ngunit kung mayroon tayong maraming kopya ng $|\psi \rangle$ sa pamamagitan ng paulit-ulit na proseso ng paghahanda (hindi natin maaaring i-clone ang mga state, ngunit maaari tayong mag-ulit ng proseso ng paghahanda), maaari nating tantiyahin ang halaga ng $r_{x}, r_{y}, r_{z}$ sa pamamagitan ng pagsasagawa ng quantum state tomography para sa density matrix na $\rho$. Dahil sa anyo:

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

nangangahulugan ito na

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

Sa kaso ng $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$$

Ang huling pagbabago ng equation ay para sa $|\psi \rangle =\alpha|0\rangle+\beta|1\rangle$. Kaya naman, maaari nating makuha ang $r_{z}$ sa pamamagitan ng probabilidad ng $|0 \rangle$ - Probabilidad ng $|1 \rangle$.

Tantiyahin ang halagang $r_z$

Para tantiyahin ang $r_z$, gagawa tayo ng quantum state at susukatin ito. Paulit-ulit na nating ihahanda at susukat nang maraming beses. Sa huli, gagamitin natin ang estadistika ng pagsukat para tantiyahin ang mga probabilidad sa itaas at sa gayon ay matantiya ang $r_z$.

Para lumikha ng random na quantum state, gagamitin natin ang pangkalahatang unitary gate na $U$ na may mga parameter na $\theta, \varphi$. (Tingnan ang U-gate para sa karagdagang impormasyon.)

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

Gamit ang AerSimulator, susukat tayo sa computational basis para tantiyahin ang $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

Gamit ang paraan ng quantum state tomography, natantiya natin ang halagang $r_z$. Sa kasong ito, dahil pinili natin ang isang parameter para sa "random" na state, alam natin ang halaga ng $r_z$ at maaari nating suriin ang ating gawa. Ngunit sa likas ng kababalaghang utility-scale, hindi laging ganoon kadali suriin ang mga resulta. Tatalakayin natin ang karagdagang paraan ng pag-verify ng mga quantum na resulta sa susunod na bahagi ng kursong ito. Sa ngayon, tandaan lamang na ang ating tantiya ay makatotohanang tumpak.

Ehersisyo 1: Tantiyahin ang halagang $r_x$

Tandaan na ang mga IBM® quantum computer ay sumusukat sa kahabaan ng $z$-axis (minsan tinatawag na "sa $z$ basis" o "sa computational basis"). Gayunpaman, sa pamamagitan ng paggamit ng mga rotasyon bago ang pagsukat, maaari rin nating sukatin ang proyeksyon ng quantum state sa x-axis. Upang maging mas tumpak, kung iikutin natin ang ating sistema upang ang mga bagay na noon ay nakaturo sa $x$ ay ngayon ay nakaturo sa $z$, maaari nating gamitin ang parehong hardware ng pagsukat sa kahabaan ng $z$, ngunit matuto nang ukol sa state na noong nakaraang sandali ay nasa kahabaan ng $x$. Ito ang paraan ng karamihang quantum computer (at lahat ng IBM quantum computer) sa pagsasagawa ng mga pagsukat sa maraming axis.

Sa pag-unawang ito, subukang sumulat ng code para tantiyahin ang halaga ng $r_x$ gamit ang quantum state tomography.

Solusyon:

# 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

Ehersisyo 2: Tantiyahin ang halagang $r_y$

Gamit ang parehong lohikal na argumento tulad ng dati, maaari nating i-rotate ang sistema bago ang pagsukat para matuto nang ukol sa $r_y$. Subukang sumulat ng code para tantiyahin ang halaga ng $r_y$ gamit ang quantum state tomography. Maaari kang magsimula sa nakaraang halimbawa, ngunit gumawa ng iba't ibang rotasyon. (Para sa karagdagang impormasyon tungkol sa iba't ibang gate na ginamit, kabilang ang sdg, tingnan ang API reference.)

Solusyon:

# 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

Natantiya na natin ang lahat ng bahagi ng $\vec{r}$ at maaari na nating isulat ang buong vector.

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

Nakuha mo ang makatotohanang tumpak na tantiya ng orihinal na random na vector gamit ang paraan ng quantum state tomography na ito.

4. Quantum teleportation

Isaalang-alang natin ang sitwasyon kung saan nais ni Alice na ipadala ang isang hindi kilalang quantum state na $|\psi \rangle$ sa kanyang kaibigan na si Bob, na nasa malayo. Ipagpalagay na ang tanging paraan lamang ng komunikasyon nila ay ang klasikal na komunikasyon (tulad ng email o telepono). Hindi maaaring kopyahin ni Alice ang quantum state (dahil sa no-cloning theorem). Kung paulit-ulit niya ang parehong proseso ng paghahanda nang maraming beses, maaari siyang mangolekta ng estadistika tulad ng ginawa natin kanina. Ngunit paano kung iisa lang ang hindi kilalang state na iyon? Maaaring lumabas ang state na ito mula sa isang pisikal na prosesong gustong pag-aralan. O maaari itong bahagi ng mas malaking quantum computation. Sa ganoong kaso, paano maipapadala ni Alice ang state kay Bob? Magagawa niya ito, kung sila ni Bob ay nagtataglay ng isang mahalagang quantum resource: isang shared entangled state, tulad ng Bell state na inilarawan sa nakaraang aralin: $\frac {|00\rangle + |11\rangle}{\sqrt 2}.$ Minsan ay tinatawag din itong "EPR pair" o "e-bit" (isang pangunahing yunit ng entanglement). Kung nagtataglay si Alice ng ganitong entangled state kasama si Bob, maaari niyang i-teleport ang hindi kilalang quantum state kay Bob sa pamamagitan ng pagsasagawa ng isang serye ng quantum operations at pagpapadala sa kanya ng dalawang bits ng klasikal na impormasyon.

4.1 Ang protokol ng Quantum teleportation

Pagpapalagay: Mayroon si Alice ng isang hindi kilalang quantum state na $|\psi \rangle$ na ipapadala kay Bob. Nagtataglay sina Alice at Bob ng isang 2-qubit entangled state, o e-bit, bawat isa ay may hawak na isang Qubit sa kanilang kani-kanilang lokasyon.

Narito ang balangkas ng pamamaraan nang walang paliwanag. Ipapatupad ang mga ito nang detalyado sa ibaba.

1. Inientangle ni Alice ang $|\psi \rangle$ sa kanyang bahagi ng e-bit gamit ang CNOT Gate.
2. Naglapat si Alice ng Hadamard Gate sa $|\psi \rangle$, at sinukat ang kanyang dalawang Qubit sa computational basis.
3. Ipinadala ni Alice kay Bob ang kanyang mga resulta ng pagsukat (alinman sa "00", "01", "10", o "11")
4. Nagsagawa si Bob ng correction operator batay sa dalawang bits ng impormasyon ni Alice sa kanyang bahagi ng e-bit pair.
   • Kung "00", walang ginagawa si Bob
   • Kung "01", nag-apply si Bob ng X Gate
   • Kung "10", nag-apply si Bob ng Z Gate
   • Kung "11", nag-apply si Bob ng iY = ZX Gate
5. Nagiging $|\psi \rangle$ ang bahagi ni Bob ng e-bit.

Mas detalyadong tinalakay ito sa Basics of Quantum Information. Magiging mas malinaw ang sitwasyon habang isinasabuhay natin ito sa Qiskit.

4.2 Quantum Circuit na nagsi-simulate ng quantum teleportation

Tulad ng dati, gagamitin natin ang Qiskit patterns framework. Ang subseksyong ito ay nakatuon lamang sa mapping.

Hakbang 1: I-map ang problema sa quantum circuits at operators

Para mailarawan ang sitwasyong nabanggit sa itaas, kailangan natin ng Circuit na may tatlong Qubit: dalawa para sa entangled pair na ibinabahagi nina Alice at Bob, at isa para sa hindi kilalang quantum state na $|\psi\rangle$.

from qiskit import QuantumCircuit
import numpy as np

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

qc.draw(output="mpl")

Sa simula, mayroon si Alice ng isang hindi kilalang quantum state na $|\psi \rangle.$ Lilikha tayo nito gamit ang $U$ Gate.

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

Maaari nating i-visualize ang state na nilikha natin, ngunit tanging dahil alam natin kung anong mga parameter ang ginamit sa $U$ Gate. Kung ang state na ito ay lumabas mula sa isang kumplikadong quantum process, hindi matutukoy ang state nang hindi paulit-ulit na isinasagawa ang proseso para lumikha ng state nang maraming beses, at nangongolekta ng estadistika tulad ng sa tomography.

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

Bago pa man magsimula ang protokol na ito, ipinagpapalagay nating mayroon nang shared entangled pair sina Alice at Bob. Kung tunay na nasa iba't ibang lugar sila, maaaring naitayo na nila ang shared state bago pa man nalilikha ang hindi kilalang state na $|\psi\rangle$. Dahil ang mga bagay na iyon ay nangyayari sa iba't ibang Qubit, hindi mahalaga ang pagkakasunod-sunod dito, at ang pagkakasunod-sunod na ito ay maginhawa para sa visualization.

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

Susunod, inientangle ni Alice ang $|\psi \rangle$ sa kanyang bahagi ng shared e-bit, gamit ang $CX$ Gate at $H$ Gate, at sinusukat ang mga ito sa computational basis.

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

Ipinapadala ni Alice kay Bob ang kanyang mga resulta ng pagsukat (alinman sa "00", "01", "10", o "11"), at nagsasagawa si Bob ng correction operator batay sa dalawang bits ng impormasyon ni Alice sa kanyang bahagi ng shared e-bit. Pagkatapos, nagiging $|\psi \rangle$ ang kay Bob.

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

Nakumpleto mo na ang isang quantum teleportation Circuit! Tingnan natin ang output state ng Circuit na ito gamit ang statevector simulator.

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)

Makikita mong ang quantum state na nilikha ng $U$-gate sa Qubit 0 (ang Qubit na orihinal na nagtataglay ng lihim na state) ay nailipat na sa Qubit 2 (ang Qubit ni Bob).

Maaari mong patakbuhin ang cell sa itaas nang ilang beses para masiguro. Mapapansin mong nagbabago ang estado ng Qubit 0 at 1, ngunit palagi sa state na $|\psi\rangle$ ang Qubit 2.

4.3 Isagawa ito at kumpirmahin ang resulta sa pamamagitan ng pag-apply ng U inverse

Sa itaas, visual na nasuri natin na tama ang hitsura ng teleported state. Isa pang paraan para masuri kung matagumpay na naiteleport ang quantum state, ay ang pag-apply ng inverse ng $U$ Gate sa Qubit ni Bob para masukat ang '0'. Ibig sabihin, dahil ang $U^{-1}U$ ay identity, kung ang Qubit ni Bob ay nasa state na nilikha mula sa $U|0\rangle,$ ang pag-apply ng inverse ay magbibigay ng $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")

Ipapatakbo muna natin ang Circuit gamit ang AerSimulator, bago lumipat sa isang tunay na quantum computer.

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}

Tandaan na sa little endian notation, ang Qubit 2 ay ang pinaka-kaliwang (o pinaka-ilalim, sa mga label ng column) Qubit. Pansinin na ang pinaka-kaliwa at pinaka-ilalim na Qubit sa mga label ng column ay 0 para sa lahat ng posibleng resulta. Ipinapakita nito na 100% ang pagkakataon na masukat ang $q_2$ sa state na $|0\rangle$. Ito ang inaasahang resulta, at nagpapakita na matagumpay na nagtrabaho ang teleportation protocol.

4.4 Teleportation sa isang tunay na quantum computer

Susunod, isasagawa natin ang teleportation sa isang tunay na quantum computer. Gamit ang dynamic circuit function, maaari tayong mag-operate sa kalagitnaan ng Circuit gamit ang mga resulta ng pagsukat, na ipinapatupad sa real-time ang mga conditional operations sa teleportation Circuit. Para sa paglutas ng mga problema gamit ang tunay na quantum computer, susundin natin ang apat na hakbang ng Qiskit patterns.

1. I-map ang problema sa quantum circuits at operators
2. I-optimize para sa target hardware
3. Isagawa sa target hardware
4. Post-process ang mga resulta

Ehersisyo 3: Buuin ang teleportation Circuit

Subukan mong buuin ang buong teleportation Circuit mula sa simula para masubok ang iyong pag-unawa. Mag-scroll pataas kung kailangan mong magpaalala.

Solusyon:

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

Bilang paalala, ang pag-apply ng inverse ng $U$ Gate ay para lang masuri natin ang inaasahang gawi. Hindi ito bahagi ng pagpapadala ng state kay Bob, at hindi natin gagamitin ang inverse na $U$ Gate kung ang tanging layunin ay ang paglipat ng quantum information.

Hakbang 2: I-optimize para sa target hardware

Para mapatakbo sa hardware, mag-import ng QiskitRuntimeService at i-load ang iyong mga naka-save na credentials. Piliin ang Backend na may pinakamaliit na bilang ng mga trabaho sa pila.

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

Tingnan natin ang coupling map ng device na pinili mo.

from qiskit.visualization import plot_gate_map

plot_gate_map(backend)

Ang iba't ibang device ay maaaring may iba't ibang coupling map, at ang bawat device ay may ilang Qubit at coupler na mas mahusay kaysa sa iba. Bukod pa rito, ang iba't ibang quantum computer ay maaaring may iba't ibang native gates (ang mga Gate na kaya ng hardware na isagawa). Ang pag-transpile ng Circuit ay nagsusulat muli ng abstract quantum circuit gamit ang mga Gate na kayang isagawa ng target quantum computer, at pinipili ang pinakamainam na mapping sa mga pisikal na Qubit (bukod sa iba pang bagay). Ang transpilation ay isang mayaman at kumplikadong paksa. Para sa karagdagang impormasyon tungkol sa transpilation, tingnan ang API reference.

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

Hakbang 3: Isagawa ang Circuit.

Gamit ang Sampler Runtime primitive, ipapatakbo natin ang target Circuit.

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

Maaari mo ring suriin ang status ng trabaho mula sa iyong IBM Quantum® dashboard.

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

Kung makita mong ipinapakita ang 'DONE', makukuha mo na ang resulta sa pamamagitan ng pagpapatakbo ng cell sa ibaba.

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

Hakbang 4: Post-process ang mga resulta

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

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

Maaari mong direktang bigyang-kahulugan ang mga resulta sa itaas. O, gamit ang marginal_count, maaari mong i-trace out ang mga resulta ni Bob sa 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)

Tulad ng makikita dito, may ilang mga resulta kung saan nasukat natin ang $|1 \rangle$. Ito ay dahil sa ingay at mga error. Sa partikular, ang mga dynamic Circuit ay may mas mataas na rate ng error dahil sa nakakatagal na pagsukat sa kalagitnaan ng Circuit.

4.5 Mga pangunahing aral sa quantum teleportation

Maaari nating ilipat ang isang quantum state sa isang malayong kaibigan sa pamamagitan ng pagtataglay ng isang pares ng mga entangled Qubit (isang e-bit).

1. Maaari bang ipadala ng quantum teleportation ang quantum state nang mas mabilis kaysa sa liwanag? Hindi, dahil kailangang sabihin ni Alice kay Bob ang mga resulta ng pagsukat sa klasikal na paraan.

2. Sisirain ba ng quantum teleportation ang "no cloning theorem", na nagbabawal ng pagkopya ng quantum state? Hindi, dahil nawala ang orihinal na quantum state na ibinigay kay Alice sa isa sa kanyang mga Qubit sa pagsukat. Bumagsak ito sa $|0\rangle$ o $|1\rangle$.

5. Superdense coding

Halos parehong setup ang maaaring gamitin para sa ibang layunin. Ipagpalagay na nais ni Alice na ipadala kay Bob ang dalawang bits ng klasikal na impormasyon, ngunit wala siyang paraan ng klasikal na komunikasyon kay Bob. Mayroon naman siyang shared entangled pair kasama si Bob at pinahihintulutan siyang ipadala ang kanyang Qubit sa lokasyon ni Bob. Pansinin ang kaibahan sa quantum teleportation protocol. Sa teleportation, available ang klasikal na komunikasyon para sa mga kaibigan, at ang layunin ay magpadala ng quantum state. Dito, hindi available ang klasikal na komunikasyon at ginagamit nila ang paglipat ng isang Qubit para magbahagi ng dalawang bits ng klasikal na impormasyon.

5.1 Ang protokol ng superdense coding

Pagpapalagay: Mayroon si Alice ng dalawang bits ng impormasyon, sabihing, $a_1a_2 \in \{00, 01, 10, 11\}$. Nagtataglay sina Alice at Bob ng entangled pair (e-bit), ngunit hindi sila makaka-communicate nang klasikal.

1. Nagsasagawa si Alice ng isa sa mga sumusunod na operasyon sa kanyang bahagi ng e-bit.
   • Kung $a_1a_2 = 00$, walang ginagawa siya
   • Kung $a_1a_2 = 01$, nag-apply siya ng Z Gate
   • Kung $a_1a_2 = 10$, nag-apply siya ng X Gate
   • Kung $a_1a_2 = 11$, nag-apply siya ng Z Gate at X Gate.
2. Ipinapadala ni Alice ang kanyang bahagi ng e-bit sa lokasyon ni Bob.
3. Nag-apply si Bob ng CNOT Gate na may Qubit mula kay Alice bilang control at ang kanyang Qubit bilang target, pagkatapos ay nag-apply ng H Gate sa Qubit mula kay Alice, at sinukat ang dalawang Qubit. Ang mga posibleng panimulang state at mga resulta ng mga operasyon ni Bob ay:

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

Tandaan na ang negatibong tanda ng $-|11\rangle$ ay global phase, kaya hindi ito masusukat.

5.2 Quantum Circuit na nagsi-simulate ng superdense coding

Batay sa protokol ng superdense coding, maaari kang bumuo ng superdense coding Circuit tulad ng nasa ibaba. Subukan mong baguhin ang mensahe, msg, na nais ipasa ni Alice kay Bob.

from qiskit import QuantumCircuit

Ang mga hakbang ng Qiskit pattern ay natukoy sa mga komento ng code.

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

Makikita mong natanggap ni Bob ang mensaheng nais ipadala ni Alice sa kanya.

Susunod, subukan nating gamitin ang isang tunay na quantum computer.

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

Ang resulta ay ayon sa aming inaasahan. Tandaan na ang superdense coding sa isang tunay na quantum computer ay nagpakita ng mas kaunting mga error kaysa sa kaso ng quantum teleportation sa isang tunay na quantum computer. Isa sa mga dahilan nito ay maaaring gumagamit ang quantum teleportation ng mga dynamic Circuit, at hindi ang superdense coding. Matututunan natin ang higit pa tungkol sa mga error sa quantum Circuit sa mga susunod na aralin.

6. Buod

Sa sesyong ito, nagpatupad tayo ng dalawang quantum protocol. Kahit medyo malayo sa quantum computing sa isang solong QPU ang mga sitwasyong naglalaman ng mga malalayong kaibigan para sa pareho, mayroon itong mga aplikasyon sa quantum computing, at nakatutulong sa atin na maunawaan nang mas mabuti ang paglipat ng quantum information.

• Quantum teleportation: Kahit hindi natin maaaring kopyahin ang mga quantum state, maaari nating i-teleport ang mga hindi kilalang quantum state sa pamamagitan ng pagtataglay ng shared entanglement.
• Quantum superdense coding: Ang isang shared entangled pair, at paglipat ng isang Qubit, ay nagbibigay-daan sa komunikasyon ng dalawang bits ng klasikal na impormasyon.

# See the version of Qiskit
import qiskit

qiskit.__version__

'2.0.2'