Přeskočit na hlavní obsah

Kvantová distribuce klíčů

Pro tento modul Qiskit v hodinách musí mít studenti funkční prostředí Python s nainstalovanými následujícími balíčky:

  • qiskit v2.1.0 nebo novější
  • qiskit-ibm-runtime v0.40.1 nebo novější
  • qiskit-aer v0.17.0 nebo novější
  • qiskit.visualization
  • numpy
  • pylatexenc

Pokyny k nastavení a instalaci výše uvedených balíčků najdeš v průvodci Instalace Qiskitu. Abys mohl(a) spouštět úlohy na skutečných kvantových počítačích, budeš si muset vytvořit účet u IBM Quantum® podle kroků v průvodci Nastavení účtu IBM Cloud.

Tento modul byl otestován a využil 5 sekund QPU času. Jedná se pouze o odhad. Skutečná spotřeba se může lišit.

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

Níže se podívej na průvodní výklad modulu od Dr. Katie McCormick nebo klikni zde a přejdi na YouTube.

Úvod a motivace​

Existuje nekonečně mnoho způsobů šifrování a dešifrování informací a doslova tisíce způsobů bylo důkladně prostudováno. Omezíme se zde na velmi ranou a velmi jednoduchou metodu šifrování zvanou „jednoduché nahrazení", abychom se mohli soustředit na kvantovou část tohoto protokolu. Kvantovou část by bylo možné s relativně malými změnami přizpůsobit mnoha dalším protokolům.

Jednoduché nahrazení​

Šifrování jednoduchým nahrazením je takové, při němž je jedno písmeno nebo číslo nahrazeno jiným, přičemž existuje vzájemně jednoznačné zobrazení z písmen a číslic zprávy na písmena a číslice použité v šifrované sekvenci. Populárním příkladem jsou šifrovací hádanky (cryptoquote nebo cryptogram), kde je citát nebo fráze zašifrována pomocí jednoduchého nahrazení a hráč má za úkol ji rozluštit. Jsou snadno řešitelné, pokud jsou dostatečně dlouhé. Vezmi si jako příklad:

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.

Lidé, kteří tato šifry lámou ručně, většinou používají triky využívající znalost struktury jazyka původní zprávy. Například v angličtině jsou jedinými jednopísmenkovými slovy jako zašifrované „R" slova „a" a „I". Zdvojené písmeno zašifrované například v „KIVGGB" může nabývat jen určitých hodnot. Existují subtilnější vodítka, například že nejčastější slovo odpovídající vzoru „GSZG" je „that". Lidé, kteří používají ke lámání šifer kód, mají mnohem více možností — například jednoduše procházejí možnosti, dokud se neobjeví anglické slovo, a průběžně je aktualizují při zachování tohoto slova. Jedna jednoduchá, ale mocná metoda spočívá v analýze frekvence písmen, zejména pokud je zpráva dostatečně dlouhá, aby tvořila reprezentativní vzorek angličtiny.

Průběžná otázka​

Zkus si šifru sám(a) rozluštit, i když to pro zbytek modulu není nutné. Kliknutím na šipku níže zobrazíš zprávu.

Odpověď:

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.

Výše uvedený příklad je spojen s „klíčem" — zobrazením ze zašifrovaných na dešifrovaná písmena. V tomto případě je klíč:

  • A (nepoužito, nazvěme ho Z)
  • B->Y
  • C (nepoužito, nazvěme ho X)
  • D->W
  • E->V
  • F->U
  • ...

A tak dále. Mírně řečeno, toto není dobrý klíč. Klíče, v nichž jsou zašifrovaná a dešifrovaná písmena jednoduše posunutou verzí abecedy (například A->B a B->C), se nazývají „Caesarovy šifry".

Všimni si, že tyto šifry jsou velmi obtížné, pokud jsou krátké. A jsou-li velmi krátké, jsou dokonce neurčité. Uvažuj:

URYYP

Existuje mnoho možných dešifrování s různými klíči: HELLO, PETTY, HAPPY, JIGGY, STOOL. Napadají tě další?

Pokud ale pošleš mnoho zpráv jako tuto, šifrování bude nakonec prolomeno. Proto bys neměl(a) používat stejný „klíč" příliš často. Nejlepší je ve skutečnosti používat určitou substituci jen jednou. Ne jen v jedné zprávě, ale pouze pro jeden jediný znak! Tím myslíme, že budeš mít schéma šifrování nebo klíč pro každý znak použitý ve zprávě, v pořadí. Pokud chceš touto metodou poslat příteli zprávu, potřebuješ ty i tvůj přítel blok papíru (v dávných dobách), na němž je tento neustále se měnící klíč zaznamenán. Použiješ ho pouze jednou. To se nazývá „jednorázový blok" (one-time pad).

Jednorázový blok​

