Quantum key distribution

Para sa modyul na ito ng Qiskit in Classrooms, kailangang magkaroon ang mga estudyante ng gumaganang Python environment na may mga sumusunod na package na naka-install:

• 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 Install Qiskit. Upang makapagpatakbo ng mga trabaho sa tunay na mga quantum computer, kailangang mag-set up ng account ang mga estudyante sa IBM Quantum® sa pamamagitan ng pagsunod sa mga hakbang sa gabay na Set up your IBM Cloud account.

Ang modyul na ito ay nasubok at gumamit ng 5 segundo ng QPU time. Pagtatantya lamang ito. Maaaring mag-iba ang iyong aktwal na paggamit.

# 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 walkthrough ng modyul ni Dr. Katie McCormick sa ibaba, o mag-click dito para mapanood ito sa YouTube.

---

Panimula at motibasyon

Mayroon nang walang katapusang mga paraan para i-encrypt at i-decrypt ang impormasyon, at libu-libong paraan ang lubos na pag-aralan na. Dito, limitahan natin ang ating sarili sa isang napakaagang at napakasimpleng paraan ng encryption, na tinatawag na "simpleng pagpapalit" (simple replacement), upang makapag-focus sa quantum na bahagi ng protocol na ito. Ang quantum na bahagi ay maaaring i-adapt sa maraming iba pang protocol nang may medyo kaunting pagbabago.

Simpleng pagpapalit

Ang simpleng pagpapalit na encryption ay isa kung saan ang isang titik o numero ay pinapalitan ng isa pa, sa paraang mayroon nang 1:1 na pagmamapa mula sa mga titik at numero sa isang mensahe, patungo sa mga titik at numero na ginagamit sa isang naka-encrypt na pagkakasunud-sunod. Ang isang halimbawa nito sa pop culture ay ang cryptoquote o cryptogram puzzle, kung saan ang isang sipi o parirala ay ine-encrypt gamit ang simpleng pagpapalit, at ang manlalaro ay kailangang i-decrypt ito. Madaling malutas ang mga ito kung sapat ang haba nila. Isaalang-alang ang halimbawang ito:

R WVXRWVW GSZG R'W YVGGVI NZPV GSRH KIVGGB OLMT. GSZG DZB, KVLKOV DROO SZEV ZM VZHRVI GRNV HLOERMT RG. R SLKV R NZWV RG HRNKOV VMLFTS.

Karamihan sa mga taong naglulutas ng mga ito nang kamay ay gumagamit ng mga tricks na may kinalaman sa pamilyaridad sa istruktura ng wika ng orihinal na mensahe. Halimbawa, sa Ingles, ang mga salitang isang titik lamang tulad ng naka-encrypt na "R" ay "a" at "I" lamang. Ang mga doble titik na naka-encrypt sa, halimbawa, ang "KIVGGB" ay maaaring kumuha lamang ng ilang mga halaga. May mas banayad na mga bagay na nagbibigay ng pahiwatig tulad ng ang pinakakaraniwang salitang akma sa pattern na "GSZG" ay "that". Ang mga taong gumagamit ng code para malutas nito ay may mas maraming pagpipilian, kabilang ang simpleng pag-scan sa mga posibilidad hanggang mabawi ang isang salitang Ingles, at pag-update habang pinapanatili ang salitang iyon. Ang isang simpleng ngunit makapangyarihang paraan ay ang paggamit ng dalas ng titik, lalo na kapag ang mensahe ay sapat na haba upang maging representatibong sampol ng Ingles.

Tanong para sa pagsusuri

Subukan mong i-decrypt ito kung gusto mo, bagaman hindi ito kinakailangan para sa natitirang bahagi ng modyul. I-click ang tuldik sa ibaba para makita ang mensahe.

Sagot:

I decided that I'd better make this pretty long. That way, people will have an easier time solving it. I hope I made it simple enough.

Ang halimbawa sa itaas ay may kasamang "key", isang pagmamapa mula sa naka-encrypt patungo sa mga na-decrypt na titik. Sa kasong ito, ang key ay:

• A (hindi ginamit, tawagin nating Z)
• B->Y
• C (hindi ginamit, tawagin nating X)
• D->W
• E->V
• F->U
• ...

At iba pa. Hindi ito magandang key, sa mahinahon na pagsasalita. Ang mga key kung saan ang mga naka-encrypt at na-decrypt na titik ay mga bersyong inilipat lamang ng alpabeto (tulad ng A->B at B->C) ay tinatawag na "Caesar shift" ciphers.

Pansinin na ang mga ito ay napakahirap kung sila ay maikli. Sa katunayan, kung napakaikli nila, sila ay indeterminate. Isaalang-alang:

URYYP

Maraming posibleng decryption, gamit ang iba't ibang key: HELLO, PETTY, HAPPY, JIGGY, STOOL. Makakapagsalita ka ba ng iba pa?

Ngunit kung magpadala ka ng maraming mensahe na ganito, sa huli, mababasag ang encryption. Kaya, hindi dapat madalas gamitin ang parehong "key". Sa katunayan, pinakamabuti kung gagamitin mo ang isang partikular na pagpapalit nang isang beses lamang. Hindi sa isang mensahe lamang, kundi para sa isang solong karakter lamang! Ang ibig sabihin nito ay magkakaroon ka ng scheme o key ng encryption para sa bawat karakter na ginamit sa mensahe, sa pagkakasunud-sunod. Kung gusto mong magpadala ng mensahe sa isang kaibigan gamit ang schemang ito, ikaw at ang iyong kaibigan ay kailangan ng isang piraso ng papel (sa mga nakaraang panahon) kung saan naka-sulat ang palaging nagbabagong key na ito. Gagamitin mo ito nang isang beses lamang. Ito ay tinatawag na "one-time pad".

Ang one-time pad

Tingnan natin kung paano ito gumagana sa isang halimbawa. Maaaring gawin ito nang buo gamit ang mga titik, ngunit karaniwan na i-convert ang mga titik sa mga numero, sabihin, sa pamamagitan ng pagtatalaga ng A=0, B=1, C=2…. Ipagpalagay na tayo ay mga kaibigan na sangkot sa mga clandestine na aktibidad at nagbahagi tayo ng isang pad. Sa isip, magbabahagi tayo ng maraming pad, ngunit ang ngayon ay:

EDGRPOJNCUWQZVMK…

O, na-convert sa mga numero ayon sa posisyon sa alpabeto:

4,3,6,17,15, 14, 9, 13, 2, 20, 22, 16, 25, 21, 12, 10…

Ipagpalagay na gusto kong ibahagi sa iyo ang mensaheng:

"I love quantum!"

O, katumbas:

8, 11, 14, 21, 4, 16, 20, 0, 13, 19, 20, 12

Ayaw naming ipadala ang code sa itaas; ito ay isang simpleng pagpapalit, na hindi talaga ligtas. Gusto naming pagsamahin ito sa aming key sa ilang paraan. Ang isang karaniwang paraan ay ang karagdagan modulo 26. Idadagdag natin ang halaga ng mensahe sa halaga ng key, mod 26, hanggang maabot ang dulo ng mensahe. Kaya, magpapadala tayo ng

8+4 (mod 26) = 12, 11+3 (mod 26) = 14, 14+6 (mod 26) = 20, 21+17 (mod 26) = 12…

= 12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

Pansinin na kung may sumasamsam nito at WALA silang key, ang pag-decrypt nito ay ganap na walang pag-asa! Kahit ang dalawang "u" sa "quantum" ay hindi naka-encode na may parehong numero! Ang una ay isang 3, at ang pangalawa ay isang 16… sa parehong salita!

Kaya, ipadala ko ito sa iyo, at mayroon kang parehong key na mayroon ako. I-undo mo ang karagdagan modulo 26 na alam mong ginawa ko:

12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

=(4+x1) (mod 26), (3+x2) (mod 26), (6+x3) (mod 26), (17+x4) (mod 26),…

Upang ang mensaheng x1, x2, x3, x4… ay dapat maging

8, 11, 14, 21…

Sa huli, pag-convert nito sa teksto, mayroon tayong

"I love quantum".

Ito ang isang one-time pad.

Pansinin na kung ang key ay mas maikli kaysa sa mensahe, magsisimula tayong ulitin ang ating encoding. Magiging mahirap pa rin ang decryption na problemang iyon, ngunit hindi imposible kung inulit ito nang sapat na beses. Kaya, kailangan mo ng mahabang key (o "pad").

tala

Sa maraming konteksto, pamilyar na ang mga estudyante sa encryption na ito, kaya maaaring laktawan ang aktibidad na ito. Ngunit ito ay isang medyo mabilis at simpleng refresher.

Hakbang 1: Kumuha ng kasama, at magbahagi ng isang pagkakasunud-sunod ng 4 na titik upang gamitin bilang key. Anumang angkop na pagkakasunud-sunod ng 4 na titik para sa klase ay gagawin.
Hakbang 2: Pumili ng isang lihim na salitang 4 na titik na gusto mong ipadala sa iyong kasama (parehong kasosyo ang gagawa nito upang magpadala kayo ng iba't ibang lihim na salita sa isa't isa)
Hakbang 3: I-convert ang 4-titik na key/pad at bawat isa sa 4-titik na lihim na salita sa mga numero gamit ang A = 1, B = 2, at iba pa.
Hakbang 4: Pagsamahin ang iyong 4-titik na salita sa one-time pad gamit ang modulo 26 na karagdagan.
Hakbang 5: Ibigay sa iyong kasama ang pagkakasunud-sunod ng mga numero na nag-encode ng iyong lihim na salita, at ibibigay ng iyong kasama sa iyo ang kanila.
Hakbang 6: I-decode ang mga salita ng isa't isa gamit ang modulo 26 na pagbabawas.
Hakbang 7: Suriin. Gumana ba ito?

Mga follow-up na tanong

Palitan ng mga naka-encrypt na salita ang ibang grupo na walang access sa iyong one-time pad. Maaari mo bang i-decrypt ito? Ipaliwanag kung bakit o bakit hindi?

Sana ay malinaw sa aktibidad sa itaas na ang isang one-time pad ay isang hindi mababasag na anyo ng encryption, dahil sa ilang mga pagpapalagay, tulad ng:

• Ang key ay parehong haba ng mensaheng ipinapadala, o mas mahaba
• Ang key ay tunay na random
• Ang key ay ginagamit nang isang beses lamang at pagkatapos ay itatapon

Kaya, napakagaling nito. Mayroon tayong hindi mababasag na encryption... maliban kung may makakakuha ng ating key. Kung may makakakuha ng ating key, ang lahat ay mai-decrypt. Ang pagkakaiba sa pagitan ng hindi mababasag na encryption at ang pagkakalantad ng lahat ng ating mga lihim ay nagpapahalaga sa pagbabahagi ng isang ligtas na key nang labis. Ang layunin ng quantum key distribution ay ang samantalahin ang mga hadlang na ipinataw ng kalikasan sa quantum na impormasyon upang ma-secure ang isang shared key/one-time pad.

Paggamit ng mga quantum state bilang key

Ipagpalagay nating nagtatrabaho tayo gamit ang mga qubit (binibigyang-diin na ang mga qubit ay may dalawang eigenstate). Maaaring gumamit ng quantum systems na may mas mataas na bilang ng mga quantum state, ngunit ang mga pinakabagong quantum computer sa IBM® ay gumagamit ng mga qubit. Walang problema sa pag-encode ng ating A, B, C, sa mga pagkakasunud-sunod ng 0's at 1's. Kaya, sapat na para sa atin na magbahagi ng isang key ng 0's at 1's at gumawa ng karagdagan modulo 2 sa bawat bit na nag-iimbak ng isang titik.

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, isipin ang iyong sagot, at pagkatapos ay i-click ang tatsulok para ihayag ang solusyon.

Kung talagang pinapahalagahan lang natin ang mga titik sa Ingles, ilang bit ang kailangan natin?

Sagot:

$$2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}$$

Ang ating mga kaibigan, si Alice at Bob ay gustong magbahagi ng quantum key sa paraang walang ibang makaka-intercept nito (kahit man ay nang hindi nila malalaman). Kailangan nilang magkaroon ng paraan ng pagpapadala ng mga quantum state sa isa't isa. Ang paggawa nito nang may mataas na fidelity at walang ingay/error ay HINDI trivial. Ngunit may dalawang diskarte na dapat nating maiintindihan sa puntong ito:

