Zacznij pracę z Qiskit w klasie

W tym module Qiskit w Klasie uczniowie muszą mieć działające środowisko Python z zainstalowanymi następującymi pakietami:

• qiskit w wersji 2.1.0 lub nowszej
• qiskit-ibm-runtime w wersji 0.40.1 lub nowszej
• qiskit-aer w wersji 0.17.0 lub nowszej
• 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 muszą założyć konto w IBM Quantum®, postępując zgodnie z instrukcjami w przewodniku Konfiguracja konta IBM Cloud®.

Ten moduł został przetestowany i wykorzystał 2 sekundy czasu QPU na procesorze Heron v2. Jest to wyłącznie szacunek. Twoje rzeczywiste zużycie może się różnić.

# Added by doQumentation — required packages for this notebook
!pip install -q 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'

Wprowadzenie

W modułach Qiskit w Klasie będziesz mieć okazję użyć komputera kwantowego do eksploracji różnych pojęć z dziedzin powiązanych z obliczeniami kwantowymi, takich jak mechanika kwantowa, informatyka, chemia i inne. Ten moduł stanowi warunek wstępny dla pozostałych — wprowadza podstawy obliczeń kwantowych oraz sposób korzystania z Qiskit do uruchamiania obwodów kwantowych.

Najpierw damy ci krótki przegląd działania klasycznego komputera, a następnie pokażemy, jak te pojęcia są adaptowane do paradygmatu obliczeń kwantowych. Na koniec pokażemy, jak połączyć te koncepcje, aby zbudować i uruchomić swój pierwszy obwód kwantowy.

Komputery klasyczne

Prawdopodobnie znasz już podstawy działania komputerów klasycznych, ale tutaj wyróżnimy kilka kluczowych cech, abyśmy mogli następnie przeprowadzić porównanie z komputerami kwantowymi.

Podstawowe jednostki informacji: bity

Komputery klasyczne przetwarzają informacje klasyczne, a podstawową jednostką informacji klasycznej jest bit. Pojedynczy bit może przechowywać odpowiedź na jedno pytanie „tak/nie". Dwa stany binarne bitu reprezentujemy zazwyczaj jako „0" i „1".

Przypomnienie liczb binarnych

Łączenie bitów pozwala przechowywać więcej informacji. Na przykład, jeśli chcesz przechować liczbę od 0 do 15, możesz to zrobić za pomocą czterech bitów w następujący sposób:

0 = 0000	4 = 0100	8 = 1000	12 = 1100
1 = 0001	5 = 0101	9 = 1001	13 = 1101
2 = 0010	6 = 0110	10 = 1010	14 = 1110
3 = 0011	7 = 0111	11 = 1011	15 = 1111

Ogólnie rzecz biorąc, aby przekonwertować liczbę binarną o $N$ bitach na znajomą liczbę w systemie dziesiętnym, mnożysz bit o najmniejszym znaczeniu (skrajny prawy) przez $2^0 = 1$, następny bit z lewej przez $2^1 = 2$, kolejny przez $2^2 = 4$ i tak dalej, aż do bitu o największym znaczeniu (skrajny lewy), który mnożysz przez $2^{N-1}$.

A zatem $N$ bitów może znajdować się w jednym z $2^N$ różnych możliwych stanów.

Sprawdź swoją wiedzę

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

Ile bitów potrzeba, aby zapisać liczbę 86? Napisz bitstring kodujący tę liczbę w systemie binarnym.

Odpowiedź:

Pamiętaj, że $N$ bitów pozwala reprezentować liczby od $0$ do $2^N - 1$, więc sześć bitów daje nam zakres do $2^6 - 1 = 63$. To trochę za mało. Dodajemy jeszcze jeden bit, aby uzyskać zakres do $2^7 - 1 = 127$. Teraz rozłóżmy 86 na potęgi liczby 2:

$$\begin{aligned} 86 &= 64 + 16 + 4 + 2 \\ &= 2^6 \times 1 + 2^5 \times 0 + 2^4 \times 1 + 2^3 \times 0 + 2^2 \times 1 + 2^1 \times 1 + 2^0 \times 0 \\ &= 1010110 \end{aligned}$$

Podstawowe operacje: bramki

Komputer musi być w stanie coś robić z bitami, aby móc — no cóż — obliczać. Bramki binarne to operacje stanowiące podstawowe elementy składowe wszystkich bardziej skomplikowanych algorytmów i kodów.

Bramka jednobitowa:

NOT

Gdy masz tylko jeden bit, istnieje tylko jeden sposób na zmianę jego stanu: odwrócenie stanu z 0 na 1 lub z 1 na 0. Nazywamy to bramką „NOT". Efekt tej bramki — i pozostałych bramek omawianych poniżej — można przedstawić w tak zwanej „tabeli prawdy", z kolumnami dla stanów wejściowych i wyjściowych kubitów. Tabela prawdy dla bramki NOT wygląda następująco:

Wejście	Wyjście
0	1
1	0

Bramki wielobitowe:

AND

AND to bramka dwubitowa, która przyjmuje dwa bity wejściowe i daje jeden bit wyjściowy. Zwraca 1, jeśli oba bity wejściowe wynoszą 1, w przeciwnym razie 0:

Wejście	Wyjście
00	0
01	0
10	0
11	1

OR

OR to kolejna bramka dwubitowa z jednym bitem wyjściowym. Zwraca 1, jeśli którykolwiek z bitów wynosi 1:

Wejście	Wyjście
00	0
01	1
10	1
11	1

XOR

XOR oznacza „exclusive OR" (wyłączne OR) i działa jak bramka OR, ale zwraca 1 tylko wtedy, gdy dokładnie jeden z bitów wejściowych wynosi 1. Zwraca 0, jeśli oba wynoszą 1 lub oba wynoszą 0:

Wejście	Wyjście
00	0
01	1
10	1
11	0

Pomiary:

Zazwyczaj, ucząc się o obliczeniach klasycznych, nie poświęca się zbyt wiele uwagi procesowi odczytu stanu bitów. Wynika to z faktu, że nie jest to zbyt skomplikowane z konceptualnego punktu widzenia. Możesz mierzyć bity w dowolnym momencie — przed, w trakcie lub po obliczeniach — i nie wpływa to na wynik. W obliczeniach kwantowych sytuacja jest inna, jak omówimy poniżej.

Obwody:

Łącząc powyższe bramki, możesz wykonać dowolną operację na komputerze. Weźmy prosty przykład: używając bramek AND i XOR, można zbudować obwód półsumatora, który oblicza sumę dwóch bitów. Jest to przedstawione na schemacie obwodu logicznego, gdzie przewody reprezentują bity, a bramki operujące na bitach są pokazane jako symbole na odpowiednich przewodach:

A zatem dwa bity są kopiowane i przepuszczane zarówno przez bramkę AND, jak i XOR. Wynik bramki XOR to „bit sumy" (S), który pozostaje na miejscu jedności liczby binarnej, natomiast wynik bramki AND to „bit przeniesienia" (C), który jest wartością kolejnej najbardziej znaczącej cyfry w liczbie binarnej. Oto tabela prawdy:

$A$	$B$	Suma ($A \oplus B$)	Przeniesienie ($A \wedge B$)
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

Sprawdź swoją wiedzę

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

Zweryfikuj, że powyższa tabela prawdy daje poprawny wynik dla obwodu sumatora. To znaczy, dla każdej z czterech kombinacji A i B, sprawdź, czy $A+B=S+2 \times C$.

Odpowiedź:

$$\begin{aligned} 0+0 &= 0+0 = 0 ~\checkmark \\ 0+1 &= 1+0 = 1 ~\checkmark \\ 1+0 &= 1+0 = 1 ~\checkmark \\ 1+1 &= 0+2 = 2 ~\checkmark \\ \end{aligned}$$

Komputery kwantowe

Bity $\rightarrow$ kubit

Tak jak bity są podstawowymi jednostkami klasycznej informacji, kwantowe bity, czyli „kubit", są podstawowymi jednostkami informacji kwantowej. Podobnie jak klasyczny bit, stan kubitu może wynosić 0 lub 1, co zwykle oznaczamy jako $\vert 0\rangle$ i $\vert 1\rangle$. Jednak w przeciwieństwie do klasycznego bitu, kubit może też znajdować się w superpozycji stanu $\vert 0\rangle$ i stanu $\vert 1\rangle$ jednocześnie. Ogólnie rzecz biorąc, kubit może być w dowolnym stanie $\vert \psi\rangle$ postaci:

$$\vert \psi\rangle = c_0 \vert 0\rangle + c_1 \vert 1\rangle$$

gdzie $c_0$ i $c_1$ są zespolonymi amplitudami spełniającymi warunek $\vert c_0 \vert ^2+\vert c_1\vert ^2=1$.

Faza kwantowa

Ponieważ $c_0$ i $c_1$ są zespolone, każdą z nich można zapisać jako $c_i = \vert c_i\vert e^{i\phi_i}$, gdzie $\phi_i$ nazywamy fazą. Jeśli pomnożymy cały stan przez ten sam globalny czynnik fazowy, nic fizycznie się nie zmienia — nazywamy to fazą globalną i nie ma ona żadnych obserwowalnych konsekwencji.

Z tego powodu przyjęło się „wyłączać" $e^{i\phi_0}$ przed nawias, co daje:

$\vert \psi\rangle = \vert c_0\vert \vert 0\rangle + \vert c_1\vert e^{i\phi}\vert 1\rangle$

gdzie $\phi = \phi_1-\phi_0$ jest względną fazą stanu kwantowego, która ma obserwowalne konsekwencje.

Faza ta odgrywa bardzo ważną rolę w obliczeniach kwantowych — jej różnorodne konsekwencje poznasz w kolejnych modułach Qiskit w klasie.

Wiele kubitów

O ile stan wielu bitów można było wyrazić po prostu jako ciąg zer i jedynek, o tyle stan wielu kubitów jest nieco bardziej skomplikowany ze względu na zasady superpozycji i splątania.

Przypomnij sobie, że $N$ bitów może przyjmować jeden z $2^N$ możliwych stanów — od binarnego 000...000 do 111...111. Teraz jednak, dzięki zasadzie superpozycji, $N$ kubitów może być jednocześnie w superpozycji wszystkich tych stanów!

Można to wyrazić jako