Pojďme si ukázat, jak to funguje na příkladu. Dalo by se to celé dělat s písmeny, ale je běžné převést písmena na čísla — například přiřazením A=0, B=1, C=2…. Předpokládejme, že jsme přátelé zapojení do utajených aktivit a sdíleli jsme blok. Ideálně bychom sdíleli mnoho bloků, ale dnešní je:

EDGRPOJNCUWQZVMK…

Nebo v číslicích podle pořadí v abecedě:

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

Předpokládejme, že ti chci sdělit zprávu:

„I love quantum!"

Neboli ekvivalentně:

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

Nechceme posílat výše uvedený kód; to je jednoduché nahrazení, které vůbec není bezpečné. Chceme to nějak kombinovat s naším klíčem. Obvyklým způsobem je sčítání modulo 26. Přičítáme hodnotu zprávy k hodnotě klíče, mod 26, dokud nedosáhneme konce zprávy. Takže bychom poslali

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

Všimni si, že pokud někdo toto zachytí a NEMÁ klíč, dešifrování je naprosto beznadějné! Dokonce ani dvě „u" ve slově „quantum" nejsou zakódována stejným číslem! První je 3 a druhé je 16… ve stejném slově!

Takže ti toto pošlu a ty máš stejný klíč jako já. Vrátíš zpět sčítání modulo 26, o němž víš, že jsem ho provedl(a):

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),…

Takže zpráva x1, x2, x3, x4… musí být

8, 11, 14, 21…

Nakonec, po převodu na text, dostaneme

„I love quantum".

To je jednorázový blok.

Všimni si, že je-li klíč kratší než zpráva, začínáme opakovat naše kódování. To by bylo stále obtížný problém na dešifrování, ale není to nemožné, pokud se to opakuje dost často. Proto potřebuješ dlouhý klíč (nebo „blok").

poznámka

V mnoha kontextech budou studenti toto šifrování již znát, takže tuto aktivitu lze přeskočit. Je to ale relativně rychlé a jednoduché opakování.

Krok 1: Najdi si partnera a sdílejte sekvenci 4 písmen jako klíč. Poslouží jakákoliv 4písmenná sekvence vhodná pro třídu.
Krok 2: Vyber si 4písmenné tajné slovo, které chceš poslat svému partnerovi (oba partneři to udělají, takže si navzájem posíláte různá tajná slova).
Krok 3: Převeď 4písmenný klíč/blok a každé ze 4písmenných tajných slov na čísla pomocí A = 1, B = 2 atd.
Krok 4: Zkombinuj své 4písmenné slovo s jednorázovým blokem pomocí sčítání modulo 26.
Krok 5: Předej partnerovi sekvenci čísel kódující tvé tajné slovo a partner ti předá tu svou.
Krok 6: Dešifrujte navzájem svá slova pomocí odčítání modulo 26.
Krok 7: Ověřte. Fungovalo to?

Navazující otázka​

Vyměňte zašifrovaná slova s jinou skupinou, která nemá přístup k vašemu jednorázovému bloku. Dokážete to dešifrovat? Vysvětli proč nebo proč ne?

Doufáme, že výše uvedená aktivita jasně ukázala, že jednorázový blok je neprolomitelná forma šifrování — za předpokladu splnění několika podmínek, jako jsou:

  • Klíč je stejně dlouhý jako odesílaná zpráva, nebo delší
  • Klíč je skutečně náhodný
  • Klíč je použit pouze jednou a poté zlikvidován

To je skvělé. Máme neprolomitelné šifrování... pokud někdo nezíská náš klíč. Pokud někdo náš klíč získá, vše bude dešifrováno. Tento rozdíl mezi neprolomitelným šifrováním a odhalením všech našich tajemství činí sdílení bezpečného klíče nesmírně důležitým. Cílem kvantové distribuce klíčů je využít omezení, která příroda uložila kvantovým informacím, k zabezpečení sdíleného klíče/jednorázového bloku.

Použití kvantových stavů jako klíče​

Předpokládejme, že pracujeme s qubity (přičemž zdůrazňujeme, že qubity mají dva vlastní stavy). Mohli bychom používat kvantové systémy s vyšším počtem kvantových stavů, ale nejmodernější kvantové počítače IBM® používají qubity. Není problém zakódovat naše A, B, C do sekvencí 0 a 1. Stačí tedy sdílet klíč z 0 a 1 a provádět sčítání modulo 2 na každém bitu uchovávajícím písmeno.

Ověř si porozumění​

Přečti si níže uvedenou otázku, zamysli se nad odpovědí, pak klikni na trojúhelník a zobraz řešení.

Pokud nám jde skutečně jen o anglická písmena, kolik bitů potřebujeme?

Odpověď:

24=1625=32→5 bits2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}