1. Ang isang fiber-optic cable ay nagpapahintulot sa iyo na magpadala ng liwanag… na napaka-quantum-mechanical. Ang mga solong photon ay maaaring madetekta nang may mataas na fidelity sa maraming kilometro ng fiber optic cable. Hindi ito isang perpekto, walang error na quantum channel, ngunit maaari itong maging napakagaling.
2. Maaari tayong gumamit ng quantum teleportation, tulad ng inilarawan sa isang nakaraang modyul. Iyon ay, si Alice at Bob ay maaaring magbahagi ng mga entangled qubit at ang isang state ay maaaring ipadala mula kay Alice patungo kay Bob gamit ang teleportation protocol.

Para sa modyul na ito, ayaw naming hilingin sa iyo na magkaroon ng mga high-fidelity na optical setup para sa pagbabahagi ng mga photon, kaya gagamitin natin ang pangalawang paraan para sa pagbabahagi ng mga quantum state. Ngunit hindi ibig sabihin nito na ito ang pinakamakatotohanang paraan para sa mahabang distansiyang pagbabahagi ng mga quantum key.

Ating tuklasin ngayon ang isang protocol na unang inihayag nina Charles Bennett at Gilles Brassard noong 1984 para sa pagbabahagi ng mga state na sinukat sa iba't ibang base mula kay Alice patungo kay Bob. Gagamit tayo ng matalinong measurement regimen para bumuo ng key para gamitin sa susunod na encryption. Sa madaling salita, nagdi-distribute tayo ng quantum key sa pagitan ng dalawang partido na gustong makipag-communicate, kaya "quantum key distribution" (QKD).

QKD hakbang 1: Mga random na bit at random na base ni Alice

Magsisimula si Alice sa pamamagitan ng pagbuo ng random na pagkakasunud-sunod ng 0's at 1's. Pagkatapos, random siyang pipili ng base kung saan ihahanda ang isang quantum state, batay sa bawat random na bit, gamit ang talahanayan sa ibaba (isang talahanayan na mayroon din si Bob):

Basis	bit = 0	bit = 1
Z	$\vert 0\rangle$	$\vert 1\rangle$
X	$\vert +\rangle$	$\vert -\rangle$

Halimbawa, ipagpalagay nating random na bumuo si Alice ng isang 0, at random na pinili ang X basis. Pagkatapos, maghahanda siya ng quantum state na $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Tiyak na maaaring samantalahin ang quantum randomness upang makabuo ng random na set ng 0's at 1's, at random na pagpili ng base. Sa ngayon, ipagpalagay na lang nating nabuo na ang isang random na set, tulad ng sumusunod:

Mga bit ni Alice	0	1	0	0	1	1	0	1	0	...
Mga base ni Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Mga state ni Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...

Ang set ng mga random na bit, base, at mga resultang state na ito ay magpapatuloy sa isang mahabang pagkakasunud-sunod, upang magbigay ng key na sapat na haba.

QKD hakbang 2: Mga random na base ni Bob

Gumagawa rin si Bob ng random na pagpili ng mga base. Gayunpaman, samantalang ginagamit ni Alice ang pagpili ng base upang ihanda ang kanyang state, si Bob naman ay talagang gagawa ng mga sukat sa mga base na ito. Kung si Bob ay gumagawa ng sukat sa parehong base kung saan inihanda ni Alice ang state, maaari nating hulaan ang resulta ng sukat ni Bob. Kapag nangyari na pumili si Bob ng ibang base kaysa sa base na ginamit ni Alice sa paghahanda, hindi natin malalaman ang resulta ng sukat ni Bob.

Mga bit ni Alice	0	1	0	0	1	1	0	1	0	...
Mga base ni Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Mga state ni Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Mga base ni Bob	X	Z	X	Z	X	X	Z	X	X	...
Mga state ni Bob (a priori)	$\vert +\rangle$	?	?	$\vert 0\rangle$	?	$\vert -\rangle$	$\vert 0\rangle$	?	$\vert +\rangle$	...
Mga state ni Bob (nasukat)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Sa talahanayan sa ibaba, isaalang-alang ang unang hanay. Inihanda ni Alice ang state na $\vert +\rangle,$ na isang eigenstate ng X. Dahil random ding pinili ni Bob na sumukat sa X basis, isa lamang ang posibleng resulta para sa nasukat na state ni Bob: $\vert +\rangle.$ Sa ikalawang hanay, gayunpaman, pumili sila ng iba't ibang base. Ang state na ipinadala ni Alice ay $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$ Ito ay may 50% na pagkakataon na masukat ni Bob sa $\vert 0\rangle$ na state, at 50% na pagkakataon na masukat sa $\vert 1\rangle.$ Kaya ang hanay na nagpapakita ng alam natin, a priori, tungkol sa mga sukat ni Bob ay hindi maaaring mapunan para sa ika-2 hanay. Ngunit gagawa si Bob ng sukat at makakakuha ng eigenstate ng (sa kolumna na iyon) Z. Sa ibabang hanay, pinupunan natin kung ano ang maidulot ng mga sukat na ito.

QKD hakbang 3: Pampublikong talakayan ng mga base

Maaari na ngayong ibahagi ni Alice at Bob sa isa't isa kung anong base ang pinili nila sa bawat kaso. Para sa lahat ng hanay kung saan nagkataon silang pumili ng parehong base, bawat isa sa kanila ay tiyak na alam kung anong state ang mayroon ang isa pa. Maaaring i-convert ni Bob ang state at base sa isang 0 o 1 ayon sa kombensyon na ibinabahagi ng dalawang partido. Maaari nating isulat muli ang talahanayan sa itaas upang ipakita lamang ang mga pagkakataon kung saan nagkatugma ang mga base ni Alice at ni Bob:

Mga bit ni Alice	0	0	1	0	0	...
Mga base ni Alice	X	Z	X	Z	X	...
Mga state ni Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga base ni Bob	X	Z	X	Z	X	X
Mga state ni Bob (a priori)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga state ni Bob (nasukat)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga bit ni Bob	0	0	1	0	0	...