$$\psi_N = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$$

gdzie, podobnie jak w przypadku klasycznym, stan $\vert i\rangle$ odpowiada stanowi, w którym każdy kubit przyjmuje odpowiednią kombinację zer i jedynek tworzącą liczbę binarną $i$. Stany te znane są jako „obliczeniowe stany bazowe" układu kwantowego. Na przykład stan trzech kubitów można zapisać jako superpozycję ośmiu obliczeniowych stanów bazowych:

$$\psi_3 = c_0 \vert 000\rangle + c_1 \vert 001\rangle + c_2 \vert 010\rangle + c_3 \vert 011\rangle + c_4 \vert 100\rangle + c_5 \vert 101\rangle + c_6 \vert 110\rangle + c_7 \vert 111\rangle$$

Każdy kubit w układzie jest oznaczony indeksem od $0$ do $N-1$. Przyjęta konwencja zakłada odczytywanie stanów kubitów od prawej do lewej, tak że stan kubitu $0$ jest stanem znajdującym się najdalej po prawej, a stan kubitu $N-1$ — najdalej po lewej. Taka notacja nazywa się „little-endian" i może początkowo wydawać się nieintuicyjna, skoro jesteśmy przyzwyczajeni do czytania od lewej do prawej.

Sprawdź swoje rozumienie

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

Na pierwszy rzut oka porządkowanie kubitów od prawej do lewej, jak w notacji little-endian, może wydawać się nieintuicyjne, lecz jest to w rzeczywistości bardzo logiczne! Wyjaśnij dlaczego. (Przypomnij sobie omówiony wcześniej sposób zamiany liczb binarnych na dziesiętne.)

Odpowiedź:

Jeśli kubity numerujemy od prawej do lewej, tak że kubit 0 jest najdalej po prawej, a kubit N-1 najdalej po lewej, logiczne jest powiązanie kubitu $0$ z bitem najmniej znaczącym, mnożonym przez $2^0$, oraz kubitu $N-1$ z bitem najbardziej znaczącym, mnożonym przez $2^{N-1}$.

Splątanie

Jak wspomnieliśmy wcześniej, kolejną kluczową właściwością kubitów jest możliwość splątania ich ze sobą. Weźmy przykład stanu dwóch kubitów, gdzie $c_0 = c_3 = \frac{1}{\sqrt{2}}$ i $c_1 = c_2 = 0$:

$\vert \psi\rangle = \frac{1}{\sqrt{2}}(\vert 00\rangle + \vert 11\rangle)$

Stan kubitu 0 może być zatem równy $\vert 0\rangle$ lub $\vert 1\rangle$ z jednakowym prawdopodobieństwem — tak samo w przypadku kubitu 1. Jednak te prawdopodobieństwa nie są już od siebie niezależne. Jeśli zmierzymy stan kubitu 0 i okaże się, że wynosi $\vert 0\rangle$, to wiemy, że kubit 1 również będzie w stanie $\vert 0\rangle$. Jest to prawdą niezależnie od tego, jak daleko od siebie się znajdują — dlatego pomiar splątanego stanu bywa określany mianem „upiornego działania na odległość".

Splątanie może przybierać też inne formy. Na przykład stan

$\vert \psi\rangle = \frac{1}{\sqrt{2}}(\vert 01\rangle + \vert 10\rangle)$

za każdym razem daje przeciwne wyniki: jeśli jeden kubit zostaje zmierzony jako $\vert 0\rangle$, drugi z pewnością znajdzie się w stanie $\vert 1\rangle$.

Sprawdź swoje rozumienie

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

Czy stan $\vert \psi\rangle = \vert 11\rangle$ jest splątany? Dlaczego tak lub dlaczego nie?

Odpowiedź:

Nie jest splątany. Choć wyniki pomiaru obu kubitów są zawsze takie same, wynika to jedynie z tego, że każdy kubit jest na stałe w stanie $\vert 1\rangle$. Wynik pomiaru jednego kubitu faktycznie nie zależy od drugiego — oba po prostu zawsze wynoszą $\vert 1\rangle$.

Ogólnie rzecz biorąc, jeśli możesz opisać stan każdego kubitu osobno, a następnie pomnożyć je przez siebie w taki sposób:

$\vert \psi\rangle = \vert \psi_1\rangle \vert \psi_0\rangle$

to taki stan nazywamy „stanem produktowym" i nie jest on splątany.

Notacja wektorowa

Często przydatne jest użycie wektorów i macierzy, by zobaczyć, jak stan kwantowy przekształca się pod wpływem różnych operacji. W tej reprezentacji stany kwantowe są wektorami, a bramki kwantowe (omówione w następnej sekcji) — macierzami przekształcającymi te wektory.

Dla pojedynczego kubitu wektorowe postacie stanów przyjmuje się jako: $\vert 0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$ $\vert 1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$ W ten sposób dowolny stan $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ można zapisać jako $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

Dla ogólnego stanu $n$ kubitów potrzebujemy wektora o $2^n$ wymiarach, ze stanami bazowymi uporządkowanymi w rosnącym porządku binarnym, zgodnie z oczekiwaniami:

$$\vert 0 \dots 000\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ \vdots \\ 0\end{pmatrix}, \vert 0 \dots 001 \rangle = \vert 1 \dots 110\rangle = \begin{pmatrix}0 \\ \vdots \\ 0 \\ 1 \\ 0\end{pmatrix}, \vert 1 \dots 111 \rangle = \begin{pmatrix}0 \\ \vdots \\ 0 \\ 0\\ 1\end{pmatrix}$$

Mając tę notację wektorową na uwadze, możemy przejść do potrzebnych bramek kwantowych, ich działania na stany kwantowe oraz ich postaci macierzowych.

Sprawdź swoje rozumienie

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

Dla układu dwóch kubitów istnieją cztery obliczeniowe stany bazowe. Zapisz każdy z nich w notacji ket oraz w notacji wektorowej.

Odpowiedź:

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

Bramki $\rightarrow$ bramki kwantowe

Podobnie jak klasyczne bramki, takie jak NOT, AND, OR i XOR, można łączyć w celu budowania dowolnych klasycznych obwodów, kwantowe bramki odgrywają tę samą rolę w obliczeniach kwantowych. Ponieważ kubity posiadają dodatkowe właściwości mechaniki kwantowej, kwantowe bramki są odpowiednio bogatsze. Choć nadal możemy opisać ich działanie na stany bazowe $|0\rangle$ i $|1\rangle$ za pomocą tablicy prawdy, nie oddaje to pełnego obrazu. W przypadku kwantowych bramek często bardziej naturalne jest użycie reprezentacji macierzowej, ponieważ działają one również na superpozycje stanów bazowych.

Poniżej przedstawimy najczęściej stosowane kwantowe bramki i sposób, w jaki przekształcają one oddziałujące z nimi kubity. Tam, gdzie to możliwe, połączymy je ze znajomymi klasycznymi bramkami.

Jednobitowe bramki (Single-qubit gates)

Bramka $X$: Jest to kwantowy odpowiednik operacji NOT. Jej tablica prawdy wygląda dokładnie tak jak klasyczna bramka NOT:

Wejście	Wyjście
$\vert 0\rangle$	$\vert 1\rangle$
$\vert 1\rangle$	$\vert 0\rangle$

Reprezentacja macierzowa:

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

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

from qiskit import QuantumCircuit

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

W tym bardzo prostym diagramie obwodu kubit jest reprezentowany przez przewód – czarną poziomą linię – a bramka pojawia się jako prostokąt na tym przewodzie.

Bramka Hadamarda: Tworzy stan superpozycji. Tablica prawdy:

Wejście	Wyjście
$\vert 0\rangle$	$\frac{1}{\sqrt{2}}\left(\vert 0\rangle+\vert 1\rangle\right)$
$\vert 1\rangle$	$\frac{1}{\sqrt{2}}\left(\vert 0\rangle-\vert 1\rangle\right)$

Reprezentacja macierzowa: $H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$

Obwód z bramką Hadamarda tworzy się w następujący sposób:

from qiskit import QuantumCircuit

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

Bramka $Z$: Dodaje przesunięcie fazowe $\Delta \phi = \pi$ do stanu $|1\rangle$:

Wejście	Wyjście
$\vert 0\rangle$	$\vert 0\rangle$
$\vert 1\rangle$	$-\vert 1\rangle$

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

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

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

Bramka $T$: Dodaje przesunięcie fazowe $\Delta \phi = \pi/4$ do stanu $|1\rangle$:

Wejście	Wyjście
$\vert 0\rangle$	$\vert 0\rangle$
$\vert 1\rangle$	$e^{i\pi/4}\vert 1\rangle$

$T=\begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$

W Qiskit tworzenie obwodu z bramką $T$ wygląda następująco:

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

Wielobitowe bramki (Multi-qubit gates)

Dwubitowe bramki mogą przypominać klasyczne bramki dwubitowe, ale z jednym istotnym zastrzeżeniem: wszystkie kwantowe bramki muszą być odwracalne. W terminologii algebry liniowej oznacza to, że są reprezentowane przez macierze unitarne. Dlatego dwa wejściowe kubity zawsze odwzorowują się na dwa wyjściowe kubity, a operację można co do zasady cofnąć. Stoi to w sprzeczności z klasycznymi bramkami, takimi jak AND czy OR, które tracą informację i są nieodwracalne – znając wyjście, nie możesz jednoznacznie ustalić wejścia.

Bramka CNOT (Controlled-NOT): Dwa wejściowe kubity noszą nazwy kubitu „sterującego" (control) i kubitu „docelowego" (target). Kubit sterujący pozostaje niezmieniony, lecz jego stan decyduje o tym, co dzieje się z kubitem docelowym. Jeśli kubit sterujący jest w stanie $\vert 1\rangle$, to bramka $X$ jest stosowana do kubitu docelowego; jeśli stan kubitu sterującego wynosi $\vert 0\rangle$, żadna zmiana nie jest wprowadzana. W poniższej notacji zakładamy, że kubit $A$ (skrajny prawy) jest sterującym, a kubit $B$ (skrajny lewy) jest docelowym. Poniżej stosowana notacja to $CNOT(q_{control},q_{target})\vert BA\rangle.$

$CNOT(A,B)\vert BA\rangle_{input} = \vert BA\rangle_{output}$