Naši přátelé Alice a Bob si chtějí sdílet kvantový klíč takovým způsobem, aby ho nikdo jiný nemohl zachytit (nebo alespoň ne bez jejich vědomí). Potřebují mít způsob, jak si navzájem posílat kvantové stavy. Dělat to s vysokou věrností a bez šumu/chyb NENÍ triviální. Existují však dva přístupy, které bychom měli být schopni pochopit:

  1. Optický kabel umožňuje přenášet světlo… které je velmi kvantověmechanické. Jednotlivé fotony lze detekovat s vysokou věrností na mnoha kilometrech optického kabelu. Není to dokonalý, bezchybový kvantový kanál, ale mohl by být velmi dobrý.
  2. Mohli bychom použít kvantovou teleportaci, jak je popsána v předchozím modulu. To znamená, že Alice a Bob by mohli sdílet provázané qubity a stav by mohl být přenesen od Alice k Bobovi pomocí teleportačního protokolu.

Pro tento modul nechceme, abyste museli mít k dispozici vysoce věrné optické nastavení pro sdílení fotonů, takže použijeme druhou metodu pro sdílení kvantových stavů. To ovšem neznamená, že je nejreálnější pro sdílení kvantových klíčů na velké vzdálenosti.

Nyní prozkoumáme protokol, který poprvé nastínili Charles Bennett a Gilles Brassard v roce 1984, pro sdílení stavů měřených v různých bázích od Alice k Bobovi. Použijeme chytré měřicí schéma k sestavení klíče pro použití při pozdějším šifrování. Jinými slovy, distribuujeme kvantový klíč mezi dvě strany, které si chtějí komunikovat, odtud „kvantová distribuce klíčů" (QKD).

QKD krok 1: Aliciny náhodné bity a náhodné báze​

Alice začne generováním náhodné sekvence 0 a 1. Poté náhodně vybere bázi, v níž připraví kvantový stav na základě každého náhodného bitu, podle níže uvedené tabulky (tabulky, kterou má také Bob):

Bázebit = 0bit = 1
Z∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle
X∣+⟩\vert +\rangle∣−⟩\vert -\rangle

Předpokládejme například, že Alice náhodně vygenerovala 0 a náhodně vybrala bázi X. Pak by připravila kvantový stav ∣ψ⟩=∣+⟩x=12(∣0⟩+∣1⟩)|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle). Je jistě možné využít kvantovou náhodnost ke generování náhodné sady 0 a 1 a náhodného výběru báze. Prozatím jednoduše předpokládejme, že náhodná sada byla vygenerována, takto:

Aliciny bity010011010...
Aliciny bázeXXZZZXZZX...
Aliciny stavy∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...

Tato sada náhodných bitů, bází a výsledných stavů by pokračovala v dlouhé sekvenci, aby poskytla klíč dostatečné délky.

QKD krok 2: Bobovy náhodné báze​

Bob také náhodně volí báze. Zatímco však Alice používala výběr báze k přípravě svého stavu, Bob bude v těchto bázích skutečně provádět měření. Pokud Bob provede měření ve stejné bázi, v níž Alice stav připravila, můžeme výsledek Bobova měření předpovědět. Když Bob náhodou zvolí jinou bázi než tu, kterou Alice použila při přípravě, výsledek Bobova měření nemůžeme znát.

Aliciny bity010011010...
Aliciny bázeXXZZZXZZX...
Aliciny stavy∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...
Bobovy bázeXZXZXXZXX...
Bobovy stavy (a priori)∣+⟩\vert +\rangle??∣0⟩\vert 0\rangle?∣−⟩\vert -\rangle∣0⟩\vert 0\rangle?∣+⟩\vert +\rangle...
Bobovy stavy (naměřené)∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
V níže uvedené tabulce uvažuj první sloupec. Alice připravila stav ∣+⟩,\vert +\rangle, který je vlastním stavem X. Protože Bob také náhodně zvolil měření v bázi X, existuje pro Bobův naměřený stav jediný možný výsledek: ∣+⟩.\vert +\rangle. Ve druhém sloupci si však zvolili různé báze. Stav, který Alice poslala, je ∣−⟩=12(∣0⟩−∣1⟩).\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle). Ten má 50% pravděpodobnost, že ho Bob naměří ve stavu ∣0⟩\vert 0\rangle, a 50% pravděpodobnost, že ho naměří ve stavu ∣1⟩.\vert 1\rangle. Proto řádek ukazující, co víme a priori o Bobových měřeních, nelze pro sloupec 2 vyplnit. Ale Bob provede měření a získá vlastní stav (v daném sloupci) Z. Do spodního řádku vyplníme, co tato měření náhodou přinesla.

QKD krok 3: Veřejná diskuse o bázích​

Alice a Bob si nyní mohou navzájem sdělit, jakou bázi v každém případě zvolili. Pro všechny sloupce, v nichž náhodou zvolili stejnou bázi, každý z nich přesně ví, v jakém stavu byl ten druhý. Bob může převést stav a bázi na 0 nebo 1 podle konvence sdílené oběma stranami. Výše uvedenou tabulku můžeme přepsat tak, aby zobrazovala pouze případy, kde se báze Alice a Boba shodovaly:

Aliciny bity00100...
Aliciny bázeXZXZX...
Aliciny stavy∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Bobovy bázeXZXZXX
Bobovy stavy (a priori)∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Bobovy stavy (naměřené)∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Bobovy bity00100...

Alice úspěšně přenesla Bobovi bitový řetězec 00100.... Pokud se přátelé předem dohodli, že budou používat 5bitové řetězce jako čísla ve svém jednorázovém bloku, těchto prvních pět bitů by jim dalo číslo 4=0×24+0×23+1×22+0×21+0×20.4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.

QKD krok 4: Ověření a odeslání tajemství​

Než Alice a Bob půjdou dál, měli by zvolit podmnožinu svých klasických bitů ke srovnání. Protože zachovali pouze měření qubitů, které byly připraveny a měřeny ve stejné bázi, všechny naměřené hodnoty by se měly shodovat. Pokud by velmi malé procento nesouhlasilo, mohlo by to být způsobeno kvantovým šumem nebo chybami. Pokud ale mnoho nesouhlasí, něco se pokazilo!

Zde nebudeme řešit, jaký zlomek klíče by měl být použit k ověření. Prozatím předpokládáme, že tato kontrola proběhne dobře; k tomu se vrátíme v níže uvedené části o odposlouchávání.

Přátelé by pak přes klasické kanály poslali navzájem zašifrovanou zprávu. Poté by používali čísla ve svém jednorázovém bloku k šifrování/dešifrování tajných zpráv, aniž by kdy přenášeli jednorázový blok z jednoho místa na druhé. Pro následující část o odposlouchávání mej na paměti, že veškeré toto sdílení klíče probíhá před odhalením zašifrovaného tajemství prostřednictvím klasických kanálů.

Alice a Bob sdělili svou volbu báze prostřednictvím klasických kanálů — nemohlo by to být zachyceno? Ano! Ale znalost báze, kterou použili pro měření, ti neřekne, jaký bit poslali nebo získali. To je možné jen tehdy, pokud také znáš Aliciny výchozí bity. Ale pak bys byl(a) v Alicině počítači, kde jsou uložena tajemství, a tajná komunikace tajemství se stává zbytečnou. Zachycení klasické komunikace tedy šifrování neprolomí. Ale co zachycení informací v kvantovém kanálu?

Odolnost QKD vůči odposlouchávání​

Alice a Bob mají přítele Evu, která je proslulá odposloucháváním. Eva si přeje zachytit kvantový klíč Alice a Boba, aby ho mohla použít k dešifrování zpráv zasílaných mezi nimi. To by se nutně muselo stát mezi přípravou stavů Alicí a měřením stavů Bobem, protože měření kolabuje kvantový stav. To zejména znamená, že odposlouchávání by muselo probíhat před jakýmkoli sdílením nebo porovnáním bází.

Eva musí hádat, která báze byla použita při kódování každého bitu. Pokud nemá přístup do Alicina počítače, nemá žádný základ pro tento odhad, a ten bude tedy náhodný. Předpokládejme, že Alicin začátek je stejný jako předtím, a dále předpokládejme, že Bobova náhodná volba měřicí báze je stejná jako předtím. Pojďme vyplnit, co Eva získá, když bude provádět měření kvantového kanálu. Jako dříve, pokud Eva náhodou zvolí stejnou bázi jako Alice, víme, co získá. Pokud ne, může získat jeden ze dvou výsledků, každý s 50% pravděpodobností.

Aliciny bity010011010...
Aliciny bázeXXZZZXZZX...
Aliciny stavy∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...
Eviny odhadnuté bázeZXXZXZZXX...
Eviny stavy (a priori)?∣−⟩\vert -\rangle?∣0⟩\vert 0\rangle??∣0⟩\vert 0\rangle?∣+⟩\vert +\rangle...
Eviny stavy (naměřené)∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
Bobovy bázeXZXZXXZXX...

Protože Eva neví, zda se shodla s Alicinou bází nebo ne, neví, co má dál přenést Bobovi, aby odpovídalo Aliciným původním stavům. Když Eva naměří například ∣0⟩,|0\rangle, ví s jistotou pouze to, že Alice pro daný qubit nepřipravila stav ∣1⟩|1\rangle. Alice však mohla připravit ∣0⟩,|0\rangle, ∣+⟩|+\rangle nebo ∣−⟩.|-\rangle. Všechny by byly konzistentní s Eviným měřením. Eva tedy musí udělat volbu. Mohla by přenést dál přesně ten stav, který naměřila, nebo se může pokusit odhadnout případy, kdy její měření nebylo vlastním stavem odeslaným Alicí. V naší tabulce zahrneme kombinaci obou přístupů:

Aliciny bity010011010...
Aliciny bázeXXZZZXZZX...
Aliciny stavy∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...
Eviny odhadnuté bázeZXXZXZZXX...
Eviny stavy (a priori)?∣−⟩\vert -\rangle?∣0⟩\vert 0\rangle??∣0⟩\vert 0\rangle?∣+⟩\vert +\rangle...
Eviny stavy (naměřené)∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
Eviny stavy (přenesené dál)∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle...
Bobovy bázeXZXZXXZXX...
Bobovy stavy (a priori)?∣0⟩\vert 0\rangle?∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
Bobovy stavy (naměřené)∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
Bobovy bity100010010...

V tuto chvíli je rozumné se zeptat: „Proč Eva jednoduše nezkopíruje Alicin kvantový stav, jeden si ponechá k měření a druhý přenese Bobovi?" Odpovědí je teorém o neklonovatelnosti. Neformálně říká, že neexistuje žádná unitární (kvantověmechanická) operace, která by dokázala vytvořit druhou kopii libovolného kvantového stavu při zachování první kopie. Důkaz je relativně jednoduchý a je ponechán jako řízené cvičení. Prozatím pochop, že vytváření kopií kvantového stavu Evou je zakázáno základními zákony přírody, a to je zásadní silnou stránkou QKD. Jako dříve, Alice a Bob by si zavolali a porovnali báze. Tuto tabulku zredukují na případy, kdy oba přátelé zvolili stejné báze:

Aliciny bity00100...
Aliciny bázeXZXZX...
Aliciny stavy∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Eviny odhadnuté bázeZZZZX...
Eviny stavy (a priori)?∣0⟩\vert 0\rangle?∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Eviny stavy (naměřené)∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Eviny stavy (přenesené dál)∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle...
Bobovy bázeXZXZX...
Bobovy stavy (a priori)?∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Bobovy stavy (naměřené)∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
Bobovy bity10000...

Alice a Bob si opět předali bitový řetězec... ale řetězce se neshodují. Krajní levý a prostřední bit jsou přehozeny. Z předchozí tabulky lze tuto neshodu vystopovat k zásahu Evy. Zásadně si všimni, že nyní můžeme provádět statistiku shody mezi našimi bitovými řetězci při sestavování klíče, dávno před sdílením zašifrovaného tajemství. Alice a Bob mohou volně použít libovolný počet bitů svého jednorázového bloku ke kontrole zabezpečení svého kanálu. Pokud se jediný bit nebo velmi malé procento bitů neshodovalo, mohlo by to být způsobeno šumem nebo chybami. Ale podstatný zlomek neshod naznačuje odposlouchávání. Výraz „podstatný" zde závisí trochu na šumu v používaném nastavení; co to znamená pro kvantové počítače IBM®, je popsáno níže při implementaci tohoto protokolu. Pokud jsou detekovány nadměrné chyby, Alice a Bob tajemství nesdílejí a mohou začít hledat odposlouchávače.

Výhrady​

Prokazování bezpečnosti je nesmírně obtížné. Ve skutečnosti byl protokol volně popsaný zde navržen v roce 1984 a nebyl prokázán jako bezpečný až 16 let poté Shor & Preskill, 2000. Existuje mnoho jemností, které jsou nad rámec tohoto úvodu. Stručně však uvedeme několik z nich, abychom ukázali, že téma je složitější, než je zde ilustrováno.

  • Bezpečné kanály: Když Alice posílá své qubity přes nějaké kvantové nastavení (kanál) a zejména když slyší klasické odpovědi od někoho zpět, předpokládali jsme, že tím někým je skutečně Bob. Pokud by Eva infiltrovala toto nastavení takovým způsobem, že veškerá komunikace Alice by ve skutečnosti probíhala s Evou a veškerá komunikace Boba by ve skutečnosti probíhala s Evou, pak Eva efektivně získala klíč a může zjistit tajemství. Nejprve je nutné zajistit „bezpečné kanály", což je proces s jiným souborem protokolů, které jsme zde neřešili.
  • Předpoklady o Evě: Abychom skutečně prokázali bezpečnost, nemůžeme dělat předpoklady o chování Evy; vždy by mohla zmást naše očekávání. Zde, abychom poskytli konkrétní příklady, předpoklady děláme. Například bychom mohli předpokládat, že stavy, které Eva přenáší dál Bobovi, jsou vždy přesně ty, které získala při měření. Nebo bychom mohli předpokládat, že náhodně volí stav experimentálně konzistentní s jejím měřením. Fundamentálněji, jazyk zde předpokládá, že Eva skutečně provádí měření, na rozdíl od uložení stavu na jiný kvantový systém a přenesení náhodného qubitu Bobovi. Tyto předpoklady jsou v pořádku pro pochopení protokolu, ale znamenají, že nic nedokazujeme v plné obecnosti.
  • Zesilování soukromí (Privacy amplification): Alice a Bob nemusí používat kvantový klíč přesně tak, jak byl přenesen. Mohou například na sdílený klíč aplikovat hašovací funkci. To by využívalo skutečnosti, že odposlouchávač má neúplné znalosti o klíči, k vytvoření kratšího, ale bezpečného sdíleného klíče.