Matagumpay na naipadala ni Alice ang bit string na 00100... kay Bob. Kung nagkasundo ang magkaibigan nang maaga na gumamit ng 5-bit strings bilang mga numero sa kanilang one-time pad, ang mga unang limang bit na ito ay magbibigay sa kanila ng numerong $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

QKD hakbang 4: Beripikahin at ipadala ang lihim

Bago pa lumayo si Alice at Bob, dapat silang pumili ng subset ng kanilang mga classical bit para ihambing. Dahil pinanatili lamang nila ang mga sukat ng mga qubit na inihanda at sinukat gamit ang parehong base, lahat ng nasukat na halaga ay dapat magkasundo. Kung may napakaliit na porsyento na hindi magkasundo, maaaring maipaliwanag ito sa pamamagitan ng quantum noise o mga error. Ngunit kung marami ang hindi magkasundo, may nagkamaling!

Dito ay hindi natin tutukuyin kung anong bahagi ng key ang dapat gamitin para sa pag-verify. Sa ngayon, ipagpalagay nating maayos ang pagsusuring ito; babalikan natin ito sa seksyon sa ibaba tungkol sa pag-eavesdrop.

Pagkatapos, magpapadala ang mga kaibigan ng naka-encrypt na mensahe sa isa't isa gamit ang mga classical channel. Gagamitin nila ang mga numero sa kanilang one-time pad para i-encrypt/i-decrypt ang mga lihim na mensahe, nang hindi kailanman inilalabas ang one-time pad mula sa isang lokasyon patungo sa isa pa. Para sa susunod na seksyon tungkol sa pag-eavesdrop, mangyaring tandaan na ang lahat ng pagbabahagi ng key na ito ay nangyayari bago ang paghahayag ng naka-encrypt na lihim sa pamamagitan ng mga classical channel.

Ibinabahagi ni Alice at Bob ang kanilang piniling base sa pamamagitan ng mga classical channel, kaya hindi ba maaaring ma-intercept iyon? Oo! Ngunit ang pagkaalam ng base na ginamit nila para sa sukat ay hindi nagpapabatid ng kung anong bit ang ipinadala o nakuha nila. Posible lamang ito kung alam mo rin ang mga panimulang bit ni Alice. Ngunit noon ay nasa computer ka na ni Alice, kung saan nakaimbak ang mga lihim, at ang lihim na komunikasyon ng mga lihim ay nagiging walang kabuluhan. Kaya ang pagharang ng classical communication ay hindi sinisira ang encryption. Ngunit paano naman ang pagharang ng impormasyon sa quantum channel?

Katatagan ng QKD laban sa pag-eavesdrop

Si Alice at Bob ay may kaibigan si Eve, na kilala sa pag-eavesdrop. Nais ni Eve na harangin ang quantum key nina Alice at Bob, upang magamit niya ito para i-decrypt ang mga mensaheng ipinapadala sa pagitan ng dalawa. Ito ay kinakailangang mangyayari sa pagitan ng paghahanda ni Alice ng mga state at ng sukat ni Bob sa mga state, dahil ang sukat ay nagbabagsak ng quantum state. Sa partikular, nangangahulugan ito na ang pag-eavesdrop ay kailangan mangyari bago magkaroon ng anumang pagbabahagi o paghahambing ng mga base.

Kailangan ni Eve na hulaan kung anong base ang ginamit sa pag-encode ng bawat bit. Muli, kung hindi siya makaka-access sa computer ni Alice, wala siyang basehan para sa hula na ito, at ito ay magiging random. Ipagpalagay nating pareho ang simula ni Alice tulad ng dati, at ipagpalagay pa nating pareho rin ang random na pagpili ng base ng sukat ni Bob tulad ng dati. Punan natin kung ano ang makukuha ni Eve kung gagawa siya ng mga sukat ng quantum channel. Tulad ng dati, kung nagkataon na pumili si Eve ng parehong base tulad ni Alice, alam natin kung ano ang makukuha niya. Kung hindi, maaari siyang makakuha ng alinman sa dalawang resulta, bawat isa ay may 50% na probabilidad.

Mga bit ni Alice	0	1	0	0	1	1	0	1	0	...
Mga base ni Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Mga state ni Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Mga hinalang base ni Eve	Z	X	X	Z	X	Z	Z	X	X	...
Mga state ni Eve (a priori)	?	$\vert -\rangle$	?	$\vert 0\rangle$	?	?	$\vert 0\rangle$	?	$\vert +\rangle$	...
Mga state ni Eve (nasukat)	$\vert 1\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Mga base ni Bob	X	Z	X	Z	X	X	Z	X	X	...

Dahil wala si Eve na ideya kung nagkatugma siya sa base ni Alice o hindi, hindi niya alam kung ano ang ipapadala niya kay Bob upang tumugma sa mga orihinal na state ni Alice. Kapag sinukat ni Eve, halimbawa, ang $|0\rangle,$ ang natatiyak lamang niya ay hindi inihanda ni Alice ang state na $|1\rangle$ para sa qubit na iyon. Ngunit maaaring inihanda ni Alice ang $|0\rangle,$ $|+\rangle,$ o $|-\rangle.$ Lahat ay maaaring maging pare-pareho sa sukat ni Eve. Kaya si Eve ay kailangang gumawa ng pagpili. Maaari niyang ipadala ang eksaktong state na nasukat niya, o maaari niyang subukang hulaan ang mga pagkakataon kung saan hindi ang kanyang sukat ang eigenstate na ipinadala ni Alice. Magsasama tayo ng halo sa ating talahanayan:

Mga bit ni Alice	0	1	0	0	1	1	0	1	0	...
Mga base ni Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Mga state ni Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Mga hinalang base ni Eve	Z	X	X	Z	X	Z	Z	X	X	...
Mga state ni Eve (a priori)	?	$\vert -\rangle$	?	$\vert 0\rangle$	?	?	$\vert 0\rangle$	?	$\vert +\rangle$	...
Mga state ni Eve (nasukat)	$\vert 1\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Mga state ni Eve (ipinadala)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	...
Mga base ni Bob	X	Z	X	Z	X	X	Z	X	X	...
Mga state ni Bob (a priori)	?	$\vert 0\rangle$	?	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Mga state ni Bob (nasukat)	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Mga bit ni Bob	1	0	0	0	1	0	0	1	0	...

