Quantum teleportation

Para sa Qiskit in Classrooms module na ito, ang mga estudyante ay dapat may gumaganang Python environment na may mga sumusunod na naka-install na package:

• qiskit v2.1.0 o mas bago
• qiskit-ibm-runtime v0.40.1 o mas bago
• qiskit-aer v0.17.0 o mas bago
• qiskit.visualization
• numpy
• pylatexenc

Para i-set up at i-install ang mga package sa itaas, tingnan ang gabay na I-install ang Qiskit. Upang makapagpatakbo ng mga trabaho sa mga tunay na quantum computer, ang mga estudyante ay kailangang mag-set up ng account sa IBM Quantum® sa pamamagitan ng pagsunod sa mga hakbang sa gabay na I-set up ang iyong IBM Cloud account.

Ang module na ito ay nasubukan at gumamit ng 14 segundo ng QPU time. Pagtatantya lamang ito. Ang iyong aktwal na paggamit ay maaaring mag-iba.

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

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

Panoorin ang module walkthrough ni Dr. Katie McCormick sa ibaba, o mag-click dito para mapanood ito sa YouTube.

---

Panimula at background

Ang quantum teleportation ay isang pamamaraan sa quantum physics na nagbibigay-daan sa paglipat ng quantum information mula sa isang lokasyon patungo sa isa pa nang hindi pisikal na inililipat ang mga particle. Hindi katulad ng sci-fi na konsepto ng teleportation, ang prosesong ito ay hindi nagsasangkot ng pagpapadala ng bagay. Sa halip, ito ay umaasa sa prinsipyo ng quantum entanglement, kung saan ang dalawang particle ay nagiging magkaugnay anuman ang distansya. Sa pamamagitan ng isang serye ng tumpak na mga sukat at klasikal na komunikasyon, ang quantum state ng isang particle ay maaaring i-recreate sa isa pang particle sa isang malayong lokasyon, na epektibong "nagteteleleport" ng quantum information. Sa module na ito, makikita natin kung paano ito gumagana sa matematika, at pagkatapos ay ipapatupad natin ang quantum teleportation sa isang tunay na quantum computer. Ang panimula rito ay magiging maikli; para sa mas maraming background tungkol sa quantum information, at mas maraming paliwanag tungkol sa teleportation, inirerekumenda namin ang kurso ni John Watrous sa Basics of quantum information, at lalo na ang seksyon sa Teleportation.

Ang mga klasikal na bit ay maaaring nasa estado 0 o 1. Ang mga quantum bit (qubit) ay maaaring nasa mga quantum state na tinutukoy bilang $|0\rangle$ at $|1\rangle$ at pati na rin ang mga linear na kombinasyon ng mga estado na ito, na tinatawag na "mga superposisyon", tulad ng $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, na may $\alpha_0,\alpha_1 \in \mathbb{C},$ at $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Kahit na ang mga estado ay maaaring umiiral sa superposisyon na ito, ang isang sukat ng estado ay "mag-cocollapse" nito sa alinman sa estado na $|0\rangle$ o $|1\rangle$. Ang mga parameter na $a$ at $b$ ay may kaugnayan sa posibilidad ng bawat resulta ng sukat ayon sa

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

Kaya ang limitasyon na $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Isa pang mahalagang katangian ay ang mga quantum bit ay maaaring "ma-entangle", na nangangahulugang ang sukat ng isang qubit ay maaaring makaapekto sa resulta ng sukat ng isa pa, na entangled na qubit. Ang pag-unawa kung paano naiiba ang entanglement mula sa simpleng klasikal na mga korelasyon ay medyo mahirap. Unahin nating ipaliwanag ang ating notasyon. Tawagan nating dalawang qubit na pag-aari ng kaibigan 0 (Alice) at kaibigan 1 (Bob), at ang bawat isa ay nasa estado ng $|0\rangle$

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

o

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

kung minsan ay pinaikli lamang sa

$$|00\rangle$$

Pansinin na ang pinaka-mababang numbered (o lettered) na qubit ay pinakamalayo sa kanan. Ito ay isang kombensyon na tinatawag na "little-endian" na notasyon, na ginagamit sa buong Qiskit. Kung ang two-qubit state ng mga kaibigan ay $|00\rangle,$ at sinusukat nila ang estado ng kani-kanilang mga qubit, ang bawat isa ay makakakita ng 0. Katulad din kung ang mga qubit ay nasa estado na $|11\rangle,$ ang bawat isa sa kanilang mga sukat ay magbubunga ng 1. Hindi iyon naiiba mula sa klasikal na kaso. Gayunpaman, sa quantum computing, maaari nating pagsamahin ito sa superposisyon upang makakuha ng mga estado tulad ng

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

