Teleportacja kwantowa

Na potrzeby tego modułu Qiskit w klasach uczniowie muszą mieć działające środowisko Python z zainstalowanymi następującymi pakietami:

• qiskit v2.1.0 lub nowszy
• qiskit-ibm-runtime v0.40.1 lub nowszy
• qiskit-aer v0.17.0 lub nowszy
• qiskit.visualization
• numpy
• pylatexenc

Aby skonfigurować i zainstalować powyższe pakiety, zapoznaj się z przewodnikiem Instalacja Qiskit. Aby uruchamiać zadania na prawdziwych komputerach kwantowych, uczniowie będą musieli założyć konto IBM Quantum®, postępując zgodnie z krokami opisanymi w przewodniku Konfiguracja konta IBM Cloud.

Ten moduł był testowany i wykorzystał 14 sekund czasu QPU. To jedynie szacunek. Twoje rzeczywiste zużycie może się różnić.

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

Obejrzyj poniższy przewodnik po module przygotowany przez dr Katie McCormick lub kliknij tutaj, aby obejrzeć go na YouTube.

---

Wprowadzenie i tło

Teleportacja kwantowa to technika z dziedziny fizyki kwantowej, która umożliwia transfer informacji kwantowej z jednego miejsca do drugiego bez fizycznego przemieszczania cząstek. W odróżnieniu od koncepcji teleportacji rodem z science fiction, proces ten nie polega na transportowaniu materii. Zamiast tego opiera się na zasadzie splątania kwantowego, w którym dwie cząstki stają się ze sobą powiązane niezależnie od odległości. Poprzez serię precyzyjnych pomiarów i klasycznej komunikacji stan kwantowy jednej cząstki może zostać odtworzony w innej cząstce w odległym miejscu, efektywnie „teleportując" informację kwantową. W tym module zobaczymy, jak działa to matematycznie, a następnie zaimplementujemy teleportację kwantową na prawdziwym komputerze kwantowym. Poniższe wprowadzenie będzie krótkie; po więcej informacji o informacji kwantowej i dokładniejsze wyjaśnienie teleportacji zalecamy kurs Johna Watrusa dotyczący Podstaw informacji kwantowej, a w szczególności sekcję o Teleportacji.

Klasyczne bity mogą przyjmować stany 0 lub 1. Kwantowe bity (Qubit) mogą znajdować się w stanach kwantowych oznaczanych $|0\rangle$ i $|1\rangle$, a także w liniowych kombinacjach tych stanów, zwanych „superpozycjami", takich jak $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, gdzie $\alpha_0,\alpha_1 \in \mathbb{C}$ i $|\alpha_0|^2+|\alpha_1|^2 = 1$. Choć stany mogą istnieć w tej superpozycji, pomiar stanu „zawęzi" go do stanu $|0\rangle$ lub $|1\rangle$. Parametry $a$ i $b$ są powiązane z prawdopodobieństwem każdego wyniku pomiaru zgodnie z

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

Stąd warunek, że $|\alpha_0|^2+|\alpha_1|^2 = 1$.

Kolejną kluczową cechą jest to, że kwantowe bity mogą być „splątane", co oznacza, że pomiar jednego Qubit może wpływać na wynik pomiaru innego, splątanego Qubit. Zrozumienie, czym splątanie różni się od zwykłych klasycznych korelacji, jest nieco skomplikowane. Najpierw wyjaśnijmy naszą notację. Nazwijmy dwa Qubit należące do przyjaciela 0 (Alicji) i przyjaciela 1 (Boba), z których każdy jest w stanie $|0\rangle$

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

lub

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

czasami skrócone po prostu do

$$|00\rangle$$

Zauważ, że Qubit o najniższym numerze (lub literze) znajduje się najdalej po prawej stronie. Jest to konwencja zwana notacją „little-endian", stosowana w całym Qiskit. Jeśli dwuqubitowy stan przyjaciół wynosi $|00\rangle$ i zmierzą oni stan swoich odpowiednich Qubit, każde z nich znajdzie 0. Podobnie, gdyby Qubit były w stanie $|11\rangle$, każdy z ich pomiarów dałby wynik 1. To niczym nie różni się od przypadku klasycznego. Jednak w obliczeniach kwantowych możemy połączyć to z superpozycją, aby uzyskać stany takie jak

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