Experiment 1: QKD bez odposlechu​

Pojďme implementovat výše popsaný protokol bez přítomnosti odposlechu. Začneme na simulátoru, abychom porozuměli pracovnímu postupu.

Poznámka ke kvantovým simulátorům: Většinu kvantových problémů zahrnujících více než ~30 qubitů nedokáže většina počítačů simulovat. Žádný klasický počítač, superpočítač ani GPU nedokáže plně simulovat chování 127qubitového kvantového počítače. Obvyklou motivací pro použití skutečných kvantových počítačů je skutečnost, že velký počet provázaných qubitů nelze simulovat. V tomto případě ale provázanost qubitů nevyužíváme — pokud nepoužijeme teleportační schéma pro přenos informace. Motivace pro použití skutečného kvantového počítače je zde odlišná: jde o teorém o neklonování. Klasický počítač simulující qubit by mohl přenášet informace o kvantovém stavu od Alice k Bobovi, ale pokud by tyto klasické informace byly zachyceny, bylo by možné je snadno duplikovat — Eve by si mohla ponechat dokonalou kopii a zároveň poslat druhou Bobovi. U skutečných kvantových stavů to možné není.

IBM Quantum doporučuje řešit problémy kvantového počítání pomocí rámce nazvaného „Qiskit patterns". Skládá se z následujících kroků:

  • Krok 1: Namapuj svůj problém na kvantový obvod
  • Krok 2: Optimalizuj obvod pro spuštění na skutečném kvantovém hardwaru
  • Krok 3: Spusť úlohu na kvantových počítačích IBM pomocí Runtime primitiv
  • Krok 4: Zpracuj výsledky

Qiskit patterns krok 1: Namapuj problém na kvantový obvod​

V tomto případě spočívá mapování problému na kvantové obvody v přípravě Aliciných stavů a zahrnutí Bobových měření. Začínáme náhodnou volbou bitů a základen.

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

Vizualizujme bity, základny a obvod. Všimni si, že základny se někdy shodují a někdy ne.

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

Output of the previous code cell

Qiskit patterns krok 2: Optimalizuj problém pro kvantové spuštění​

Tento krok vezme operace, které chceme provést, a vyjádří je pomocí funkcí konkrétního kvantového počítače. Zároveň namapuje náš problém na uspořádání qubitu daného kvantového počítače.

Začneme načtením několika balíčků potřebných ke komunikaci s kvantovými počítači IBM. Také musíme vybrat backend, na kterém poběžíme. Můžeme zvolit nejméně vytížený backend, nebo vybrat konkrétní backend, jehož vlastnosti známe. Přestože teď použijeme simulátor, je důležité použít přiměřený šumový model, a je dobré udržet pracovní postup co nejblíže tomu, který budeme používat později na skutečných kvantových počítačích.

Níže je kód pro první uložení přihlašovacích údajů. Po uložení do svého prostředí tyto informace z notebooku smaž, aby nebyly náhodně sdíleny, až budeš notebook sdílet. Více informací najdeš v průvodcích Nastav si účet IBM Cloud a Inicializuj službu v nedůvěryhodném prostředí.

# 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

Níže vybereme simulátor a šumový 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 krok 3: Spuštění​

Použij sampler ke spuštění úlohy s obvodem jako argumentem.

# 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 krok 4: Zpracování výsledků​

Zde interpretujeme výsledky a extrahujeme užitečné informace. Mohli bychom se pokusit vizualizovat výstup sampleru, ale použili jsme ho nekonvenčním způsobem. Místo mnoha měření obvodu a sbírání statistik jsme provedli jen jedno měření (Bobovo). Jakýkoli qubit, jehož stav byl připraven a změřen ve stejné základně, by měl mít deterministický výsledek, takže stačí jedno měření. Qubity, jejichž stavy byly připraveny a měřeny v různých základnách (což by mělo pravděpodobnostní výsledky a vyžadovalo by mnoho měření k interpretaci), nebudeme při tvorbě jednorázového klíče/padu používat.

Extrahujme seznam výsledků měření z tohoto bitového řetězce. Dávej pozor na obrácené pořadí při porovnávání s Aliciným polem bitů, které jsme použili k vygenerování obvodu.

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

Porovnejme základny náhodně zvolené Alicí a Bobem. Byl to krok 3 v našem protokolu QKD (veřejná diskuse o základnách). Kdykoli zvolili pro daný qubit stejnou základnu, přidáme bity přidružené k tomuto qubitu do seznamu bitů pro generování čísel v jednorázovém padu. Pokud základny nesouhlasí, výsledky zahodíme. Také zkontrolujeme, zda se oba seznamy bitů shodují, nebo zda došlo ke ztrátám kvůli šumu či jiným faktorům.