Sa isang estado tulad nito, kung ang mga qubit ng Alice at Bob ay nasa estado ng 0 o 1 ay hindi pa alam, hindi pa naman natutukoy ng kalikasan, at gayunpaman alam natin na masusukat nila ang parehong estado para sa kanilang qubit. Halimbawa, kung sinusukat ni Bob ang kanyang qubit na nasa estado na $|0\rangle,$ ang tanging paraan para mangyari iyon ay kung ang sukat ay nag-collapse ng two-qubit state sa isa sa dalawang posibleng estado, partikular sa $|00\rangle.$ Iyon ay nag-iiwan sa qubit ni Alice na nasa estado rin ng $|0\rangle$.

Ang entanglement ng mga qubit sa ganitong paraan ay hindi nangangailangan na ang mga qubit ay manatiling pisikal na malapit sa isa't isa. Sa ibang salita, maaari tayong mag-entangle ng mga qubit, pagkatapos ay ihiwalay ang mga ito ng malaking distansya, at gamitin ang kanilang entanglement upang magpadala ng impormasyon. Ang isang entangled state tulad ng nasa itaas ay isang pangunahing yunit ng entanglement, at kung minsan ay tinutukoy bilang isang "e-bit", isang solong bit ng entanglement. Ang mga e-bit na ito ay maaaring ituring bilang mga mapagkukunan sa quantum communication, dahil ang bawat e-bit na ibinabahagi sa pagitan ng mga malalayong kasosyo ay maaaring gamitin, tulad ng aming binabalangkas dito, upang ilipat ang impormasyon mula sa isang lokasyon patungo sa isa pa.

Ang unang naiisip ng maraming tao na natututo tungkol dito sa unang pagkakataon ay ang paglabag sa relatibidad: maaari ba nating gamitin ito upang magpadala ng impormasyon nang mas mabilis kaysa sa liwanag? Sa lahat ng paraan, patuloy na magtanong at sumuri sa mga siyentipikong panuntunan, ngunit sa kasamaang palad hindi nito papayagan tayong magpadala ng impormasyon nang mas mabilis kaysa sa liwanag, sa mga dahilang magiging malinaw sa buong takbo ng module na ito. Spoiler: kamangha-mangha, hindi ito dahil sa bilis ng pagpapalaganap ng collapse na ito, na tila nangyayari nang mas mabilis kaysa sa liwanag [1]. Nagsisimula tayo sa dalawang katuwang na Alice at Bob, na una ay nasa parehong lokasyon at maaaring magtulungan sa parehong mga qubit. Ang mga katuwang na ito ay mag-eentangle ng kanilang mga qubit. Pagkatapos ay lilipat sila sa dalawang magkaibang heograpikong lokasyon, dala ang kani-kanilang mga qubit. Pagkatapos ay makakakuha si Alice ng quantum information sa isang bagong qubit Q. Walang mga pagpapalagay tayo tungkol sa impormasyon sa Q. Ang estado ng Q ay maaaring isang lihim na hindi alam ni Alice; maaari itong hindi alam ng lahat ng tao. Ngunit ibinibigay kay Alice ang gawain na ilipat ang impormasyon sa Q patungo kay Bob. Gagawin niya ito gamit ang quantum teleportation.

Upang magawa ito, kailangan nating malaman ang ilang mga quantum na operasyon o "gate".

Mga quantum operator (gate)

Huwag mag-atubiling laktawan ang seksyong ito kung pamilyar ka na sa mga quantum gate. Kung gusto mong mas maunawaan ang mga gate na ito, tingnan ang Basics of quantum information, lalo na ang unang dalawang aralin, sa IBM Quantum Learning.

Para sa teleportation protocol na ito, pangunahin tayong gagamit ng dalawang uri ng quantum gate: ang Hadamard gate at ang CNOT gate. Ilang iba pa ang gagampan ng mas maliit na papel: ang $X$ gate, $Z$ gate, at ang SWAP gate.

Ang module na ito ay maaaring makumpleto nang may napaka-limitadong linear algebra na background, ngunit kung minsan ang pag-visualize ng mga quantum mechanical gate gamit ang mga matrix at vector ay maaaring makatulong. Kaya ipinipresenta namin dito ang mga matrix/vector na anyo ng mga quantum gate/estado, din.

Ang mga estado na ipinakita na namin ay pinili (bahagya sa pamamagitan ng kombensyon at bahagya sa pamamagitan ng mga limitasyon) upang magkaroon ng mga anyo ng vector:

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

Sa ganitong paraan, ang isang arbitrary na estado na $|\psi\rangle = a|0\rangle+b|1\rangle$ ay maaaring isulat bilang

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

Mayroong ilang pagpipilian kung paano palawigin ang notasyon sa mga multi-qubit na estado, ngunit ang pagpipilian sa ibaba ay medyo karaniwang ginagamit:

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

Sa pagpipiliang ito ng vector notation, maaari na nating ipakilala ang aming mga kinakailangang quantum gate, ang kanilang mga epekto sa mga quantum state, at ang kanilang mga anyo ng matrix.