Wejście	Wyjście
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 11\rangle$
$\vert 10\rangle$	$\vert 10\rangle$
$\vert 11\rangle$	$\vert 01\rangle$

Zatem macierz reprezentująca tę operację to:

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

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

To pierwszy diagram obwodu, który widzimy z dwoma kubitami, reprezentowanymi przez dwa przewody. Bramka CNOT jest zastosowana między dwoma kubitami, przy czym $q_0$ pełni rolę sterującego, a $q_1$ docelowego.

Sprawdź swoje zrozumienie

Przeczytaj poniższe pytanie(-a), zastanów się nad odpowiedzią, a następnie kliknij trójkąt, aby odsłonić rozwiązanie.

Większość bramek ma tę samą postać macierzową w Qiskit co wszędzie indziej. Jednak bramka CNOT działa na dwa kubity, więc nagle konwencje kolejności kubitów stają się problemem. Teksty, które porządkują kubity jako $\vert q_0,q_1,...\rangle$, będą pokazywać inną postać macierzową bramki CNOT. Zweryfikuj przez jawne mnożenie macierzy, że powyższa macierz CNOT ma właściwe działanie na stan $\vert 01\rangle.$

Odpowiedź:

$CNOT\vert 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} = \vert 11\rangle$

Bramka SWAP: Ta bramka zamienia stany dwóch kubitów. Tablica prawdy:

Wejście	Wyjście
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 10\rangle$
$\vert 10\rangle$	$\vert 01\rangle$
$\vert 11\rangle$	$\vert 11\rangle$

Zatem macierz reprezentująca tę operację to:

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

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

Bramkę SWAP można w rzeczywistości zbudować z trzech bramek CNOT. Aby zobaczyć jak, możemy rozłożyć (decompose()) bramkę za pomocą Qiskit:

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

Widzimy tu po raz pierwszy, jak wiele bramek jest przedstawianych w diagramie obwodu. Czytamy go od lewej do prawej, więc skrajnie lewa bramka jest stosowana jako pierwsza.

Sprawdź swoje zrozumienie

Przeczytaj poniższe pytanie(-a), zastanów się nad odpowiedzią, a następnie kliknij trójkąt, aby odsłonić rozwiązanie.

Zweryfikuj, że powyższa kombinacja bramek CNOT daje w wyniku bramkę SWAP. Możesz to zrobić poprzez mnożenie macierzy lub dowolną inną metodę.

Odpowiedź:

Za pomocą mnożenia macierzy:

$\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0\end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1\end{pmatrix} = SWAP ~\checkmark$

Za pomocą tablicy prawdy, aby zobaczyć jak stany zmieniają się przy każdym CNOT. W ostatniej kolumnie stany powinny odpowiadać kolumnie „wyjście" tablicy prawdy SWAP:

Wejście	CNOT(A,B)	CNOT(B,A)	CNOT(A,B)
$\vert 00\rangle$	$\vert 00\rangle$	$\vert 00\rangle$	$\vert 00\rangle \checkmark$
$\vert 01\rangle$	$\vert 11\rangle$	$\vert 10\rangle$	$\vert 10\rangle \checkmark$
$\vert 10\rangle$	$\vert 10\rangle$	$\vert 11\rangle$	$\vert 01\rangle \checkmark$
$\vert 11\rangle$	$\vert 01\rangle$	$\vert 01\rangle$	$\vert 11\rangle \checkmark$