Sa puntong ito, makatuwiran na magtanong, "Bakit hindi lang gumawa si Eve ng kopya ng quantum state ni Alice, panatilihin ang isa para sukatin, at ipadala ang isa pa kay Bob?" Ang sagot ay ang "no-cloning" theorem. Sa madaling salita, sinasabi nito na walang unitary (quantum mechanical) na operasyon ang maaaring gumawa ng pangalawang kopya ng isang arbitrary na quantum state, habang pinapanatili ang unang kopya. Ang patunay ay medyo simple, at iniiwan bilang isang guided exercise. Ngunit sa ngayon, unawain na ang pagkopya ng quantum state ni Eve ay ipinagbabawal ng mga pangunahing batas ng kalikasan, at ito ay isang prinsipyal na lakas ng QKD. Tulad ng dati, tatawag si Alice at Bob sa isa't isa at maghahambing ng mga base. Bababaan nila ang talahanayan na ito sa mga kaso kung saan parehong pinili ng dalawang kaibigan ang parehong mga base:

Mga bit ni Alice	0	0	1	0	0	...
Mga base ni Alice	X	Z	X	Z	X	...
Mga state ni Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga hinalang base ni Eve	Z	Z	Z	Z	X	...
Mga state ni Eve (a priori)	?	$\vert 0\rangle$	?	$\vert 0\rangle$	$\vert +\rangle$	...
Mga state ni Eve (nasukat)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga state ni Eve (ipinadala)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	...
Mga base ni Bob	X	Z	X	Z	X	...
Mga state ni Bob (a priori)	?	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga state ni Bob (nasukat)	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Mga bit ni Bob	1	0	0	0	0	...

Nagpahayag muli si Alice at Bob ng bit string... ngunit hindi magkatugma ang mga string. Ang pinakakaliwang bit at gitnang bit ay naka-flip. Sa pagtingin sa nakaraang talahanayan, maaari mong masubaybayan ang hindi pagkakatugmang ito sa pakikialam mula kay Eve. Kritikal na pansinin na maaari tayong gumawa ng mga istatistika sa pagtatugma sa pagitan ng ating mga bitstring ngayon, habang nag-se-set up ng key, matagal bago ibahagi ang ating naka-encrypt na lihim. Si Alice at Bob ay malaya na gumamit ng kahit gaano karami sa kanilang mga one-time pad bit upang suriin ang seguridad ng kanilang channel. Kung isang bit, o napakaliit na porsyento ng mga bit ang hindi nagkatugma, maaaring maipaliwanag ito sa pamamagitan ng ingay o mga error. Ngunit ang malaking bahagi ng mga hindi pagkakatugma ay nagpapahiwatig ng pag-eavesdrop. Ang kahulugan ng "malaki" dito ay medyo nakasalalay sa ingay sa setup na ginagamit; ang ibig sabihin nito para sa mga IBM® quantum computer ay tinalakay sa ibaba kapag isinagawa natin ang protocol na ito. Kung natukoy ang labis na mga error, hindi ibinabahagi ni Alice at Bob ang lihim, at maaari nilang simulan ang paghahanap sa mananawid.

Mga caveat

Ang pagpapatunay ng seguridad ay napakahirap. Sa katunayan, ang protocol na maluwag na inilarawan dito ay iminungkahi noong 1984, at hindi napatunayan na ligtas hanggang 16 na taon na ang lumipas Shor & Preskill, 2000. Maraming mga subtlety na higit sa saklaw ng panimulang ito. Ngunit ilista natin nang maikli ang ilan upang ipakita na ang paksa ay mas kumplikado kaysa sa ipinakita dito.

• Mga ligtas na channel: Kapag nagpadala si Alice ng kanyang mga qubit sa pamamagitan ng ilang quantum setup (isang channel), at lalo na kapag nakadinig siya ng mga classical na tugon mula sa isang tao, ipinagpalagay nating ang tao ay si Bob talaga. Kung nakalusot si Eve sa setup na ito sa paraang ang lahat ng komunikasyon ni Alice ay talagang nangyayari kay Eve, at ang lahat ng komunikasyon ni Bob ay talagang ginagawa ni Eve, kung gayon ay epektibong nakakuha si Eve ng key, at maaari siyang matuto ng mga lihim. Una, kailangang tiyakin ang "mga ligtas na channel", isang proseso na may ibang hanay ng mga protocol na hindi natin tinugunan dito.
• Mga pagpapalagay tungkol kay Eve: Upang tunay na mapatunayan ang seguridad, hindi tayo maaaring gumawa ng mga pagpapalagay tungkol sa gawi ni Eve; maaari niyang palaging pigilan ang ating mga inaasahan. Dito, upang magbigay ng mga konkretong halimbawa, gumagawa tayo ng mga pagpapalagay. Halimbawa, maaari tayong ipagpalagay na ang mga state na ipinapadala ni Eve kay Bob ay palaging eksaktong yaong nakuha niya sa sukat. O maaari tayong ipagpalagay na random siyang pumipili ng state na eksperimentong pare-pareho sa kanyang sukat. Mas pundamental, ang wika dito ay nagpapagpalagay na si Eve ay talagang gumagawa ng sukat, kumpara sa pag-iimbak ng state sa isa pang quantum system at pagpapadala ng random na qubit kay Bob. Ang mga pagpapalagay na ito ay ayos para maunawaan ang protocol, ngunit nangangahulugang hindi tayo nagpapatunay ng anumang bagay sa buong pangkalahatan.
• Privacy amplification: Hindi kinakailangan ni Alice at Bob na gamitin ang quantum key nang eksakto tulad ng ipinadala. Maaari silang, halimbawa, mag-apply ng hash function sa shared key. Ito ay sasamantalahin ang katotohanan na ang mananawid ay may hindi kumpleto na kaalaman ng key upang makagawa ng mas maikli, ngunit ligtas na shared key.

Eksperimento 1: QKD nang walang eavesdropper

Ipapatupad natin ang protokol sa itaas nang walang eavesdropper. Gagawin natin ito gamit muna ang isang simulator, para lang maunawaan ang daloy ng trabaho.