W takim stanie to, czy Qubit Alicji i Boba są w stanie 0 czy 1, nie jest jeszcze znane — nawet natura tego jeszcze nie wyznaczyła — a jednak wiemy, że zmierzą ten sam stan swojego Qubit. Na przykład, jeśli Bob zmierzy swój Qubit jako będący w stanie $|0\rangle$, jedynym sposobem, żeby to się stało, jest to, że pomiar zawalił dwuqubitowy stan do jednego z dwóch możliwych stanów — konkretnie do $|00\rangle$. To pozostawia Qubit Alicji również w stanie $|0\rangle$.

Splątanie Qubit w ten sposób nie wymaga, aby Qubit pozostawały fizycznie blisko siebie. Innymi słowy, możemy splątać Qubit, a następnie rozdzielić je na dużą odległość i wykorzystać ich splątanie do przesyłania informacji. Splątany stan jak powyższy jest podstawową jednostką splątania i jest czasami nazywany „e-bitem" — pojedynczym bitem splątania. Te e-bity można traktować jako zasoby w komunikacji kwantowej, ponieważ każdy e-bit współdzielony między odległymi partnerami może być używany — jak tu opisujemy — do przenoszenia informacji z jednego miejsca do drugiego.

Pierwszą myślą wielu osób uczących się o tym po raz pierwszy jest kwestia naruszenia teorii względności: czy możemy użyć tego do wysyłania informacji szybciej niż światło? Jak najbardziej — pytaj i kwestionuj zasady naukowe — ale niestety to nie pozwoli nam wysyłać informacji szybciej niż światło, z powodów, które staną się jasne w trakcie tego modułu. Spoiler: co zadziwiające, NIE jest to spowodowane prędkością, z jaką ta „zawalona" informacja się propaguje, co wydaje się dziać szybciej niż światło [1]. Zaczynamy od dwóch współpracowników — Alicji i Boba — którzy początkowo są w tym samym miejscu i mogą razem pracować na tych samych Qubit. Ci współpracownicy splątają swoje Qubit. Następnie rozdzielą się do dwóch różnych lokalizacji geograficznych, zabierając ze sobą swoje odpowiednie Qubit. Alicja następnie uzyska informację kwantową na nowym Qubit Q. Nie robimy żadnych założeń dotyczących informacji na Q. Stan Q mógłby być sekretem nieznanym Alicji; mógłby być nieznany wszystkim ludziom. Ale Alicja dostaje zadanie przeniesienia informacji z Q do Boba. Zrobi to za pomocą teleportacji kwantowej.

Aby to osiągnąć, będziemy musieli znać pewne operacje kwantowe, czyli „bramki".

Operatory kwantowe (bramki)

Możesz pominąć tę sekcję, jeśli znasz już bramki kwantowe. Jeśli chcesz lepiej zrozumieć te bramki, zapoznaj się z kursem Basics of quantum information, szczególnie z pierwszymi dwoma lekcjami, dostępnymi na IBM Quantum Learning.

W tym protokole teleportacji będziemy używać przede wszystkim dwóch rodzajów bramek kwantowych: bramki Hadamarda oraz bramki CNOT. Kilka innych odegra mniejszą rolę: bramka $X$, bramka $Z$ oraz bramka SWAP.

Ten moduł można ukończyć przy bardzo ograniczonej znajomości algebry liniowej, jednak wizualizacja bramek kwantowych za pomocą macierzy i wektorów bywa pomocna. Dlatego przedstawiamy tu również macierzowo-wektorową reprezentację bramek i stanów kwantowych.

Stany, które już omówiliśmy, przyjmują (częściowo zgodnie z konwencją, a częściowo ze względu na narzucone ograniczenia) następujące postaci wektorowe:

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

W ten sposób dowolny stan $|\psi\rangle = a|0\rangle+b|1\rangle$ można zapisać jako

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

Istnieje pewna swoboda w rozszerzeniu tej notacji na stany wieloqubitowe, ale poniższy wybór jest dość standardowy:

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

Mając na uwadze tę notację wektorową, możemy teraz przedstawić potrzebne bramki kwantowe, ich działanie na stany kwantowe oraz ich postaci macierzowe.

Bramka H Hadamarda: Tworzy stan superpozycji. Bramka jednoQubitowa.

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

Circuit z bramką Hadamarda tworzy się następująco:

from qiskit import QuantumCircuit

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