# 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

Alice i Bob mají seznam bitů, které se shodují se 100% věrností. Mohou je použít ke generování čísel pro jednorázový pad. Ten pak mohou použít v kroku 4 QKD: odeslání a dešifrování tajné zprávy. Současné pole bitů je příliš krátké pro dešifrování čehokoli podstatného. Vrátíme se k tomu poté, co zahrneme odposlech.

Ověř si své porozumění​

Přečti si níže uvedenou otázku, zamysli se nad odpovědí a pak klikni na trojúhelník, aby se zobrazilo řešení.

Předpokládej, že potřebuješ čísla dostatečně velká pro posunutí písmen anglické abecedy o celou délku abecedy nebo více, i když existují i jiná kódovací schémata. (a) Jak dlouhá zpráva v písmenech by mohla být dešifrována pomocí bitů v klíči výše? (b) Musí se tvá odpověď shodovat s odpovědí spolužáků? Proč ano nebo ne?

Odpověď:

(a) Odpověď závisí na tom, kolik náhodně zvolených základen se shodovalo mezi Alicí a Bobem. Protože existuje přibližně 50% šance, že se základny pro daný qubit shodují, očekáváme, že bude použitelných přibližně 10 z našich bitů. 9 nebo 11 bude zcela běžné. Dokonce i 4 nebo 15 není mimo rámec možností. Pro posunutí o číslo větší nebo rovno délce anglické abecedy je potřeba 5 bitů, což znamená, že pro každých 5 sdílených bitů lze jedno písmeno zakódovat. Máš-li alespoň 5 bitů sdílených Alicí a Bobem, můžeš zakódovat jedno písmeno. Máš-li alespoň 10, můžeš zakódovat 2 písmena, a tak dále. (b) Nemusí se shodovat, z důvodů uvedených v části (a).

Experiment 2: QKD s odposlechem​

Implementujeme přesně stejný protokol jako předtím. Tentokrát vložíme mezi Alici a Boba další sadu měření od Eve.

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

Qiskit patterns krok 4 (zpracování výsledků) je v tomto případě jednoduchý. Není třeba vizualizovat rozložení měření, protože jsme provedli pouze jedno měření. Eve má následující bity:

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]

Nyní musí Eve rekonstruovat stavy, které pošle Bobovi. Jak bylo popsáno v úvodu, nemá jak zjistit, zda správně odhadla kódovací základny, takže není schopna připravit přesně stejné stavy, které byly odeslány. Mohla by předpokládat, že každá volba základny byla správná, a zakódovat přesně to, co naměřila, nebo by mohla předpokládat, že zvolila základnu nesprávně, a vybrat libovolný vlastní stav opačné základny. Zde pro jednoduchost předpokládáme první možnost. Toho dosáhneme sestavením zcela nového kvantového obvodu a opakováním kroků Qiskit patterns jako dříve.

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]

Porovnejme nyní Aliciny a Bobovy bity:

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

Dříve existovala dokonalá shoda mezi bity v klíčích Alice a Boba. Nyní, kvůli zásahu Eve, vidíme, že se bity Alice a Boba liší ve 14 % případů, které by se měly shodovat, protože Alice a Bob zvolili stejné základny. To by Alice a Bob měli být schopni snadno odhalit. Spoléhání se na takové procento chyb však znamená, že existuje limit množství šumu, které jsme schopni v kvantovém kanálu tolerovat.

Experiment 3: Porovnání QKD s odposlechem a bez něj na skutečném kvantovém počítači​

Spusťme tento experiment na skutečném kvantovém počítači. Tak můžeme využít teorém o nemožnosti klonování. Zároveň skutečné kvantové počítače mají šum a vyšší míru chyb než klasické počítače. Porovnejme tedy ztrátu věrnosti našich klíčových bitů s odposlechem i bez něj, abychom se ujistili, že rozdíl je při použití skutečného kvantového počítače detekovatelný. Začneme bez odposlechu:

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

Bez odposlechu jsme dosáhli 100% věrnosti na této sadě 127 testovacích bitů, přičemž 55 základen se shodovalo a yielding použitelné klíčové bity. Nyní zopakujme tento experiment s odposlechem od Evy:

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

Zde jsme zjistili téměř 23% ztrátu věrnosti sdílených bitů způsobenou odposlechem! To je velmi dobře detekovatelné! Vezmi v úvahu, že přenos kvantových informací na dlouhé vzdálenosti může stále vnášet další šum a chyby. Zajištění toho, aby byl odposlech detekovatelný i za přítomnosti šumu a i tehdy, když Eva použije veškeré triky, které má k dispozici, je komplexní obor přesahující rámec tohoto úvodu.

Otázky​

Vyučující mohou požádat o verze těchto notebooků s klíčem odpovědí a pokyny k zařazení do běžných osnov vyplněním tohoto krátkého průzkumu o způsobu využití notebooků.