Una, isang paunawa tungkol sa mga quantum simulator: Karamihan sa mga quantum na problema na may higit sa ~30 na qubit ay hindi kayang i-simulate ng karamihang mga computer. Walang klasikal na computer, supercomputer, o GPU ang kayang i-simulate ang buong hanay ng gawi ng isang 127-qubit na quantum computer. Kadalasan, ang dahilan kung bakit ginagamit ang tunay na mga quantum computer ay dahil ang maraming entangled na qubit ay hindi ma-simulate. Sa kasong ito, walang entanglement ng mga qubit, maliban kung gagamitin natin ang teleportation scheme para ilipat ang impormasyon. Sa kasong ito, ang dahilan ng paggamit ng tunay na mga quantum computer ay naiiba: ito ang no-cloning theorem. Ang isang klasikal na computer na nag-si-simulate ng qubit ay makakapadala ng impormasyon tungkol sa isang quantum state mula kay Alice patungong Bob, ngunit kung ang klasikal na impormasyong ito ay na-intercept, madali itong maaaring i-duplicate, at maaaring mapanatili ni Eve ang isang perpektong kopya habang nagpapadala ng isa pa kay Bob. Hindi ito posible sa tunay na mga quantum state.

Inirerekomenda ng IBM Quantum na harapin ang mga problema sa quantum computing gamit ang isang balangkas na tinatawag naming "Qiskit patterns". Binubuo ito 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

Qiskit patterns hakbang 1: I-map ang iyong problema sa isang quantum circuit

Sa kasong ito, ang pag-map ng aming problema sa mga quantum circuit ay simpleng paghahanda ng mga estado ni Alice, at pagdaragdag ng mga sukat ni Bob. Magsisimula tayo sa random na bit at random na pagpili ng basis.

# Qiskit patterns step 1: Map your problem to quantum circuit
# Import some generic packages

import numpy as np
from qiskit import QuantumCircuit

# Set up a random number generator and a quantum circuit. We choose to start with 20 bits, though any number <30 should be fine.

rng = np.random.default_rng()
bit_num = 20
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Random bits and bases for Alice
# generate Alice's random bits

abits = np.round(rng.random(bit_num))

# generate Alice's random measurement bases. Here we will associate a "0" with the Z basis, and a "1" with the X basis.

abase = np.round(rng.random(bit_num))

# Alice's state preparation. Check that this creates states according to table 1

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob
# generate Bob's random measurement bases.

bbase = np.round(rng.random(bit_num))

# Note that if Bob measures in Z no gates are necessary, since IBM Quantum computers measure in Z by default.
# If Bob measures in the X basis, we implement a hadamard gate qc.h to facilitate the measurement.

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

I-visualize natin ang mga bit, bases, at circuit. Pansinin na minsan magtutugma ang mga bases, at minsan hindi.

print("Alice's bits are ", abits)
print("Alice's bases are ", abase)
print("Bob's bases are ", bbase)
qc.draw("mpl")

Alice's bits are  [1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0.]
Alice's bases are  [0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0.]
Bob's bases are  [0. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0.]

Qiskit patterns hakbang 2: I-optimize ang problema para sa quantum execution

Ang hakbang na ito ay kumukuha ng mga operasyong gusto nating isagawa at ipinapahayag ang mga ito sa mga termino ng functionality ng isang tiyak na quantum computer. Ino-map din nito ang aming problema sa layout ng quantum computer.

Magsisimula tayo sa pag-load ng ilang mga pakete na kinakailangan para makipag-communicate sa mga IBM quantum computer. Kailangan din nating pumili ng isang backend kung saan magpapatakbo. Maaari tayong pumili ng pinaka-hindi abala na backend, o pumili ng isang tiyak na backend na alam na natin ang mga katangian. Kahit gagamit tayo ng simulator sandali, mahalaga na gumamit ng makatwirang noise model sa simulation, at mabuti na panatilihing malapit sa isa't isa ang daloy ng trabaho na gagamitin natin sa tunay na mga quantum computer.

May code sa ibaba para sa pag-save ng iyong mga kredensyal sa unang paggamit. Siguraduhing burahin ang impormasyong ito mula sa notebook pagkatapos itong i-save sa iyong environment, para hindi maaksidenteng maibahagi ang iyong mga kredensyal 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_brisbane

Sa ibaba ay pipili tayo ng isang simulator at noise model.

# 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

# Load the qiskit runtime sampler
from qiskit_ibm_runtime import SamplerV2 as Sampler

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)

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

Qiskit patterns hakbang 3: Isagawa

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

# This required 5 s to run on a Heron r2 processor on 10-28-24
sampler = Sampler(mode=backend)
job = sampler.run([qc_isa], shots=1)
# job = sampler_sim.run([qc], shots = 1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Qiskit patterns hakbang 4: Post-processing

Dito natin inuunawa ang ating mga resulta at kinukuha ang kapaki-pakinabang na impormasyon. Maaaring subukan nating i-visualize ang output ng ating sampler, ngunit ginamit natin ang sampler sa isang hindi pangkaraniwang paraan. Sa halip na gumawa ng maraming sukat ng ating circuit at bumuo ng mga istatistika sa mga estado, isang sukat lamang ang ginawa natin (yung kay Bob). Ang anumang qubit na may estado na inihanda at sinukat sa parehong basis ay dapat magkaroon ng deterministic na kinalabasan, kaya isang sukat na lamang ang kailangan. Ang mga qubit na may mga estadong inihanda at sinukat sa iba't ibang basis (na magkakaroon ng probabilistic na kinalabasan at mangangailangan ng maraming sukat para maunawaan) ay hindi gagamitin para buuin ang ating one-time pad/key. I-extract natin ang isang listahan ng mga kinalabasan ng sukat mula sa bitstring na ito. Mag-ingat sa pag-reverse ng pagkakasunod-sunod kapag inihambing sa bit array ni Alice na ginamit natin para buuin ang circuit.

# Get an array of bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))

# Reverse the order to match our input. See "little endian" notation.

bbits = bmeas_ints[::-1]

print(bbits)

[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0]

Ihambing natin ang mga basis ng sukat na random na pinili ng Alice at Bob. Ito ang hakbang 3 ng ating QKD protocol (pampublikong talakayan ng mga basis). Sa tuwing pumili sila ng parehong basis para sa isang qubit, idadagdag natin ang mga bit na kaugnay ng qubit na iyon sa isang listahan ng mga bit para sa pagbuo ng mga numero sa isang one-time pad. Kapag hindi nagtugma ang mga basis, ang mga resulta ay itatapon. Suriin din natin kung magkatugma ang dalawang listahan ng mga bit, o kung may mga pagkawala dahil sa ingay o iba pang mga kadahilanan.