Bramka Toffoliego (czyli „controlled-controlled-NOT" (CCNOT)): Jest to bramka działająca na trzy kubity. Nazwa „controlled-controlled-NOT" może już podpowiadać, jak działa: są dwa kubity sterujące i jeden kubit docelowy, a stan kubitu docelowego jest odwracany tylko wtedy, gdy oba kubity sterujące są w stanie $\vert 1\rangle$. Zachowujemy konwencję kolejności, którą stosowaliśmy przy CNOT:

$$CCNOT(Control A, Control B, Target C)\vert CBA\rangle$$

Zatem tablica prawdy wygląda następująco:

Wejście	Wyjście
$\vert 000\rangle$	$\vert 000\rangle$
$\vert 001\rangle$	$\vert 001\rangle$
$\vert 010\rangle$	$\vert 010\rangle$
$\vert 011\rangle$	$\vert 111\rangle$
$\vert 100\rangle$	$\vert 100\rangle$
$\vert 101\rangle$	$\vert 101\rangle$
$\vert 110\rangle$	$\vert 110\rangle$
$\vert 111\rangle$	$\vert 011\rangle$

Macierz reprezentująca tę operację to:

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

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

Bramkę Toffoliego również można rozłożyć na bramki CNOT wraz z kilkoma innymi bramkami. Jest to jednak znacznie bardziej skomplikowane niż dekompozycja bramki SWAP, dlatego zostanie pozostawione jako opcjonalne ćwiczenie na końcu modułu do samodzielnego zbadania i weryfikacji tej dekompozycji.

Pomiary

Pomiary pełnią w obliczeniach kwantowych szczególną rolę, która nie ma analogu w klasycznych komputerach. W przypadku klasycznych komputerów możesz sprawdzić stan bitów w dowolnym momencie algorytmu, natomiast w obliczeniach kwantowych musisz bardzo starannie dobierać chwilę, w której patrzysz na swoje kubity — pomiar powoduje kolaps stanu i niszczy superpozycję, która nadaje kubitom ich obliczeniową złożoność.

W szczególności, dla $N$-bitowego stanu kwantowego $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$, pomiar spowoduje kolaps stanu do jednej z funkcji bazowych $\vert i\rangle$ z prawdopodobieństwem równym $\vert c_i\vert ^2$.

Jednak ten destrukcyjny efekt pomiaru nie zawsze jest przeszkodą. W rzeczywistości jest kluczowym zasobem w pewnych algorytmach i protokołach, takich jak teleportacja kwantowa i kwantowa dystrybucja klucza.

W Qiskit, gdy wykonywany jest pomiar, jego wynik trafia do klasycznego rejestru, gdzie jest przechowywany jako klasyczny bit. Tworzenie obwodu z pomiarem wygląda następująco:

qc = QuantumCircuit(
    1, 1
)  # the second number is the number of classical bits in the circuit
qc.measure(0, 0)
qc.draw("mpl")

Obwody

Teraz, gdy wiemy już, jak działają kubity, bramki i pomiary, stwórzmy i wykonajmy własny obwód kwantowy! W tym celu zapoznamy cię z przydatnym przepływem pracy zwanym wzorcami Qiskit.

Wzorzec Qiskit patterns

Wzorzec Qiskit patterns to ogólna procedura podejścia do problemów i ich rozwiązywania za pomocą komputera kwantowego. Składa się z czterech kroków:

1. Mapowanie naszego problemu na obwody kwantowe i operatory
2. Optymalizowanie obwodu pod kątem docelowego sprzętu
3. Wykonanie na docelowym sprzęcie
4. Post-processing wyników

Aby zilustrować te kroki, zaimplementujemy kwantową wersję omówionego powyżej układu półsumatora.

1. Mapowanie

Klasyczny układ sumatora używa bramki XOR i bramki AND do obliczenia odpowiednio bitu sumy i bitu przeniesienia. Możemy zaadaptować te bramki do kontekstu kwantowego, aby stworzyć kwantowy półsumator. Pamiętając, że kwantowe bramki są odwracalne, nie możemy po prostu nadpisać danych wejściowych. Zamiast tego wprowadzamy dwa pomocnicze kubity zainicjowane w stanie $\vert 0\rangle$, które będą przechowywać wyjścia sumy i przeniesienia. Nasz pełny stan kwantowy będzie więc składał się z kubitów $A$ i $B$ oraz kubitów sumy i przeniesienia, które oznaczymy $S$ i $C$:

$\vert \psi\rangle = \vert C S B A\rangle$

Teraz potrzebujemy kwantowych bramek, które wykonają to samo, co bramki XOR i AND w klasycznym układzie.

Suma:

Dla XOR stosujemy dwa CNOT-y, każdy z kubitami sterującymi $A$ i $B$ oraz kubitem docelowym $S$ dla obu. Jeśli $A$ i $B$ są różne, jedna z bramek CNOT przerzuci $S$ do stanu $\vert 1\rangle$. Jeśli $A$ i $B$ są oba $\vert 0\rangle$, nic się nie dzieje z $S$ i pozostaje on w stanie $\vert 0\rangle$. Jeśli $A$ i $B$ są oba $\vert 1\rangle$, stan $S$ zostanie przerzucony dwukrotnie, wracając do stanu $\vert 0\rangle$.

Przeniesienie:

Dla bitu przeniesienia potrzebujemy czegoś, co działa jak klasyczna bramka AND.

Sprawdź swoją wiedzę

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

Przejrzyj omówione bramki i sprawdź, czy potrafisz zgadnąć, której kwantowej bramki użyjemy zamiast klasycznej bramki AND:

Odpowiedź:

To bramka Toffoli! Pamiętaj, bramka Toffoli, czyli bramka controlled-controlled-NOT, przerzuca stan docelowy wtedy i tylko wtedy, gdy kubit sterujący 0 ORAZ kubit sterujący 1 są oba w stanie $\vert 1\rangle$. Zatem jeśli kubit docelowy zaczyna w stanie $\vert 0\rangle$, działa tak samo jak bramka AND.

Mamy więc już wszystkie składniki potrzebne do stworzenia obwodu kwantowego:

# qubits: a, b, sum, carry
qc = QuantumCircuit(4)

# Choose values for A and B:
a = 0
b = 0

# Prepare A and B qubits according to selected values:
if a:
    qc.x(0)
if b:
    qc.x(1)

# XOR (sum) into qubit 2
qc.cx(0, 2)
qc.cx(1, 2)

# AND (carry) into qubit 3
qc.ccx(0, 1, 3)  # a AND b

# measure
qc.measure_all()

qc.draw("mpl")

Powyżej przedstawiony jest diagram obwodu kwantowego półsumatora. Jak wspomniano wcześniej, przewody reprezentują kubity $0$ do $3$ uporządkowane od góry do dołu, a dolny przewód z podwójną linią to rejestr klasycznych bitów. Czytając diagram od lewej do prawej, widzimy, jak bramki są stosowane do każdego kubitu, obserwując, gdzie pojawiają się pola na odpowiadających im przewodach. Na końcu widoczne są pomiary. Pomiary powodują kolaps stanów kubitów do określonych wartości $0$ lub $1$, a wyniki trafiają do klasycznego rejestru.

Jedna subtelność: choć diagram obwodu rysowany jest od lewej do prawej, pisząc odpowiadające mu wyrażenie macierzowe, musimy czytać je od prawej do lewej. Wynika to z tego, że w mnożeniu macierzy operator najbliższy wektorowi stanu działa jako pierwszy. Na przykład powyższy obwód (pomijając pomiary) zapisalibyśmy jako:

$$CCNOT(q_0,q_1,q_3)CNOT(q_1, q_2)CNOT(q_0,q_2)\vert q_3 q_2 q_1 q_0\rangle$$

2. Optymalizowanie:

Następnie musimy zoptymalizować obwód do uruchomienia na sprzęcie kwantowym. Ta optymalizacja jest realizowana przez transpiler, który tłumaczy abstrakcyjny obwód pokazany powyżej na instrukcje zrozumiałe dla komputera kwantowego. Przypisuje logiczne kubity do rzeczywistych, fizycznych kubitów na procesorze i przepisuje bramki w kategoriach własnego natywnego zestawu bramek zoptymalizowanego do działania na komputerze kwantowym. Wreszcie transpiler implementuje również coś, co nazywa się „tłumieniem i łagodzeniem błędów", aby zminimalizować wpływ błędów na wynik. Dla naszego bardzo prostego obwodu nie jest to tak istotne, ale jeśli będziesz kontynuować swoją przygodę z obliczeniami kwantowymi i uruchamiać bardziej skomplikowane obwody, szybko docenisz wartość tłumienia i łagodzenia błędów. Jeśli chcesz dowiedzieć się więcej na ten temat, zapoznaj się z kursem Olivii Lane, Quantum Computing in Practice.

Na początku ładujemy pakiety wymagane do komunikacji z komputerami kwantowymi IBM® i wybieramy backend, na którym będziemy uruchamiać zadania. Możemy wybrać najmniej zajęty backend albo wybrać konkretny backend, o którego właściwościach wiemy.

Poniżej znajduje się kod do jednorazowego zapisania twoich poświadczeń. Pamiętaj, aby usunąć te informacje z notatnika po zapisaniu ich w swoim środowisku, żeby poświadczenia nie zostały przypadkowo ujawnione podczas udostępniania notatnika. Więcej wskazówek znajdziesz w sekcjach Skonfiguruj konto IBM Cloud i Inicjalizuj usługę w niezaufanym środowisku.

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

Teraz używamy transpilera do optymalizacji obwodu. Możemy wybrać poziom optymalizacji od 0 (brak optymalizacji) do 3 (najwyższy poziom optymalizacji). Aby zobaczyć, co obejmuje każdy poziom, odwiedź przewodnik Ustaw poziom optymalizacji transpilera. Wynikowy obwód będzie wyglądał znacznie inaczej niż logiczny obwód, który stworzyliśmy na etapie mapowania.

# Transpile the circuit and optimize for running on the quantum computer selected
# 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)

qc_isa.draw("mpl")

„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ą zostać zmierzone i z jakim prawdopodobieństwem. Importujemy tutaj Qiskit Runtime Sampler:

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

sampler = Sampler(mode=backend)

Jeśli wyczerpałeś(-aś) przydzielony czas na prawdziwych komputerach kwantowych lub nie masz dostępu do internetu, możesz preferować użycie symulatora. W tym celu uruchom poniższą komórkę i odkomentuj powiązaną linię w kroku „Wykonanie".

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

3. Wykonanie

Po przygotowaniu obwodu możemy teraz uruchomić go na komputerze kwantowym!

job = sampler.run([qc_isa], shots=100)
# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator
res = job.result()
counts = res[0].data.meas.get_counts()

4. Post-processing

Teraz jesteśmy gotowi, aby zobaczyć wyniki! Wyświetlimy histogram 100 próbek obwodu.

from qiskit.visualization import plot_histogram

print("counts = ", counts)
plot_histogram(counts)

counts =  {'0000': 90, '0100': 4, '1100': 3, '0010': 3}

Powyższy histogram pokazuje wyniki pomiarów wszystkich czterech kubitów na końcu obwodu. Idealny komputer kwantowy bez szumów mierzyłby kubity z tymi samymi wartościami przy każdym uruchomieniu, jednak w rzeczywistości szumy powodują, że część uruchomień produkuje błędy.

Sprawdź swoją wiedzę

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

Używając bitstringa z największą liczbą zliczeń jako wartości $A$, $B$, $S$ i $C$, zweryfikuj, że kwantowy układ dodający zadziałał prawidłowo.

Odpowiedź:

Musimy zweryfikować, że $A+B = S+2 \times C$. Pamiętaj, że kolejność bitstringa jest zgodna z notacją little-endian, więc czyta się go jako CSBA.

Z powyższego histogramu widać, że dominującym bitstringiem jest 0000.

$0 + 0 = 0 + 0 \times 2 = 0 ~\checkmark$

Wróć i zmień wartości $A$ i $B$ na $A=1$ i $B=1$, a następnie przejdź ponownie przez kroki wzorca Qiskit, aby uruchomić obwód jeszcze raz. Zweryfikuj ponownie, że układ dodający zadziałał prawidłowo.

Odpowiedź:

Powinieneś/powinnaś uzyskać histogram, w którym dominującym bitstringiem jest 1011:

$1 + 1 = 0 + 1 \times 2 = 2 ~\checkmark$

Jedną z dodatkowych cech kwantowego półsumatora w porównaniu z klasycznym półsumatorem jest to, że może on działać z kwantowymi wejściami. Oznacza to, że potrafi „dodawać" kubity $A$ i $B$ nawet wtedy, gdy znajdują się w stanach superpozycji. W sekcji Pytania dodatkowe poniżej zostaniesz poproszony/a o przygotowanie kubitów w superpozycjach i sprawdzenie, co się stanie!

Podsumowanie

Ten moduł został zaprojektowany, aby dać ci solidne, podstawowe zrozumienie zasad leżących u podstaw obliczeń kwantowych poprzez porównanie ich z obliczeniami klasycznymi. Przyjrzeliśmy się klasycznemu obwodowi półsumatora, a następnie pokazaliśmy, jak dostosować ten obwód do działania z kubitami na komputerze kwantowym. Teraz jesteś gotowy/gotowa, aby odkrywać pozostałe moduły Qiskit w Classroom!

Kluczowe pojęcia:

• W odróżnieniu od klasycznych bitów, które mogą przyjmować wyłącznie wartości 0 i 1, kubity mogą również znajdować się w stanach superpozycji obu wartości: 0 i 1.
• Wiele kubitów może znajdować się w superpozycji klasycznie dozwolonych bitstringów, zwanych stanami bazy obliczeniowej.
• Wiele kubitów może być splątanych, tak że stan jednego zależy od stanu drugiego.
• Konwencją Qiskit jest stosowanie notacji little-endian, która umieszcza najmniej znaczący kubit, $q_0$, na skrajnej prawej pozycji, a najbardziej znaczący kubit, $q_N$, na skrajnej lewej.
• Bramki kwantowe to odwracalne operacje reprezentowane przez macierze unitarne, które działają na wektorach stanu kwantowego. W tej notacji macierz najbliżej wektora (najbardziej wysunięta w prawo) działa jako pierwsza.
• Pomiary zwijają kwantowy stan superpozycji do jednego z klasycznie dozwolonych stanów, z prawdopodobieństwem równym kwadratowi amplitudy odpowiadającego mu stanu bazy obliczeniowej w superpozycji.
• Obwody kwantowe są często przedstawiane za pomocą diagramów obwodów kwantowych, gdzie kubity są przedstawiane jako poziome linie, a bramki kwantowe pojawiają się wzdłuż tych linii od lewej do prawej.
• Aby uruchomić obwód kwantowy, używamy czterech kroków przepływu pracy wzorców Qiskit: Mapuj, Optymalizuj, Wykonaj, Przetwórz wyniki.

Pytania

Pytania prawda/fałsz

1. Pojedynczy bit w komputerze klasycznym może przechowywać wyłącznie wartość 0 lub 1.

2. Splątanie oznacza, że stan jednego kubitu jest niezależny od stanu drugiego.

3. Bramki kwantowe to operacje generalnie nieodwracalne.

4. Konwencja Qiskit umieszcza najmniej znaczący kubit, $q_0$, na skrajnej lewej pozycji.

5. Pomiar stanu kwantowego zawsze daje dokładnie taki sam wynik, jeśli jest powtarzany wielokrotnie.

6. Bramka Hadamarda tworzy superpozycję w pojedynczym kubicie.

7. Obwody kwantowe mogą zawierać operacje pomiarowe, które zwijają stan superpozycji do jednego z klasycznie dozwolonych stanów.

8. Liczba możliwych stanów klasycznych dla $N$ bitów wynosi $2N$.

9. Prawdopodobieństwa wyników pomiarów kwantowych są dane przez kwadraty amplitud klasycznie mierzalnych stanów bazowych.

Pytania krótkiej odpowiedzi

1. Jakie są główne różnice między bitem a kubitem?

2. Co dzieje się ze stanem kwantowym, gdy jest on mierzony?

3. Dlaczego w Qiskit używamy notacji little-endian?

4. Jakie są cztery kroki przepływu pracy wzorców Qiskit?

Pytania dodatkowe:

1. W module używaliśmy sumatora wyłącznie do dodawania klasycznie dozwolonych stanów $A$ i $B$. Możemy jednak również przygotować $A$ i $B$ w superpozycjach! Zmień kod tak, aby przygotować każdy kubit w równej superpozycji stanów 0 i 1, a następnie uruchom nowy obwód i uzyskaj nowy histogram. Co widzisz? Wyjaśnij, co się dzieje.

2. Dekompozycja bramki Toffoliego. Użyj decompose(), aby pokazać, jak bramka Toffoliego jest rozkładana na jednokubitowe i dwukubitowe bramki, a następnie zweryfikuj tę konstrukcję za pomocą mnożenia macierzy. Pamiętaj, że choć diagramy obwodów czyta się od lewej do prawej, macierze są stosowane do stanów kwantowych od prawej do lewej!