H Hadamard Gate: Lumilikha ng isang superposisyon na estado. Single-qubit gate.

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

Ang isang Circuit na may Hadamard gate ay ginagawa tulad ng sumusunod:

from qiskit import QuantumCircuit

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

CNOT Controlled-NOT Gate: Ang gate na ito ay gumagamit ng dalawang qubit: isang control at isang target. Sinusuri ang estado ng isang control qubit na hindi nababago. Ngunit kung ang control qubit ay nasa estado ng $|1\rangle$, binabago ng gate ang estado ng target qubit; kung ang estado ng control qubit ay $|0\rangle$ walang pagbabagong ginagawa. Sa notasyong nasa ibaba, ipagpalagay na ang qubit na $A$ (pinaka-kanang qubit) ay ang control, at ang qubit na $B$ (pinaka-kaliwang qubit) ay ang target. Sa ibaba, ang notasyong ginamit ay $CNOT(q_{control},q_{target})|BA\rangle.$

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

Kung minsan ay makikita mo ang CNOT na nakasulat nang may ipinahiwatig lamang na pagkakasunod-sunod ng control at target. Ngunit walang ganitong kalabuan sa code o sa mga diagram ng Circuit.

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

Ang isang CNOT gate ay medyo magkaiba ang hitsura sa isang Circuit, dahil nangangailangan ito ng dalawang qubit. Ganito ito ipinapatupad:

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

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, isipin ang iyong sagot, pagkatapos ay i-click ang tatsulok upang ipakita ang solusyon.

Karamihan sa mga gate ay may parehong anyo ng matrix sa Qiskit tulad ng sa lahat ng dako. Ngunit ang CNOT gate ay kumikilos sa dalawang qubit, at biglang nagiging isyu ang mga kombensyon ng pag-order ng mga qubit. Ang mga teksto na nag-oorder ng mga qubit bilang $|q_0,q_1,...\rangle$ ay magpapakita ng ibang anyo ng matrix para sa kanilang mga CNOT gate. I-verify sa pamamagitan ng tahasang matrix multiplication na ang CNOT matrix sa itaas ay may tamang aksyon sa estado na $|01\rangle.$

Sagot:

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

$X$ Gate: Katumbas ng isang operasyong NOT. Single-qubit gate.

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

Sa Qiskit, ang paggawa ng Circuit na may $X$ gate ay ganito ang hitsura:

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

$Z$ Gate: Nagdaragdag ng "phase" sa isang estado (isang prefactor, na sa mga kaso ng Z eigenstates na $|0\rangle$ at $|1\rangle$ ay alinman sa 1, o -1, ayon sa pagkakasunod). Single-qubit gate.

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

Sa Qiskit, ang paggawa ng Circuit na may $Z$ gate ay ganito ang hitsura:

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

Teorya

Ilahad natin ang protocol para sa quantum teleportation gamit ang matematika. Pagkatapos, sa susunod na seksyon, ipapatupad natin ang setup na ito gamit ang isang quantum computer.

Ni-entangle ng Alice at Bob ang kanilang mga qubit: Sa simula, ang qubit ni Alice at ang qubit ni Bob ay magkahiwalay, bawat isa ay nasa estado ng $|0\rangle$ (isang magandang pagpapalagay at pati na rin ang tamang initialization para sa mga IBM® quantum computer). Maaari nating isulat ito bilang $|0\rangle_B|0\rangle_A$ o simpleng $|00\rangle$. Kalkulahin natin kung ano ang mangyayari kapag si Alice at Bob ay kumikilos sa pamamagitan ng Hadamard gate sa qubit ni Alice, at pagkatapos ay isang CNOT gate na may qubit ni Alice bilang control at kay Bob bilang target:

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

Pansinin na ngayon ang mga qubit ni Alice at Bob ay entangled na. Kahit hindi pa natutukoy ng kalikasan kung ang parehong kanilang mga qubit ay nasa estado ng $|0\rangle$ o $|1\rangle$, alam na ang mga qubit nila ay nasa parehong estado. Naghiwalay ang Alice at Bob: Inilipat ng dalawang kaibigan ang kanilang mga qubit sa mga bagong lokasyon, posibleng napakalayo sa isa't isa. Ito ay may maraming mga caveat: hindi madaling ilipat ang quantum information nang hindi ito naaabala. Ngunit maaari itong ilipat, at talagang ilipat mo ito sa module na ito. Ngunit isaalang-alang bilang isang caveat na inaasahan nating makakatagpo ng ilang mga error kapag inilipat natin ang quantum information nang maraming beses.

Ipinakilala ang Q: Ang lihim na estado ay inihanda sa qubit Q:

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

Sa puntong ito, ang Q ay simpleng katabi ng qubit ni Alice (A). Walang entanglement na naganap, kaya ang quantum state ng tatlong qubit nang magkasama ay maaaring isulat bilang:

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