Bramka CNOT (Controlled-NOT): Ta bramka wykorzystuje dwa Qubity: sterujący i docelowy. Sprawdza stan Qubitu sterującego, który pozostaje niezmieniony. Jeśli jednak Qubit sterujący jest w stanie $|1\rangle$, bramka zmienia stan Qubitu docelowego; jeśli Qubit sterujący jest w stanie $|0\rangle$, żadna zmiana nie jest wprowadzana. W poniższej notacji przyjmijmy, że Qubit $A$ (skrajny prawy) jest sterującym, a Qubit $B$ (skrajny lewy) jest docelowym. Notacja poniżej przyjmuje postać $CNOT(q_{control},q_{target})|BA\rangle.$

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

Zapis CNOT bywa niekiedy stosowany bez jawnego wskazania kolejności Qubitu sterującego i docelowego. W kodzie oraz na diagramach Circuit nie ma jednak żadnej dwuznaczności.

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

Bramka CNOT wygląda nieco inaczej w Circuit, ponieważ wymaga dwóch Qubitów. Oto jej implementacja:

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

Sprawdź swoją wiedzę

Przeczytaj poniższe pytanie, zastanów się nad odpowiedzią, a następnie kliknij trójkąt, aby ujawnić rozwiązanie.

Większość bramek ma tę samą postać macierzową w Qiskit co wszędzie indziej. Bramka CNOT działa jednak na dwa Qubity, przez co konwencje kolejności Qubitów nabierają znaczenia. Teksty, w których Qubity są uporządkowane jako $|q_0,q_1,...\rangle$, będą pokazywać inną postać macierzową bramki CNOT. Zweryfikuj przez jawne mnożenie macierzowe, że powyższa macierz CNOT działa poprawnie na stan $|01\rangle.$

Odpowiedź:

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

Bramka $X$: Odpowiednik operacji NOT. Bramka jednoQubitowa.

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

W Qiskit tworzenie Circuit z bramką $X$ wygląda następująco:

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

Bramka $Z$: Dodaje „fazę" do stanu (współczynnik, który dla stanów własnych Z, czyli $|0\rangle$ i $|1\rangle$, wynosi odpowiednio 1 lub -1). Bramka jednoQubitowa.

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

W Qiskit tworzenie Circuit z bramką $Z$ wygląda następująco:

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

Teoria

Opiszmy matematycznie protokół kwantowej teleportacji. W kolejnej sekcji zrealizujemy ten schemat na komputerze kwantowym.

Alice i Bob splatają swoje Qubity: Na początku Qubit Alice i Qubit Boba są oddzielnie w stanie $|0\rangle$ (to rozsądne założenie, a zarazem właściwa inicjalizacja komputerów kwantowych IBM®). Możemy to zapisać jako $|0\rangle_B|0\rangle_A$ lub po prostu $|00\rangle$. Obliczmy, co się dzieje, gdy Alice i Bob zastosują bramkę Hadamarda na Qubicie Alice, a następnie bramkę CNOT z Qubitem Alice jako kontrolnym i Qubitem Boba jako docelowym:

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

Zauważ, że teraz Qubity Alice i Boba są splątane. Choć natura nie zdecydowała jeszcze, czy oba Qubity są w stanie $|0\rangle$, czy $|1\rangle$, wiadomo, że będą w tym samym stanie. Alice i Bob się rozdzielają: Dwoje znajomych przenosi swoje Qubity do nowych lokalizacji, potencjalnie bardzo odległych od siebie. Wiąże się to z wieloma zastrzeżeniami: przenoszenie informacji kwantowej bez jej zakłócania nie jest trywialne. Można to jednak zrobić – i rzeczywiście zrobisz to w tym module. Pamiętaj jednak, że przenoszenie informacji kwantowej wiąże się z ryzykiem wystąpienia błędów.

Wprowadzamy Q: Na Qubicie Q przygotowywany jest tajny stan:

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

W tym momencie Q sąsiaduje po prostu z Qubitem Alice (A). Nie doszło do żadnego splątania, więc stan kwantowy wszystkich trzech Qubitów razem można zapisać jako:

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

Celem jest przeniesienie informacji z Q z lokalizacji Alice do lokalizacji Boba. Na tym etapie nie stawiamy żadnych wymagań co do tajności ani szybkości transferu informacji. Badamy po prostu, w jaki sposób informacja może przejść od Alice do Boba. Ponieważ informacja zaczyna się na Q, przyjmiemy, że Q otrzymuje najniższy numer wśród Qubitów, przez co w notacji little-endian Q będzie najbardziej wysunięty w prawo w poniższych wzorach.