Klíčové pojmy​

  • Kvantové informace nelze kopírovat ani „klonovat".
  • Lze opakovat stejný přípravný postup k vytvoření souboru kvantových stavů, které jsou všechny stejné nebo téměř stejné.
  • Šifrovací/dešifrovací klíč (jednorázová šifra) může být sdílen mezi dvěma přáteli pomocí kvantových stavů.
  • Když dva přátelé náhodně volí základnu měření, polovina času ji zvolí různě a budou muset informace na těchto qubitech zahodit.
  • Náhodný výběr základny měření také zajišťuje, že odposlouchávač nemůže znát počáteční připravený stav, a tedy nemůže obnovit odeslaný stav. To zaručuje, že odposlech bude odhalen.

Otázky Pravda/Nepravda​

  1. P/N Při kvantové distribuci klíčů oba komunikující partneři měří každý qubit ve stejné základně.
  2. P/N Odposlouchávač zachycující kvantové informace v QKD je zákony přírody chráněn před kopírováním zachyceného kvantového stavu.
  3. P/N Jednorázová šifra je klíč pro šifrování/dešifrování bezpečných zpráv, v němž je konkrétní schéma kódování použito pouze jednou, pro jednu jednotku informace (např. jedno písmeno abecedy).

Otázky s výběrem odpovědi​

  1. Vyber možnost, která nejlépe doplní tvrzení. Jak je popsáno v tomto modulu, jednorázová šifra je sada šifrovacích/dešifrovacích klíčů, která se používá...
  • a. Pouze jednou pro jednu jednotku informace, například jedno písmeno.
  • b. Pouze jednou pro jednu zprávu.
  • c. Pouze jednou pro stanovené časové období, například jeden den.
  • d. Dokud neexistují důkazy o odposlechu.
  1. Předpokládej, že Alice a Bob volí své měřicí základny náhodně. Provedou měření. Poté sdílejí své měřicí základny a ponechají si pouze bity informací z případů, kdy použili stejnou základnu. S přibližně jakou procentuální hodnotou by jejich qubitů měly přinést použitelné bity informací (s výhradou náhodných odchylek)?
  • a. 100 %
  • b. 50 %
  • c. 25 %
  • d. 12,5 %
  • e. 0 %
  1. Poté, co Alice a Bob vyberou případy, v nichž použili stejné měřicí základny, jaké procento těchto bitů informací by se mělo shodovat, pokud by kvantový šum a chyby byly zanedbatelné?
  • a. 100 %
  • b. 50 %
  • c. 25 %
  • d. 12,5 %
  • e. 0 %
  1. Předpokládej, že Alice si své měřicí základny zvolila náhodně. Eva také volí základny náhodně a odposlouchává (měří). Poté posílá Bobovi stavy odpovídající jejím měřením. Alice a Bob porovnají volby základen a ponechají si pouze qubity, které oba měřili/připravili ve stejných základnách. Přibližně jaké procento ponechaných měření qubitů se bude shodovat podle Alice a Boba (s výhradou náhodných odchylek)?
  • a. 100 %
  • b. 75 %
  • c. 50 %
  • d. 25 %
  • e. 12,5 %
  • f. 0 %

Diskusní otázky​

  1. Předpokládej, že všechny volby základen jsou pro všechny účastníky — Alici, Boba i Evu — náhodné. Předpokládej, že poté, co Eva odposlouchá, pošle Bobovi stav připravený ve stejné základně, ve které měřila, a odpovídající tomuto měření. Přesvědč své partnery, že 12,5 % všech qubitů inicializovaných Alicí přinese neshody v měřeních mezi Alicí a Bobem, což signalizuje odposlech (ignoruj kvantové chyby a šum). Nápověda 1: Protože neexistuje preferovaná základna, uvažuješ-li jen jednu počáteční volbu pro Alici, poměr pro tuto jednu volbu by měl být stejný jako poměr pro součet všech voleb. Nápověda 2: Nemusí stačit počítat počet způsobů, jakými může něco nastat, protože některé výsledky mohou nastávat s různými pravděpodobnostmi.

  2. Předpokládej opět, že všechny volby základen jsou pro všechny účastníky — Alici, Boba i Evu — náhodné. Nyní však uvaž, že Eva může Bobovi po svém měření poslat jakýkoli stav. Mohla by dokonce zkusit posílat stavy, které jsou v rozporu s jejími vlastními měřeními. Prodiskutuj se svými partnery/sousedy, zda si myslíš, že existuje nějaká volba základen, která by mohla snížit průměrné procento qubitů signalizujících odposlech pro Alici a Boba.

Zdroj: IBM Quantum docs — aktualizováno 15. 5. 2026
Anglická verze na doQumentation — aktualizováno 15. 5. 2026
Problém s webem nebo překladem?Problém v obsahu? Upravit v IBM Quantum docs