Ang layunin ay ilipat ang impormasyon sa Q mula sa lokasyon ni Alice patungo sa lokasyon ni Bob. Sa puntong ito, wala tayong mga pahayag o kinakailangan tungkol sa segretong o bilis ng paglipat ng impormasyon. Tinutuklas lamang natin kung paano maaaring lumipat ang impormasyon mula kay Alice patungo kay Bob. Dahil ang impormasyon ay nagsisimula sa Q, ipagpalagay natin na ang Q ay itinalaga sa pinakamababang numero sa mga numero ng qubit, upang ang little endian notation ay magtulot sa Q na maging pinakakanang qubit sa matematika sa ibaba.

Ni-entangle ng Alice ang mga qubit A at Q: Ngayon ay kumikilos si Alice gamit ang isang CNOT gate na ang sarili niyang qubit bilang control at Q bilang target, pagkatapos ay nag-aapply ng Hadamard gate sa Q. Kalkulahin natin ang three-qubit state pagkatapos ng operasyong iyon:

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

Dahil ang A at Q ay nasa parehong lokasyon, ipaggrupo natin ang mga termino sa itaas ayon sa mga resulta ng mga sukat sa mga qubit A at Q:

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

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, isipin ang iyong sagot, pagkatapos ay i-click ang tatsulok upang ipakita ang solusyon.

Batay sa ekspresyon sa itaas para sa mga estado ng lahat ng tatlong qubit, ano ang posibilidad na ang isang sukat ng mga qubit A at Q ay magbubunga ng $|0\rangle_A|0\rangle_Q?$

Sagot:

25%. Upang makita ito, alalahanin na ang estado ni Bob ay dapat na ma-normalize, kaya $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Ngayon, maaaring sukatin ni Alice ang mga qubit A at Q. Hindi niya makokontrol ang resulta ng sukat na iyon, dahil ang mga quantum na sukat ay probabilistiko. Kaya kapag sinukat niya, mayroong 4 na posibleng resulta at ang lahat ng 4 ay pantay-pantay na posible: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q,$ at $|1\rangle_A|1\rangle_Q.$ Pansinin na ang bawat resulta ay may iba't ibang implikasyon para sa qubit ni Bob. Halimbawa, kung makita ni Alice ang kanyang mga qubit na nasa $|0\rangle_A|0\rangle_Q,$ na nag-collapse sa buong, 3-qubit na quantum state sa $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Ang iba pang mga resulta ng sukat para kay Alice ay nagbubunga ng iba't ibang estado para kay Bob. Ang mga ito ay pinagsama sa talahanayan sa ibaba.

Resulta ni Alice	Estado ni Bob	Tagubilin kay Bob	Resulta
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Wala	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ tapos $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Para sa lahat ng posibleng resulta ng sukat sa mga qubit ni Alice, ang qubit ni Bob ay naiwan sa isang estado na malabong kahawig ng lihim na estado na orihinal na nasa Q. Sa kaso kung saan sinukat ni Alice ang $	0\rangle_C	0\rangle_A$(ang unang hanay ng talahanayan), ang qubit ni Bob ay naiwan nang eksakto sa lihim na estado! Sa ibang mga kaso, may may mali sa estado. Ang mga koepesyente ($\alpha$) ay napalitan, o mayroon "−" na tanda kung saan dapat mayroong "+" na tanda, o pareho. Upang baguhin ang qubit ni Bob upang maging eksaktong katumbas ng lihim na estado, si Alice ay dapat tumawag kay Bob (gumamit ng ilang paraan ng klasikal na komunikasyon) at sabihin kay Bob na magsagawa ng karagdagang mga operasyon sa kanyang qubit, tulad ng nakabalangkas sa talahanayan. Halimbawa, sa ikatlong hanay ang mga koepesyente ay napalitan. Kung tatawag si Alice kay Bob at sasabihing mag-apply ng$X$gate sa kanyang qubit, binabago nito ang$	0\rangle$sa$

Dapat na malinaw na ngayon kung bakit hindi natin magagamit ang setup na ito upang magpadala ng impormasyon nang mas mabilis kaysa sa liwanag. Maaaring mapalad tayo at masukat ang $|0\rangle_A|0\rangle_Q,$ na nangangahulugang si Bob ay mayroon nang eksaktong lihim na estado, agad. Ngunit hindi alam ni Bob iyon hanggang sa tatawagin natin siya at sasabihin sa kanya na "Sinukat namin ang $|0\rangle_A|0\rangle_Q$, kaya wala kang kailangang gawin."

Sa thought experiment, ang mga qubit ay madalas na pisikal na pinaghihiwalay at dinadala sa isang bagong lokasyon. Ang mga IBM® quantum computer ay gumagamit ng solid-state na mga qubit sa isang chip na hindi maaaring paghiwalayin. Kaya sa halip na ilipat ang Alice at Bob sa iba't ibang lokasyon, ihihiwalay natin ang impormasyon sa chip mismo sa pamamagitan ng paggamit ng mga tinatawag na "swap gate" upang ilipat ang impormasyon mula sa isang qubit patungo sa isa pa.