Alice splata Qubity A i Q: Alice stosuje teraz bramkę CNOT z własnym Qubitem jako kontrolnym i Q jako docelowym, a następnie przykłada bramkę Hadamarda do Q. Obliczmy trójkubitowy stan po tej operacji:

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

Ponieważ A i Q znajdują się w tym samym miejscu, pogrupujmy powyższe wyrazy według wyników pomiarów Qubitów A i Q:

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

Sprawdź swoje zrozumienie

Przeczytaj poniższe pytanie, zastanów się nad odpowiedzią, a następnie kliknij trójkąt, aby zobaczyć rozwiązanie.

Korzystając z powyższego wyrażenia na stany wszystkich trzech Qubitów, jakie jest prawdopodobieństwo, że pomiar Qubitów A i Q da wynik $|0\rangle_A|0\rangle_Q?$

Odpowiedź:

25%. Aby to zobaczyć, przypomnij sobie, że stan Boba musi być znormalizowany, więc $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Teraz Alice może zmierzyć Qubity A i Q. Nie może kontrolować wyniku tego pomiaru, ponieważ pomiary kwantowe są probabilistyczne. Kiedy więc dokonuje pomiaru, możliwe są 4 wyniki, wszystkie jednakowo prawdopodobne: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q$ oraz $|1\rangle_A|1\rangle_Q.$ Zauważ, że każdy wynik ma inne konsekwencje dla Qubitu Boba. Na przykład, jeśli Alice stwierdzi, że jej Qubity są w stanie $|0\rangle_A|0\rangle_Q,$ to cały trójkubitowy stan kwantowy zostaje zredukowany do $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Inne wyniki pomiaru Alice dają Bobowi różne stany. Zostały one zebrane w poniższej tabeli.

Wynik Alice	Stan Boba	Instrukcja dla Boba	Wynik
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Brak	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$, a następnie $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Dla wszystkich możliwych wyników pomiaru Qubitów Alice, Qubit Boba pozostaje w stanie przypominającym tajny stan pierwotnie zapisany na Q. Gdy Alice zmierzy $	0\rangle_C	0\rangle_A$(pierwszy wiersz tabeli), Qubit Boba jest dokładnie w tajnym stanie! W pozostałych przypadkach coś się nie zgadza: współczynniki ($\alpha$) są zamienione miejscami, pojawia się znak „−" zamiast „+", albo obydwa błędy naraz. Aby zmodyfikować Qubit Boba tak, by był dokładnie równy tajnemu stanowi, Alice musi zadzwonić do Boba (skorzystać z jakiegoś środka klasycznej komunikacji) i poinformować go, jakie dodatkowe operacje ma wykonać na swoim Qubicie, zgodnie z tabelą. Na przykład w trzecim wierszu współczynniki są zamienione. Jeśli Alice zadzwoni do Boba i powie mu, żeby przyłożył do swojego Qubitu bramkę$X$, zamieni ona$	0\rangle$na$

Powinno być teraz jasne, dlaczego nie możemy użyć tego schematu do wysyłania informacji szybciej niż światło. Możemy mieć szczęście i zmierzyć $|0\rangle_A|0\rangle_Q,$ co oznacza, że Bob natychmiast ma tajny stan. Ale Bob nie wie o tym, dopóki nie zadzwonimy do niego i nie powiemy mu: „Zmierzyliśmy $|0\rangle_A|0\rangle_Q$, więc nie musisz nic robić."

W eksperymencie myślowym Qubity są często fizycznie rozdzielone i przenoszone do nowej lokalizacji. Komputery kwantowe IBM® używają Qubitów w stanie stałym na chipie, których nie można rozdzielić. Zamiast więc przenosić Alice i Boba do różnych miejsc, rozdzielimy informację na samym chipie, używając tzw. „bramek SWAP" do przesuwania informacji z jednego Qubitu na drugi.

Eksperyment 1: Podstawowa teleportacja

IBM Quantum zaleca podejście do problemów kwantowych za pomocą platformy, którą nazywamy „wzorcami Qiskit" (ang. Qiskit patterns). Składa się ona z następujących kroków:

• Krok 1: Odwzoruj swój problem na obwód kwantowy
• Krok 2: Zoptymalizuj obwód pod kątem uruchamiania na rzeczywistym sprzęcie kwantowym
• Krok 3: Wykonaj zadanie na komputerach kwantowych IBM przy użyciu Runtime Primitives
• Krok 4: Przetwarzaj wyniki końcowe

Krok 1: Odwzoruj problem na obwód kwantowy

Cała matematyka, którą wykonaliśmy powyżej, stanowi zarys kroku 1. Teraz go zrealizujemy — zbudujemy obwód kwantowy przy użyciu Qiskit! Zaczynamy od stworzenia obwodu kwantowego z trzema qubitami i splątania dwóch qubitów Alice i Boba. Przyjmiemy, że będą to qubity 1 i 2, a qubit 0 zarezerwujemy na stan tajny.

# Step 1: Map your problem to a quantum circuit

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

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

cr = ClassicalRegister(3, "c")

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

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

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

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

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

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

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

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

qc.draw(output="mpl")

To wszystko, co trzeba zrobić, aby stan Alice został steleportowany do Boba. Pamiętaj jednak, że gdy mierzymy stan kwantowy $\alpha_0 |0\rangle+\alpha_1|1\rangle$, uzyskujemy albo $|0\rangle$, albo $|1\rangle$. Zatem po zakończeniu całego procesu Bob na pewno ma tajny stan Alice, ale nie możemy tego łatwo zweryfikować zwykłym pomiarem. Żeby pomiar powiedział nam, że zrobiliśmy to poprawnie, musimy zastosować pewien trik. Użyliśmy operatora oznaczonego „U" (od „unitary" — unitarny), którym przygotowaliśmy tajny stan Alice. Możemy zastosować odwrotność U na końcu naszego obwodu. Jeśli U przekształciło stan $|0\rangle$ Alice w $\alpha_0 |0\rangle+\alpha_1|1\rangle$, to odwrotność U przekształci stan Boba $\alpha_0 |0\rangle+\alpha_1|1\rangle$ z powrotem w $|0\rangle$. Ten ostatni krok nie byłby więc konieczny, gdyby celem było jedynie przeniesienie informacji kwantowej. Robimy go wyłącznie po to, by sprawdzić poprawność naszego działania.

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

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

qc.draw(output="mpl")

Jeśli zatem wszystko zrobiliśmy poprawnie, pomiar qubitu Boba powinien dać stan $|0\rangle$. Oczywiście pomiary te są probabilistyczne. Jeśli więc nawet istnieje małe prawdopodobieństwo uzyskania stanu $|1\rangle$ dla qubitu Boba, to pojedynczy pomiar może właśnie taki wynik dać. Naprawdę chcielibyśmy wykonać wiele pomiarów, aby upewnić się, że prawdopodobieństwo $|0\rangle$ jest bardzo wysokie.

Krok 2: Zoptymalizuj problem pod kątem wykonania kwantowego

Ten krok przekształca operacje, które chcemy wykonać, na postać zgodną z możliwościami konkretnego komputera kwantowego. Dokonuje też odwzorowania naszego problemu na układ topologiczny komputera kwantowego.

Zaczniemy od załadowania kilku pakietów niezbędnych do komunikacji z komputerami kwantowymi IBM. Musimy też wybrać Backend, na którym będziemy uruchamiać zadania. Możemy wybrać najmniej zajęty Backend lub wskazać konkretny Backend, którego właściwości znamy.

Poniżej znajduje się kod służący do jednorazowego zapisania poświadczeń. Pamiętaj, by po zapisaniu ich w środowisku usunąć te informacje z notatnika — w ten sposób nie udostępnisz przypadkowo swoich danych uwierzytelniających razem z notatnikiem. Więcej wskazówek znajdziesz w przewodnikach Set up your IBM Cloud account oraz Initialize the service in an untrusted environment.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

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

# Load saved credentials
service = QiskitRuntimeService()

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

ibm_sherbrooke

Jawnie włączamy logikę warunkową na pomiarach.

from qiskit.circuit import IfElseOp

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