# QKD step 3: Public discussion of bases

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    # Check whether bases matched.
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        # If bits match when bases matched, increase count of matching bits
        if int(abits[n]) == bbits[n]:
            match_count += 1

print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

[1, 0, 1, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 1, 0]
fidelity =  1.0
loss =  0.0

Ang Alice at Bob ay bawat isa ay may listahan ng mga bit, at nagtutugma ang mga ito nang 100% na katumpakan. Maaari nilang gamitin ang mga ito para bumuo ng mga numero sa isang one-time pad. Maaari nilang gamitin ito sa QKD hakbang 4: pagpapadala at pag-decrypt ng isang lihim. Ang kasalukuyang hanay ng mga bit ay masyadong maikli para mag-decrypt ng kahit ano. Babalikan natin ito pagkatapos isama ang pag-eeavesdrop.

Suriin ang iyong pag-unawa

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

Ipagpalagay na kailangan mo ng mga digit na malaki para makapagbigay ng shift sa mga letra ng Ingles na alpabeto ng buong haba nito, o higit pa, bagaman may iba pang mga paraan ng encoding. (a) Gaano katagal ang mensahe para ma-decrypt gamit ang mga bit sa key sa itaas? (b) Kailangan bang magkapareho ang iyong sagot sa iyong mga kaklase? Bakit o bakit hindi?

Sagot:

(a) Ang sagot ay depende sa kung gaano karaming random na piniling bases ang nagtugma sa pagitan ni Alice at Bob. Dahil may halos 50-50 na pagkakataon na magtugma ang mga basis para sa anumang ibinigay na qubit, inaasahan nating halos 10 ng ating mga bit ang magiging kapaki-pakinabang. Ang 9 o 11 ay karaniwan. Kahit 4 o 15 ay hindi imposible. Kailangan ng 5 bits para mag-shift ng numero na katumbas o mas malaki kaysa sa haba ng Ingles na alpabeto, ibig sabihin maaari kang mag-apply ng shift sa isang letra para sa bawat 5 bits na mayroon ka. Kung mayroon kang hindi bababa sa 5 bits na ibinabahagi ng Alice at Bob, maaari kang mag-encode ng isang letra. Kung mayroon kang hindi bababa sa 10, maaari kang mag-encode ng 2 letra, at iba pa. (b) Hindi kailangang magkasundo, dahil sa mga dahilang nakabalangkas sa (a).

Eksperimento 2: QKD na may eavesdropper

Ipapatupad natin ang eksaktong parehong protokol gaya ng dati. Sa pagkakataong ito, maglalagay tayo ng isa pang hanay ng mga sukat, ni Eve, sa pagitan ni Alice at Bob.

from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Qiskit patterns step 1: Mapping your problem to a quantum circuit
# QKD step 1: Random bits and bases for Alice

bit_num = 20
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Alice's random bits and bases, as before

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation, as before

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

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

# Qiskit patterns step 3: Execute
job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Ang Qiskit patterns hakbang 4 (post-processing) ay simple sa kasong ito. Hindi na kailangang i-visualize ang distribusyon ng mga sukat, dahil isang sukat lamang ang ginawa natin. Ang mga sumusunod na bit ay nasa kamay ni Eve:

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

print(ebits)

[0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]

Ngayon dapat i-reconstruct ni Eve ang mga estado para ipadala kay Bob. Gaya ng nabanggit sa panimula, wala siyang paraan para malaman kung tamang hinulaan niya ang mga encoding basis, kaya hindi siya makakapaghanda ng eksaktong parehong mga estado na ipinadala. Maaari niyang ipagpalagay na tama ang bawat pagpili ng basis at i-encode kung ano mismo ang sinukat niya, o maaari niyang ipagpalagay na mali ang piniling basis at pumili ng alinmang eigenstate ng kabaligtarang basis. Dito, ipinapalagay natin ang una, para sa simplisidad. Nagagawa natin ito sa pamamagitan ng pagbuo ng isang bagong quantum circuit, na inuulit ang mga hakbang ng Qiskit patterns gaya ng dati.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit patterns step 1: Mapping your problem onto a quantum circuit
# QKD step 1: Eve uses her measurements to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

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

# Qiskit patterns step 3: Execute

job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

print(bbits)

[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]

Ihambing natin ngayon ang mga bit ni Alice at Bob:

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1
print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 1]
fidelity =  0.8571428571428571
loss =  0.1428571428571429

Dati, perpektong nagtugma ang mga bit sa mga key ni Alice at Bob. Ngayon, dahil sa pakikialam ni Eve, makikita natin na 14% ng mga kaso na dapat sana'y nagtugma—dahil pumili ng parehong bases ang Alice at Bob—ay magkaiba ang mga bit. Dapat itong madaling matuklasan ng Alice at Bob. Gayunpaman, ang pag-asa sa isang porsyento ng mga error na katulad nito ay nangangahulugang may limitasyon sa dami ng ingay na maaari nating tiisin sa quantum channel.

Eksperimento 3: Ikumpara ang QKD na may at walang pakikinig sa isang tunay na quantum computer

Subukan nating patakbuhin ito sa isang tunay na quantum computer. Sa ganoon, magagamit natin ang no-cloning theorem. Ngunit ang mga tunay na quantum computer ay may ingay at mas mataas na error rate kumpara sa mga klasikal na computer. Kaya ikukumpara natin ang pagkawala ng fidelity ng ating mga key bits — na may at walang pakikinig — para masiguro na nakikita ang pagkakaiba kahit gumagamit ng tunay na quantum computer. Magsisimula tayo nang walang pakikinig:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and required 3 sec to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

# Qiskit patterns step 2: Transpilation

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

# Load the Runtime primitive and session
sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's measurement bases and collect usable bits

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Alice's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
Bob's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
fidelity =  0.9682539682539683
loss =  0.031746031746031744

Nang walang pakikinig, nakakuha tayo ng halos 100% fidelity sa 127 trial bits, na nagresulta sa 55 na magkakatugmang bases at magagamit na key bits. Ngayon, ulitin natin ang eksperimentong ito na may pakikinig ni Eve:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and required 2 s to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

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

sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Eve's bits

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

# print(ebits)

# Restart process
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

# QKD step 1: Eve uses her measurements above to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

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

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit Patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's bases, when they are the same, keep the bits.

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Alice's bits =  [1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1]
Bob's bits =  [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
fidelity =  0.7619047619047619
loss =  0.23809523809523814

Natuklasan natin dito ang halos 23% na pagkawala ng fidelity sa mga shared bits dahil sa pakikinig! Madali itong matukoy! Dapat tandaan na ang paglipat ng quantum information sa malalayong distansya ay maaaring magdagdag pa ng ingay at mga error. Ang pagsisiguro na matatukoy ang pakikinig kahit may ingay, at kahit gamitin ni Eve ang lahat ng paraan na alam niya, ay isang kumplikadong larangang lampas sa panimulang pag-aaral na ito.

Mga Tanong

Ang mga guro ay maaaring humiling ng mga bersyon ng mga notebook na ito na may mga susi sa sagot at gabay sa paglalagay sa karaniwang kurikulum sa pamamagitan ng pagsagot sa maikling survey na ito tungkol sa paggamit ng mga notebook.

Mga pangunahing konsepto

• Hindi maaaring kopyahin o "i-clone" ang quantum information.
• Maaari kang ulit-ulitin ang parehong proseso ng paghahanda para makagawa ng isang ensemble ng mga quantum state na magkapareho, o halos magkapareho.
• Ang isang encryption/decryption key (one-time pad) ay maaaring ibahagi sa pagitan ng dalawang kaibigan gamit ang mga quantum state.
• Kapag ang dalawang kaibigan ay random na pumipili ng measurement basis, kalahati ng oras ay magkaiba ang kanilang pinili, at kailangan nilang itapon ang impormasyong mula sa mga qubit na iyon.
• Ang random na pagpili ng measurement basis ay nagtitiiyak din na hindi malalaman ng isang tagapakinig ang unang state na inihanda, kaya hindi niya maaaring muling likhain ang naipadala. Tinitiyak nito na matatukoy ang pakikinig.

Mga T/F na tanong

1. T/F Sa quantum key distribution, ang dalawang kasosyo sa komunikasyon ay sumusukat sa bawat qubit gamit ang parehong basis.
2. T/F Ang isang tagapakinig na humarang ng quantum information sa QKD ay pinipigilan ng mga batas ng kalikasan sa pagkopya ng quantum state na kanilang hinarang.
3. T/F Ang one-time pad ay isang key para sa pag-encrypt/decrypt ng mga ligtas na mensahe kung saan isang partikular na paraan ng pag-encode ang ginagamit nang isang beses lamang, para sa isang piraso ng impormasyon (tulad ng isang titik ng alpabeto).

Mga MC na tanong

1. Piliin ang opsyong pinakamahusay na nagkukumpleto sa pahayag. Ayon sa modyul na ito, ang one-time pad ay isang hanay ng mga encryption/decryption key na ginagamit...

• a. Isang beses lamang para sa isang piraso ng impormasyon, tulad ng isang titik.
• b. Isang beses lamang para sa isang mensahe.
• c. Isang beses lamang para sa isang nakatakdang panahon, tulad ng isang araw.
• d. Hanggang may katibayan ng pakikinig.

2. Ipagpalagay na si Alice at Bob ay random na pumipili ng kanilang mga measurement basis. Sumusukat sila. Pagkatapos ay ibinabahagi nila ang kanilang mga measurement basis, at pinapanatili lamang ang mga bits ng impormasyon mula sa mga kaso kung saan ginamit nila ang parehong basis. Sa halos random na pagbabago-bago, humigit-kumulang anong porsyento ng kanilang mga qubit ang dapat magbigay ng magagamit na bits ng impormasyon?

• a. 100%
• b. 50%
• c. 25%
• d. 12.5%
• e. 0%

3. Pagkatapos piliin ni Alice at Bob ang mga kaso kung saan ginamit nila ang parehong measurement basis, anong porsyento ng mga bits ng impormasyon ang dapat na magkatugma, kung ang quantum noise at mga error ay mapapalampas?

• a. 100%
• b. 50%
• c. 25%
• d. 12.5%
• e. 0%

4. Ipagpalagay na si Alice ay random na pumili ng kanyang mga measurement basis. Si Eve ay random din ang pagpili ng kanyang mga basis, at siya ay nakikinig (sumusukat). Nagpapadala siya ng mga state kay Bob na naaayon sa kanyang mga sukat. Ikukumpara ni Alice at Bob ang kanilang mga pagpili ng basis at pinapanatili lamang ang mga qubit na sinukat/inihanda ng pareho sa parehong basis. Sa halos random na pagbabago-bago, humigit-kumulang anong porsyento ng mga napanatiling sukat ng qubit ang magkatugma, ayon kina Alice at Bob?

• a. 100%
• b. 75%
• c. 50%
• d. 25%
• e. 12.5%
• f. 0%

Mga tanong para sa talakayan

1. Ipagpalagay na lahat ng pagpili ng basis ay random para sa lahat ng kalahok — sina Alice, Bob, at Eve. Ipagpalagay na pagkatapos makinig ni Eve, nagpapadala siya ng state kay Bob na inihanda sa parehong basis kung saan siya sumusukat, at naaayon sa sukat na iyon. Kumbinsihin ang iyong mga kasama na 12.5% ng lahat ng qubit na sinimulan ni Alice ay magbubunga ng mga hindi magkatugmang sukat sa pagitan nina Alice at Bob, na nagpapahiwatig ng pakikinig (binabalewala ang mga quantum error at ingay). Pahiwatig 1: Dahil walang mas nangingibabaw na basis, kung isasaalang-alang mo ang isang paunang pagpili para kay Alice, ang ratio para sa pagpiling iyon ay dapat na katulad ng ratio para sa kabuuan ng lahat ng pagpili. Pahiwatig 2: Maaaring hindi sapat ang basta mabilang ang bilang ng mga paraan na maaaring mangyari ang isang bagay, dahil ang ilang mga kinalabasan ay maaaring mangyari sa iba't ibang probabilidad.