Eksperimento 1: Basic na teleportasyon

Inirerekomenda ng IBM Quantum ang pagtugon sa mga problema sa quantum computing gamit ang isang balangkas na tinatawag naming "Qiskit patterns". Ito ay binubuo ng mga sumusunod na hakbang.

• Hakbang 1: I-map ang iyong problema sa isang quantum circuit
• Hakbang 2: I-optimize ang iyong circuit para sa pagpapatakbo sa tunay na quantum hardware
• Hakbang 3: Isagawa ang iyong trabaho sa mga IBM quantum computer gamit ang Runtime Primitives
• Hakbang 4: I-post-process ang mga resulta

Hakbang 1: I-map ang iyong problema sa isang quantum circuit

Lahat ng matematika na ginawa natin sa itaas ay nagbabalangkas ng hakbang 1. Ipapatupad natin ito ngayon, binubuo ang ating quantum circuit gamit ang Qiskit! Magsisimula tayo sa paglikha ng quantum circuit na may tatlong qubit, at pag-entangle ng dalawang qubit ni Alice at Bob. Kukunin natin ang mga ito bilang qubit 1 at 2, at ireserba ang qubit 0 para sa secret state.

# Step 1: Map your problem to a quantum circuit

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

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

cr = ClassicalRegister(3, "c")

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

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

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

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

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

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

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

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

qc.draw(output="mpl")

Iyon na ang lahat ng kailangan nating gawin para ma-teleport ang state ni Alice papunta kay Bob. Gayunpaman, alalahanin na kapag sinusukat natin ang isang quantum state na $\alpha_0 |0\rangle+\alpha_1|1\rangle$ makikita natin ang alinman sa $|0\rangle$ o $|1\rangle.$ Kaya sa katapusan ng lahat ng ito, tiyak na nasa Bob na ang secret state ni Alice, ngunit hindi natin ito madaling ma-verify gamit ang isang pagsukat. Para masabi ng isang pagsukat na nagawa nating tama ito, kailangan nating gumawa ng isang trick. Mayroon tayong operator na may label na "U" para sa "unitary" na ginamit natin upang ihanda ang secret state ni Alice. Maaari nating ilapat ang inverse ng U sa katapusan ng ating circuit. Kung ang U ay nag-map ng $|0\rangle$ state ni Alice sa $\alpha_0 |0\rangle+\alpha_1|1\rangle$, ang inverse ng U ang mag-ma-map ng $\alpha_0 |0\rangle+\alpha_1|1\rangle$ ni Bob pabalik sa $|0\rangle.$ Kaya ang huling bahaging ito ay hindi kinakailangang gawin kung ang layunin ay ilipat lang ang quantum information. Ito ay ginagawa natin para masuri ang ating sarili.

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

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

qc.draw(output="mpl")

Kaya kung nagawa natin ito nang tama, ang ating pagsukat sa qubit ni Bob ay dapat magbunga ng $|0\rangle$ state. Siyempre, ang mga pagsukat na ito ay probabilistiko. Kaya kung mayroon mang maliit na pagkakataon na sukatin ang qubit ni Bob na nasa $|1\rangle$ state, isang pagsukat lang ay maaaring magreresulta sa $|1\rangle.$ Gusto nating gumawa ng maraming pagsukat upang masiguro na ang probabilidad ng $|0\rangle$ ay medyo mataas.

Hakbang 2: I-optimize ang problema para sa quantum na pagpapatupad

Kinukuha ng hakbang na ito ang mga operasyon na gusto nating isagawa at ipinapahayag ang mga ito sa mga termino ng functionality ng isang partikular na quantum computer. Ini-map din nito ang ating problema sa layout ng quantum computer.

Magsisimula tayo sa pag-load ng ilang package na kinakailangan para makipag-communicate sa mga IBM quantum computer. Kailangan din nating pumili ng backend kung saan tatakbo. Maaari tayong pumili ng pinaka-hindi abalang backend, o pumili ng isang partikular na backend na alam natin ang mga katangian.

May code sa ibaba para sa pag-save ng iyong mga kredensyal sa unang paggamit. Tiyaking tanggalin ang impormasyong ito mula sa notebook pagkatapos itong i-save sa iyong environment, upang ang iyong mga kredensyal ay hindi aksidenteng ibahagi kapag ibinabahagi mo ang notebook. Tingnan ang I-set up ang iyong IBM Cloud account at I-initialize ang serbisyo sa isang hindi pinagkakatiwalaang environment para sa karagdagang gabay.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

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

# Load saved credentials
service = QiskitRuntimeService()

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

ibm_sherbrooke

Tahasang pinapagana natin ang lohika sa mga pagsukat.

from qiskit.circuit import IfElseOp

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