Teraz musimy dokonać „transpilacji" obwodu kwantowego. Proces ten obejmuje wiele podkroków i jest fascynującym zagadnieniem. Jako przykład podkroku: nie wszystkie komputery kwantowe mogą bezpośrednio realizować wszystkie bramki logiczne z Qiskit. Musimy zapisać bramki z naszego obwodu w terminach bramek, które dany komputer kwantowy może wykonać. Ten i inne procesy możemy przeprowadzić za pomocą wstępnie skonfigurowanego menedżera przejść (ang. preset pass manager). Ustawienie optimization = 3 (najwyższy poziom optymalizacji) zapewnia, że odwzorowanie z naszego abstrakcyjnego obwodu kwantowego na instrukcje przekazywane komputerowi kwantowemu jest tak efektywne, jak tylko może to osiągnąć nasz etap wstępnego przetwarzania.

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

Sampler to prymityw zaprojektowany do próbkowania możliwych stanów wynikających z obwodu kwantowego oraz zbierania statystyk dotyczących tego, jakie stany mogą być zmierzone i z jakim prawdopodobieństwem. Importujemy tutaj Sampler z Qiskit Runtime:

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

sampler = Sampler(mode=backend)

Nie wszystkie obliczenia na komputerze kwantowym można w rozsądny sposób symulować na komputerach klasycznych. Ta prosta teleportacja zdecydowanie tak, choć wcale nie jest zaskoczeniem, że możemy klasycznie zapisać informacje w jednym lub innym miejscu. Zdecydowanie zalecamy przeprowadzanie tych obliczeń na prawdziwym komputerze kwantowym IBM. Jeśli jednak wyczerpałeś(-aś) miesięczny bezpłatny limit lub coś musi zostać ukończone podczas zajęć i nie może czekać w kolejce, ten moduł można zrealizować za pomocą symulatora. W tym celu po prostu uruchom poniższą komórkę i odkomentuj odpowiednie linie w krokach „Execute".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

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

noise_model = NoiseModel.from_backend(backend)

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

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

Krok 3: Wykonaj

Użyj Sampler, aby uruchomić zadanie, przekazując obwód jako argument.

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

Krok 4: Końcowe przetwarzanie i analiza

Wyrysujmy wyniki i je zinterpretujmy.

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

plot_histogram(counts)

Sprawdź swoje rozumienie

Przeczytaj poniższe pytanie, zastanów się nad odpowiedzią, a następnie kliknij trójkąt, aby ujawnić rozwiązanie.

Które ze stanów powyżej wskazują na pomyślną teleportację i skąd to wiesz?

Odpowiedź:

Stany $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ są wszystkie zgodne z pomyślną teleportacją. Wynika to z tego, że dodaliśmy bramkę odwracającą początkowe przygotowanie tajnego stanu. Jeśli tajny stan został pomyślnie steleportowany do qubitu Boba, ta dodatkowa bramka powinna przywrócić qubit Boba do stanu $|0\rangle$. Zatem każdy stan powyżej, w którym qubit Boba (qubit 0, zmierzony na 0-tym elemencie rejestru klasycznego, a więc najbardziej po prawej stronie) jest w stanie $|0\rangle$, oznacza sukces.

Ten wykres przedstawia wszystkie wyniki pomiarów dla trzech qubitów, w trakcie 5000 prób, czyli „strzałów" (ang. shots). Wskazaliśmy wcześniej, że Alice będzie mierzyć wszystkie możliwe stany qubitów A i Q z równym prawdopodobieństwem. Qubity 0–2 przypisaliśmy w obwodzie odpowiednio do Q, A i B. W notacji little-endian qubit Boba jest najbardziej po lewej stronie / o najniższym numerze. Tak więc cztery słupki po lewej stronie odpowiadają qubitowi Boba w stanie $|0\rangle$, a dwa pozostałe qubity przyjmują wszystkie możliwe kombinacje z mniej więcej równym prawdopodobieństwem. Niemal wszystkie (zwykle ~95%) pomiary dają qubit Boba w stanie $|0\rangle$, co oznacza, że nasze podejście zakończyło się sukcesem! Kilka strzałów (~5%) dało qubit Boba w stanie $|1\rangle$. Logicznie rzecz biorąc, nie powinno to być możliwe. Jednak wszystkie nowoczesne komputery kwantowe w znacznie większym stopniu niż komputery klasyczne podlegają szumom i błędom. A kwantowa korekcja błędów jest wciąż rozwijającą się dziedziną.

Eksperyment 2: Teleportacja przez procesor