Ngayon kailangan nating "i-transpile" ang quantum circuit. Kasama dito ang maraming sub-hakbang at isa itong kahanga-hangang paksa. Bilang halimbawa lamang ng isang sub-hakbang: hindi lahat ng quantum computer ay direktang maaaring mag-implement ng lahat ng logical na gate sa Qiskit. Kailangan nating isulat ang mga gate mula sa ating circuit sa mga termino ng mga gate na kayang i-implement ng quantum computer. Maaari tayong magsagawa ng prosesong iyon, at iba pa, gamit ang isang preset pass manager. Ang pagtatakda ng optimization = 3 (ang pinakamataas na antas ng optimization) ay tinitiyak na ang mapping mula sa ating abstract na quantum circuit patungong mga instruksyon na ibinibigay sa quantum computer ay kasingdepekto ng kaya ng ating pre-processing.

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

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

Ang "Sampler" ay isang primitive na idinisenyo upang mag-sample ng mga posibleng estado na nagmumula sa isang quantum circuit, at mag-kolekta ng istatistika tungkol sa kung anong mga estado ang maaaring sukatin at sa anong probabilidad. Ini-import natin dito ang Qiskit Runtime Sampler:

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

sampler = Sampler(mode=backend)

Hindi lahat ng computations sa isang quantum computer ay makatuwirang maisimula sa mga classical computer. Ang simpleng teleportasyong ito ay tiyak na maisimula, ngunit hindi ito kabulaanan na maaari nating classical na i-save ang impormasyon sa isang lugar o iba pa. Mariing inirerekomenda naming isagawa ang mga kalkulasyong ito gamit ang isang tunay na IBM quantum computer. Ngunit kung naagahan mo na ang iyong libreng buwanang paggamit, o kung ang isang bagay ay kailangang tapusin sa klase at hindi maaaring maghintay sa pila, ang module na ito ay maaaring makumpleto gamit ang isang simulator. Upang gawin ito, patakbuhin lang ang cell sa ibaba at i-uncomment ang mga kaugnay na linya sa mga hakbang na "Execute".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

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

noise_model = NoiseModel.from_backend(backend)

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

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

Hakbang 3: Isagawa

Gamitin ang sampler upang patakbuhin ang iyong trabaho, na may circuit bilang argumento.

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

Hakbang 4: Post-processing at pagsusuri

I-plot natin ang mga resulta at bigyang-kahulugan ang mga ito.

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

plot_histogram(counts)

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, pag-isipan ang iyong sagot, pagkatapos ay i-click ang tatsulok upang makita ang solusyon.

Alin sa mga estado sa itaas ang nagpapahiwatig ng matagumpay na teleportasyon, at paano mo malalaman?

Sagot:

Ang mga estado na $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ ay lahat ay naaayon sa matagumpay na teleportasyon. Ito ay dahil nagdagdag tayo ng gate upang i-undo ang paunang paghahanda ng secret state. Kung ang secret state ay matagumpay na na-teleport sa qubit ni Bob, ang karagdagang gate na iyon ay dapat ibalik ang qubit ni Bob sa $|0\rangle$ state. Kaya ang anumang estado sa itaas na may qubit ni Bob (qubit 0, sinusukat din sa ika-0 na sangkap ng classical register, at samakatuwid ang pinakamataas/kanan) na nasa $|0\rangle$ state ay nagpapahiwatig ng tagumpay.

Ipinapakita ng plot na ito ang lahat ng resulta ng pagsukat para sa tatlong qubit, sa loob ng 5,000 pagsubok o "shots". Itinuro natin kanina na susukat si Alice ng lahat ng posibleng estado para sa mga qubit A at Q nang may pantay na posibilidad. Itinalaga natin ang mga qubit 0–2 sa circuit sa Q, A, at B, ayon sa pagkakasunod. Sa little-endian notation, ang qubit ni Bob ang pinakakaliwang/pinakamababa. Kaya ang apat na bar sa kaliwa ay tumutugma sa qubit ni Bob na nasa $|0\rangle$, at ang dalawang iba pang qubit na nasa lahat ng posibleng kombinasyon nang may halos pantay na probabilidad. Tandaan na halos lahat (kadalasan ay ~95%) ng mga pagsukat ay nagbubunga ng qubit ni Bob sa $|0\rangle$ state, ibig sabihin matagumpay ang ating setup! Mayroong iilang shots (~5%) na nagbunga ng qubit ni Bob sa $|1\rangle$ state. Hindi ito lohikal na posible. Gayunpaman, lahat ng modernong quantum computer ay nagdurusa mula sa ingay at mga error sa mas malaking lawak kaysa sa mga classical computer. At ang quantum error correction ay isang umuusbong pa ring larangan.

Eksperimento 2: Pag-teleport sa buong processor