Zdecydowanie najciekawszym aspektem kwantowej teleportacji jest to, że stan kwantowy może być teleportowany na duże odległości natychmiastowo (choć klasyczna komunikacja dodatkowych bramek już nie jest natychmiastowa). Jak już wspomnieliśmy, nie możemy odłamać qubitów od procesora i przenosić ich w przestrzeni. Możemy jednak przenosić informację z jednego qubitu na drugi, aż qubity biorące udział w teleportacji znajdą się po przeciwnych stronach procesora. Powtórzmy teraz kroki opisane powyżej, tworząc tym razem większy Circuit z wystarczającą liczbą qubitów, by objąć cały procesor.

Krok 1: Odwzorowanie problemu na Circuit

Tym razem qubity odpowiadające Alice i Bobowi będą się zmieniać. Nie nadamy więc żadnemu konkretnemu qubitowi nazwy „A" ani „B". Zamiast tego ponumerujemy qubity i użyjemy zmiennych reprezentujących bieżącą pozycję informacji na qubitach należących do Alice i Boba. Wszystkie pozostałe kroki — z wyjątkiem bramek swap — przebiegają tak jak opisano wcześniej.

# Step 1: Map

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

qc = QuantumCircuit(qr, cr)

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

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

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

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

qc.barrier()

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

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

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

qc.barrier()

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

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

qc.barrier()

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

qc.draw("mpl")

Na diagramie Circuit widać, że kroki logiczne są takie same. Jedyna różnica polega na tym, że użyliśmy bramek swap, aby przenieść stan qubitu Alice z qubitu 6 ($A_5$) na qubit 1 ($A_0$), bezpośrednio sąsiadujący z Q. Zastosowaliśmy też bramki swap, by przenieść stan początkowy Boba z qubitu 7 ($B_0$) na qubit 12 ($B_5$). Zwróć uwagę, że stan na qubicie 12 nie ma żadnego związku z tajnym stanem Q aż do momentu wykonania pomiarów na odległych qubitach 0 i 1, a stan na qubicie 12 staje się równy tajnemu stanowi dopiero po zastosowaniu warunkowych bramek $X$ i $Z$.

Krok 2: Optymalizacja Circuit

Zwykle podczas korzystania z menedżera przebiegów (pass manager) do transpilacji i optymalizacji Circuit sensowne jest ustawienie optimization_level = 3, gdyż zależy nam na jak największej wydajności naszych Circuit. W tym przypadku nie ma jednak obliczeniowego uzasadnienia dla przenoszenia stanów z qubitów 6 i 7 na qubity 1 i 12 — zrobiliśmy to wyłącznie po to, by zademonstrować teleportację na odległość. Gdybyśmy poprosili menedżera przebiegów o optymalizację naszego Circuit, zdałby sobie sprawę, że te bramki swap nie mają logicznego uzasadnienia, i usunąłby je, wykonując operacje bramkowe na sąsiednich qubitach. Dlatego w tym szczególnym przypadku używamy optimization_level = 0.

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

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

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Możemy zwizualizować rozmieszczenie tych qubitów na procesorze kwantowym za pomocą funkcji plot_circuit_layout.

Krok 3: Wykonanie

Podobnie jak wcześniej, zalecamy uruchomienie na prawdziwych komputerach kwantowych IBM. Jeśli wyczerpałeś/-aś swój miesięczny bezpłatny limit, możesz odkomentować odpowiednie komórki symulatora i uruchomić obliczenia na symulatorze.

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

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Krok 4: Klasyczne przetwarzanie wyników

Ponownie widzimy, że prawdopodobieństwa możliwych wyników pomiarów qubitów Alice są dość równomierne. Istnieje wyraźna preferencja dla znalezienia qubitu Boba w stanie $|0\rangle$ po odwróceniu tajnego kodu, co oznacza duże prawdopodobieństwo, że poprawnie przeteleportowaliśmy tajny stan przez procesor — od Q do Boba (od qubitu 0 do qubitu 12). Zauważamy jednak, że tym razem szansa na niezmierzenie $|0\rangle$ dla Boba jest wyraźnie wyższa. To ważna lekcja z informatyki kwantowej: im więcej bramek (zwłaszcza wieloqubitowych, takich jak bramki swap) masz w swoim Circuit, tym więcej szumów i błędów możesz się spodziewać.

Pytania

Instruktorzy mogą poprosić o wersje tych notebooków z kluczami odpowiedzi i wskazówkami dotyczącymi umiejscowienia w typowych programach nauczania, wypełniając tę krótką ankietę na temat sposobu korzystania z notebooków.