Maaaring sabihing ang pinaka-kawili-wiling bahagi ng quantum teleportation ay ang isang quantum state ay maaaring ma-teleport sa malalayong distansya nang mabilis (bagama't ang classical na komunikasyon ng mga karagdagang gate ay hindi mabilis). Tulad ng nasabi na natin, hindi natin maaaring hatiin ang mga qubit mula sa processor at ilipat ang mga ito. Ngunit maaari nating ilipat ang impormasyon mula sa isang qubit patungo sa isa pa, hanggang ang mga qubit na kasangkot sa teleportasyon ay nasa magkabilang dulo ng processor. Ulitin natin ang mga hakbang na ginawa natin sa itaas, ngunit ngayon gagawa tayo ng mas malaking circuit na may sapat na qubit upang masaklaw ang processor.

Hakbang 1: I-map ang iyong problema sa isang quantum circuit

Sa pagkakataong ito, magbabago ang mga qubit na tumutugma kina Alice at Bob. Kaya hindi na namin magpapalitan ng pangalan sa isang qubit na "A" at isa pa bilang "B". Sa halip, bibilangan natin ang mga qubit at gagamit ng mga variable upang kumatawan sa kasalukuyang posisyon ng impormasyon sa mga qubit na pag-aari nina Alice at Bob. Lahat ng iba pang hakbang maliban sa mga swap gate ay tulad ng inilarawan kanina.

# Step 1: Map

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

qc = QuantumCircuit(qr, cr)

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

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

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

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

qc.barrier()

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

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

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

qc.barrier()

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

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

qc.barrier()

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

qc.draw("mpl")

Makikita mo sa circuit diagram na ang mga lohikal na hakbang ay pareho. Ang tanging pagkakaiba ay ginamit namin ang mga swap gate upang dalhin ang state ng qubit ni Alice mula sa qubit 6 ($A_5$) pataas hanggang sa qubit 1 ($A_0$), katabi ng Q. At ginamit namin ang mga swap gate upang dalhin ang paunang estado ni Bob mula sa qubit 7 ($B_0$) pababa hanggang sa qubit 12 ($B_5$). Tandaan na ang estado sa qubit 12 ay hindi pa kahit kaugnay sa secret state ng Q hanggang ang mga pagsukat ay ginawa sa malalayong qubit 0 at 1, at ang estado sa qubit 12 ay hindi katumbas ng secret state hanggang pagkatapos na mailapat ang mga conditional na $X$ at $Z$ gate.

Hakbang 2: I-optimize ang iyong circuit

Karaniwan, kapag ginamit natin ang pass manager upang i-transpile at i-optimize ang ating mga circuit, makatuwiran na itakda ang optimization_level = 3, dahil gusto nating maging kasingdepekto ng posible ang ating mga circuit. Sa kasong ito, walang computational na dahilan para sa atin na ilipat ang mga estado mula sa mga qubit 6 at 7 patungo sa mga qubit 1 at 12. Iyon ay isang bagay lamang na ginawa natin upang ipakita ang teleportasyon sa isang distansya. Kung hihilingin natin sa pass manager na i-optimize ang ating circuit, malalaman nito na walang lohikal na dahilan para sa mga swap gate na ito, at aalisin ang mga ito at isasagawa ang mga operasyon ng gate sa mga katabing qubit. Kaya para sa espesyal na kasong ito, ginagamit natin ang optimization_level = 0.

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

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

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Maaari nating i-visualize kung saan sa quantum processor matatagpuan ang mga qubit na ito gamit ang function na plot_circuit_layout.

Hakbang 3: Isagawa

Tulad ng dati, inirerekomenda naming tumakbo sa tunay na mga IBM quantum computer. Kung naabot na ang iyong buwanang libreng paggamit, huwag mag-atubiling i-uncomment ang mga simulator cell upang tumakbo sa isang simulator.

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

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Hakbang 4: Classical post-processing

Muli naming makikita na ang mga probabilidad para sa mga posibleng resulta ng mga qubit ni Alice ay medyo pantay-pantay. May malakas na kagustuhan para mahanap ang qubit ni Bob sa $|0\rangle$ pagkatapos i-invert ang secret code, ibig sabihin ay may mataas na probabilidad na tama tayong na-teleport ang secret state sa buong processor mula Q patungong Bob (mga qubit 0 hanggang 12). Gayunpaman, napapansin natin na mayroon na ngayong mas mataas na pagkakataon ng hindi pagsukat ng $|0\rangle$ para kay Bob. Ito ay isang mahalagang aral sa quantum computing: habang mas marami kang gate, lalo na ang mga multi-qubit gate tulad ng mga swap gate, mas maraming ingay at mga error ang mararanasan mo.

Mga Tanong

Ang mga tagapagturo ay maaaring humiling ng mga bersyon ng mga notebook na ito na may mga susi ng sagot at gabay sa paglalagay sa mga karaniwang kurikulum sa pamamagitan ng pagsagot sa maikling survey tungkol sa kung paano ginagamit ang mga notebook.

Mga kritikal na konsepto

• Ang mga qubit ay maaaring ma-entangle, ibig sabihin ang pagsukat ng isang qubit ay nakaka-apekto o kahit natutukoy ang estado ng isa pang, entangled na qubit.
• Ang entanglement ay naiiba sa mga simpleng classical na correlation; halimbawa, ang mga qubit A at B ay maaaring nasa superposition ng mga estado tulad ng $\alpha_0|00\rangle+\alpha_1|11\rangle.$ Ang estado ng A o B ay maaaring hindi pa natutukoy ng kalikasan, at gayon pa man ang A at B ay maaari pa ring garantisadong nasa parehong estado.
• Sa pamamagitan ng kombinasyon ng mga entanglement at pagsukat, maaari tayong maglipat ng estado (na maaaring mag-imbak ng impormasyon) mula sa isang qubit patungo sa isa pa. Ang paglipat na ito ay maaari pang gawin sa malalayong distansya, at ito ang tinatawag na quantum teleportation.
• Ang quantum teleportation ay umaasa sa mga quantum na pagsukat, na probabilistiko. Kaya, ang classical na komunikasyon ay maaaring kailanganin upang i-tweak ang mga na-teleport na estado. Pinipigilan nito ang quantum teleportation mula sa pagpapalipat ng impormasyon nang mas mabilis kaysa sa liwanag. Ang quantum teleportation ay hindi lumalabag sa relativity o causality.
• Ang mga modernong quantum computer ay mas madaling kapitan ng ingay at mga error kaysa sa mga classical computer. Asahan ang iilang porsyento ng error.
• Habang mas maraming gate ang idinagdag mo sa pagkakasunod-sunod (lalo na ang mga 2-qubit gate) mas maraming mga error at ingay ang maaasahan mo.

Mga Tanong na Tama/Mali

1. T/M Ang quantum teleportation ay maaaring gamitin upang magpadala ng impormasyon nang mas mabilis kaysa sa liwanag.
2. T/M Ang modernong katibayan ay nagmumungkahi na ang pagguho ng isang quantum state ay kumakalat nang mas mabilis kaysa sa liwanag.
3. T/M Sa Qiskit, ang mga qubit ay inayos sa mga estado nang may pinakamababang bilang na qubit sa kanan, tulad ng sa $|q_3,q_2,q_1, q_0\rangle$

Mga Tanong na Pagpili

1. Ang mga qubit A at B ay na-entangle, pagkatapos ay pinagsamantala ng isang malaking distansya $d$. Sinusukat ang qubit A. Alin sa mga pahayag ang tama tungkol sa bilis kung saan naapektuhan ang estado ng qubit B?

• a. Ang qubit B ay apektado nang mabilis, sa loob ng experimental na tolerance, sa mga eksperimentong naisagawa na.
• b. Ang qubit B ay apektado pagkatapos ng panahon na $d/c$, ibig sabihin ang quantum state ay "gumuguho" nang humigit-kumulang sa bilis ng liwanag, sa loob ng experimental na tolerance.
• c. Ang qubit B ay apektado lamang pagkatapos mangyari ang classical na komunikasyon, ibig sabihin nangyayari ito sa panahon na mas mahaba kaysa sa $d/c$.
• d. Wala sa mga nabanggit

2. Alalahanin na ang probabilidad ng pagsukat ay nauugnay sa mga amplitude sa mga quantum state. Halimbawa, kung ang isang qubit ay paunang nasa estado na $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ ang probabilidad ng pagsukat ng estado $|0\rangle$ ay $|\alpha_0|^2.$ Hindi lahat ng mga hanay ng pagsukat ay eksaktong tutugma sa mga probabilidad na ito, dahil sa limitadong sampling (tulad ng pagtatapon ng barya ay maaaring magbunga ng dalawang magkakasunod na ulo). Ang measurement histogram sa ibaba ay maaaring tumugma sa alin sa mga sumusunod na quantum state? Piliin ang pinakamainam na opsyon.

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

3. Alin sa mga sumusunod na estado ang nagpapakita ng mga qubit A at B na na-entangle? Piliin ang lahat ng naaangkop.

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

4. Sa module na ito, naghanda tayo ng entangled na estado: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Ngunit marami pang ibang entangled na estado ang maaaring gamitin para sa katulad na protocol. Alin sa mga estado sa ibaba ang maaaring magbunga ng 2-qubit measurement histogram tulad ng sumusunod? Piliin ang pinakamainam na sagot.

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

Mga Tanong para sa Talakayan

1. Ilarawan ang quantum teleportation protocol, mula simula hanggang katapusan, sa iyong kasama/grupo. Tingnan kung mayroon silang idadagdag, o kung mayroon silang mga katanungan.

2. Mayroon bang anumang natatangi sa paunang entangled na estado sa pagitan nina Alice at Bob: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Kung gayon, ano ang natatangi dito? Kung hindi, anong iba pang entangled na estado ang maaari sana nating ginamit?