Kluczowe pojęcia

• Qubity mogą być splątane, co oznacza, że pomiar jednego Qubitu wpływa na stan innego Qubitu lub nawet go determinuje.
• Splątanie różni się od klasycznych korelacji; na przykład Qubity A i B mogą znajdować się w superpozycji stanów takich jak $\alpha_0|00\rangle+\alpha_1|11\rangle.$ Stan A lub B może być nieokreślony przez naturę, a mimo to A i B mogą mieć gwarancję znajdowania się w tym samym stanie.
• Poprzez kombinację splątań i pomiarów możemy przenieść stan (który może przechowywać informacje) z jednego Qubitu do drugiego. Przeniesienie to może odbywać się nawet na duże odległości i nazywa się teleportacją kwantową.
• Teleportacja kwantowa opiera się na pomiarach kwantowych, które mają charakter probabilistyczny. Dlatego klasyczna komunikacja może być konieczna do korekty teleportowanych stanów. To uniemożliwia teleportacji kwantowej przenoszenie informacji szybciej niż światło. Teleportacja kwantowa nie narusza teorii względności ani zasady przyczynowości.
• Nowoczesne komputery kwantowe są bardziej podatne na szum i błędy niż komputery klasyczne. Należy spodziewać się kilkuprocentowego błędu.
• Im więcej bramek dodasz kolejno (zwłaszcza bramek dwu-qubitowych), tym więcej błędów i szumu możesz się spodziewać.

Pytania prawda/fałsz

1. P/F Teleportacja kwantowa może być wykorzystana do wysyłania informacji szybciej niż światło.
2. P/F Współczesne dowody sugerują, że zanik stanu kwantowego propaguje się szybciej niż światło.
3. P/F W Qiskit, Qubity są porządkowane w stanach z Qubitem o najniższym numerze po prawej stronie, jak w $|q_3,q_2,q_1, q_0\rangle$

Pytania wielokrotnego wyboru

1. Qubity A i B są splątane, a następnie rozdzielone na dużą odległość $d$. Qubit A jest mierzony. Które stwierdzenie jest poprawne dotyczące prędkości, z jaką stan Qubitu B jest zmieniany?

• a. Qubit B jest zmieniany natychmiastowo, w granicach tolerancji eksperymentalnej, w dotychczas przeprowadzonych eksperymentach.
• b. Qubit B jest zmieniany po czasie $d/c$, co oznacza, że stan kwantowy „zapada się" z mniej więcej prędkością światła, w granicach tolerancji eksperymentalnej.
• c. Qubit B jest zmieniany dopiero po przeprowadzeniu klasycznej komunikacji, co oznacza, że dzieje się to w czasie dłuższym niż $d/c$.
• d. Żadne z powyższych

2. Przypomnij sobie, że prawdopodobieństwo pomiaru jest powiązane z amplitudami w stanach kwantowych. Na przykład, jeśli Qubit początkowo jest w stanie $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ prawdopodobieństwo zmierzenia stanu $|0\rangle$ wynosi $|\alpha_0|^2.$ Nie wszystkie zestawy pomiarów będą dokładnie odpowiadać tym prawdopodobieństwom ze względu na skończone próbkowanie (podobnie jak rzut monetą może dać dwa razy z rzędu orła). Poniższy histogram pomiarów może odpowiadać któremu z następujących stanów kwantowych? Wybierz najlepszą odpowiedź.

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

3. Które z poniższych stanów pokazują splątane Qubity A i B? Wybierz wszystkie, które pasują.

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

4. W tym module przygotowaliśmy stan splątany: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Istnieje jednak wiele innych stanów splątanych, które można by zastosować w podobnym protokole. Który z poniższych stanów może dawać histogram pomiarów dwu-qubitowych podobny do przedstawionego poniżej? Wybierz najlepszą odpowiedź.

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

Pytania do dyskusji

1. Opisz protokół teleportacji kwantowej od początku do końca swojemu partnerowi/grupie. Sprawdź, czy mają coś do dodania lub czy mają pytania.

2. Czy jest coś wyjątkowego w początkowym stanie splątanym między Alice i Bobem: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Jeśli tak, co jest w nim wyjątkowego? Jeśli nie, jakich innych stanów splątanych moglibyśmy użyć?