Magsimula sa Qiskit sa Silid-Aralan

Para sa modyul na ito ng Qiskit sa Silid-Aralan, ang mga estudyante ay dapat may gumaganang Python environment na may mga sumusunod na naka-install na package:

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

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

Ang modyul na ito ay nasubok at gumamit ng 2 segundo ng QPU time sa isang Heron v2 processor. Ito ay isang tantiya lamang. Ang iyong aktwal na paggamit ay maaaring mag-iba.

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

Panimula

Sa mga modyul ng Qiskit sa Silid-Aralan, magkakaroon ka ng pagkakataon na gumamit ng quantum computer upang tuklasin ang iba't ibang konsepto sa mga larangang kaugnay ng quantum computing tulad ng quantum mechanics, computer science, chemistry, at marami pa. Ang modyul na ito ay nagsisilbing paunang kinakailangan sa iba — ipinakilala nito ang mga pangunahing kaalaman sa quantum computing at kung paano gamitin ang Qiskit upang magpatakbo ng mga quantum circuit.

Una, ibibigay namin sa iyo ang isang maikling pangkalahatang-ideya ng kung paano gumagana ang isang klasikal na computer, pagkatapos ay ipapakita namin kung paano ang mga konseptong ito ay inangkop upang magkasya sa quantum computing paradigm. Sa wakas, ipapakita namin kung paano pagsamahin ang mga konseptong ito upang buuin at isagawa ang iyong unang quantum circuit.

Mga klasikal na computer

Malamang na pamilyar ka na sa mga pangunahing kaalaman tungkol sa kung paano gumagana ang mga klasikal na computer, ngunit dito ay i-highlight namin ang ilang pangunahing tampok upang makapagbigay tayo ng paghahambing sa mga quantum computer.

Ang pangunahing yunit ng impormasyon: bits

Ang mga klasikal na computer ay nagpoproseso ng klasikal na impormasyon, at ang pangunahing yunit ng klasikal na impormasyon ay ang bit. Ang isang bit ay maaaring mag-imbak ng sagot sa isang tanong na "oo/hindi". Karaniwang kinakatawan natin ang dalawang binary state ng isang bit bilang "0" at "1".

Pagrepaso ng mga binary number

Ang pagsasama ng mga bit ay nagbibigay-daan sa iyo na mag-imbak ng mas maraming impormasyon. Halimbawa, kung nais mong mag-imbak ng isang numero mula 0 hanggang 15, maaari mong gawin ito gamit ang apat na bit sa sumusunod na paraan:

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

Sa pangkalahatan, upang mai-convert mula sa isang binary number na may $N$ bits patungo sa isang pamilyar na base-10 na numero, pinarami mo ang pinaka-mababa (pinakakanang) bit ng $2^0 = 1$, ang susunod na bit sa kaliwa ng $2^1 = 2$, pagkatapos ang susunod ng $2^2 = 4$, at iba pa, hanggang sa maabot mo ang pinakamahalaga (pinaka-kaliwang bit), na pinarami mo ng $2^{N-1}$.

Kaya, nangangahulugang ang $N$ bits ay maaaring nasa isa sa $2^N$ iba't ibang posibleng estado.

Suriin ang iyong pag-unawa

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

Ilang bits ang kailangan mo upang katawanin ang numero 86? Isulat ang bitstring na nag-encode ng numerong ito sa binary.

Sagot:

Tandaan, ang $N$ bits ay nagpapahintulot sa iyo na katawanin ang mga numero $0$ hanggang $2^N - 1$, kaya ang paggamit ng anim na bits ay magdadala sa atin hanggang sa $2^6 - 1 = 63$. Hindi pa sapat iyon. Dagdagan natin ng isa pang bit para makarating sa $2^7 - 1 = 127$. Ngayon, hatiin natin ang 86 sa mga kapangyarihan ng 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}$$

Mga pangunahing operasyon: gates

Ngayon, ang isang computer ay kailangang makapag-gawa ng isang bagay gamit ang mga bit upang, sa katunayan, mag-compute. Ang mga binary gate ay ang mga operasyong bumubuo sa pangunahing gusali ng lahat ng mas kumplikadong algorithm at code.

Single-bit gate:

NOT

Kapag mayroon kang isang bit lamang, iisa lang ang paraan na maaari mong baguhin ang estado nito: i-flip ang estado mula 0 patungong 1 o mula 1 patungong 0. Tinatawag natin itong "NOT" gate. Ang epekto ng gate na ito — at ng iba pang mga gate na tatalakayin natin sa ibaba — ay maaaring katawanin sa isang tinatawag na "truth table," na may mga column para sa input at output na estado ng mga qubit. Ang truth table para sa NOT gate ay:

Input	Output
0	1
1	0

Mga multi-bit gate:

AND

Ang AND ay isang two-bit gate na tumatanggap ng dalawang input na bit at nag-o-output ng isang bit. Nag-o-output ito ng 1 kung parehong input na bit ay 1, at 0 kung hindi:

Input	Output
00	0
01	0
10	0
11	1

OR

Ang OR ay isa pang two-bit gate na may isang output na bit. Nag-o-output ito ng 1 kung alinman sa mga bit ay 1:

Input	Output
00	0
01	1
10	1
11	1

XOR

Ang XOR ay kumakatawan sa "exclusive OR" at ito ay katulad ng OR gate, ngunit nag-o-output ng 1 kung isang bit lamang sa mga input na bit ang 1. Nag-o-output ito ng 0 kung parehong 1 o parehong 0:

Input	Output
00	0
01	1
10	1
11	0

Mga sukat:

Karaniwang, kapag natututo tungkol sa klasikal na computing, hindi masyadong binibigyang-pansin ang proseso ng pagbabasa ng estado ng mga bit. Ito ay dahil hindi ito masyadong kumplikado mula sa konseptwal na pananaw. Maaari mong sukatin ang mga bit anumang oras bago, habang, o pagkatapos ng isang computation, at hindi ito nakakaapekto sa resulta. Hindi ito ang kaso sa quantum computing, tulad ng tatalakayin natin sa ibaba.

Mga Circuit:

Sa pamamagitan ng pagsasama ng mga gate sa itaas, maaari kang gumawa ng anumang uri ng operasyon na gusto mo sa isang computer. Kumuha tayo ng isang simpleng halimbawa: Gamit ang AND at XOR gates, maaari kang bumuo ng half-adder circuit, na kinakalkula ang kabuuan ng dalawang bit. Ito ay kinakatawan sa isang lohikal na circuit diagram, kung saan ang mga wire ay kumakatawan sa mga bit at ang mga gate na gumaganap sa mga bit ay ipinapakita bilang mga simbolo sa mga kaugnay na wire:

Kaya, ang dalawang bit ay kinokopya at pinagdaluyan sa parehong AND gate at XOR gate. Ang resulta ng XOR gate ay ang "sum bit" (S), na nananatili sa ones place ng binary number, at ang resulta ng AND gate ay ang "carry bit" (C), na siyang halaga ng susunod na pinakamahalaga na digit sa binary number. Narito ang truth table:

$A$	$B$	Sum ($A \oplus B$)	Carry ($A \wedge B$)
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

Suriin ang iyong pag-unawa

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

I-verify na ang truth table sa itaas ay nagbubunga ng tamang solusyon para sa isang adder circuit. Ibig sabihin, para sa bawat isa sa apat na opsyon ng A at B, i-verify na ang $A+B=S+2 \times C$.

Sagot:

$$\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}$$

Mga quantum computer

Mga bit $\rightarrow$ qubits

Tulad ng mga bit bilang pangunahing yunit ng klasikal na impormasyon, ang mga quantum bit, o "qubit," ay ang pangunahing yunit ng quantum na impormasyon. Tulad ng klasikal na bit, ang estado ng isang Qubit ay maaaring 0 o 1, na karaniwang tinutukoy natin bilang $\vert 0\rangle$ at $\vert 1\rangle$. Ngunit hindi tulad ng klasikal na bit, ang isang quantum bit ay maaari ding nasa isang superposition ng parehong estado na $\vert 0\rangle$ at $\vert 1\rangle$ nang sabay-sabay. Sa pangkalahatan, ang isang Qubit ay maaaring nasa anumang estado na $\vert \psi\rangle$ ng anyo:

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

kung saan ang $c_0$ at $c_1$ ay mga kumplikadong amplitude na may $\vert c_0 \vert ^2+\vert c_1\vert ^2=1$.

Ang quantum phase

Dahil ang $c_0$ at $c_1$ ay kumplikado, ang bawat isa ay maaaring isulat bilang $c_i = \vert c_i\vert e^{i\phi_i}$ kung saan ang $\phi_i$ ay tinatawag na phase. Kung pinarami natin ang buong estado ng parehong overall phase factor, walang nagbabago sa pisikal — ito ay tinatawag na global phase, at ito ay walang mga observable na kahihinatnan.

Para sa kadahilanang iyon, ang kaugalian ay "i-factor out" ang $e^{i\phi_0}$, na nagbibigay ng:

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

kung saan ang $\phi = \phi_1-\phi_0$ ay ang relative phase ng quantum na estado, na may observable na kahihinatnan.

Ang phase na ito ay may napakahalgang papel sa quantum computing, at tutuklasin mo ang iba't ibang kahihinatnan nito sa mga kasunod na modyul ng Qiskit sa Silid-Aralan.

Maraming qubit

Habang ang estado ng maraming bit ay maaaring simpleng ipahayag bilang isang string ng mga 0 at 1, ang estado ng maraming qubit ay nagiging kaunting mas kumplikado dahil sa mga prinsipyo ng superposition at entanglement.

Alalahanin na ang $N$ bits ay maaaring nasa isa sa $2^N$ posibleng estado mula sa mga binary number na 000...000 hanggang 111...111. Ngunit ngayon, dahil sa prinsipyo ng superposition, ang $N$ qubit ay maaaring nasa isang superposition ng lahat ng mga estadong ito nang sabay-sabay!

Maaari itong ipahayag bilang

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

kung saan, tulad ng sa klasikal na kaso, ang estado na $\vert i\rangle$ ay tumutugma sa estado kung saan ang bawat qubit ay nasa tamang kombinasyon ng 0 at 1 upang makamit ang binary number na $i$. Kilala ang mga ito bilang "computational basis states" ng quantum system. Halimbawa, ang isang three-qubit state ay maaaring isulat bilang isang superposition ng walong computational basis state nito:

$$\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$$

Ang bawat qubit sa sistema ay may index na $0$ hanggang $N-1$. Ang kaugalian ay ang pagbabasa ng mga estado ng qubit mula kanan patungo sa kaliwa, kaya ang estado ng qubit $0$ ay ang pinakakanang estado at ang estado ng qubit $N-1$ ay ang pinaka-kaliwang estado. Ito ay kilala bilang "little-endian" notation, at maaaring mukhang hindi makatuwiran sa una, dahil sanay tayong magbasa mula kaliwa patungo sa kanan.

Suriin ang iyong pag-unawa

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

Sa unang tingin, maaaring mukhang hindi makatuwiran ang pag-order ng mga qubit mula kanan patungo sa kaliwa tulad ng sa little-endian notation, ngunit ito ay isang napaka-lohikal na bagay na gawin! Ipaliwanag kung bakit. (Alalahanin ang ating talakayan sa itaas tungkol sa binary-to-base-10 number conversion.)

Sagot:

Kung i-order natin ang mga qubit mula kanan patungo sa kaliwa, para ang qubit 0 ay ang pinakamalayo sa kanan at ang qubit N-1 ay ang pinakamalayo sa kaliwa, lohikal na iugnay ang qubit $0$ sa least-significant bit, na pinarami ng $2^0$ at ang qubit $N-1$ sa most-significant bit, na pinarami ng $2^{N-1}$.

Entanglement

Tulad ng nabanggit namin kanina, isa pang pangunahing tampok ng mga qubit ay maaari silang ma-entangle sa isa't isa. Kunin natin ang isang halimbawa ng isang two-qubit state, kung saan ang $c_0 = c_3 = \frac{1}{\sqrt{2}}$ at $c_1 = c_2 = 0$:

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

Kaya, ang estado ng qubit 0 ay maaaring maging alinman sa $\vert 0\rangle$ o $\vert 1\rangle$ na may pantay na posibilidad, at ganoon din ang estado ng qubit 1. Ngunit ang mga posibilidad na ito ay hindi na nakapag-iisa sa isa't isa. Kung matuklasan natin ang estado ng qubit 0 na $\vert 0\rangle$, alam natin na ang qubit 1 ay nasa $\vert 0\rangle$ din. Ito ay totoo kahit gaano kalayo ang isa't isa, kaya naman ang pagsukat ng isang entangled na estado ay minsan ay tinutukoy bilang "spooky action at a distance."

Ang entanglement ay maaari ring kumuha ng iba pang anyo. Halimbawa, ang estado

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

ay nagbubunga ng kabaligtarang resulta sa bawat pagkakataon: kung ang isang qubit ay nasukat na $\vert 0\rangle$, ang isa pa ay garantisadong matatagpuan sa estado na $\vert 1\rangle$.

Suriin ang iyong pag-unawa

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

Ang estado ba na $\vert \psi\rangle = \vert 11\rangle$ ay entangled? Bakit o bakit hindi?

Sagot:

Hindi ito entangled. Kahit palagi ang parehong resulta kapag sinukat mo ang parehong qubit, ito ay dahil lamang ang bawat qubit ay palaging nakatakda sa estado na $\vert 1\rangle$. Ang resulta ng pagsukat ng isang qubit ay hindi talaga nakadepende sa isa pa — parehong palaging $\vert 1\rangle$ ang dalawa.

Sa pangkalahatan, kung maaari mong ilarawan ang estado ng bawat qubit nang hiwalay at pagkatapos ay paramihin ang mga ito nang magkasama tulad nito:

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

Kung gayon, ito ay kilala bilang "product state" at hindi entangled.

Vector notation

Madalas na nakatutulong na gumamit ng mga vector at matrix upang makita kung paano nagbabago ang quantum state sa ilalim ng iba't ibang operasyon. Sa representasyong ito, ang ating mga quantum state ay magiging mga vector, at ang ating mga quantum gate (tinatalakay sa susunod na seksyon) ay magiging mga matrix na nagbabago ng mga vector.

Para sa isang qubit, ang vector form ng mga estado ay pinili na maging: $\vert 0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$ $\vert 1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$ Sa ganitong paraan, ang isang arbitrary na estado na $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ ay maaaring isulat bilang $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

Para sa isang pangkalahatang $n$-qubit state, kakailanganin natin ng isang $2^n$-dimensional na vector, na may mga basis state na nakaayos tulad ng inaasahan, sa pataas na binary value:

$$\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}$$

Sa pagkakaroon ng vector notation na ito sa isip, maaari na nating ipakilala ang ating mga kailangang quantum gate, ang kanilang mga epekto sa mga quantum state, at ang kanilang mga matrix form.

Suriin ang iyong pag-unawa

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

Mayroong apat na computational basis state para sa isang two-qubit system. Isulat ang bawat isa sa parehong ket at vector notation.

Sagot:

$$\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}$$

Mga Gate $\rightarrow$ quantum gates

Tulad ng mga klasikal na gate — gaya ng NOT, AND, OR, at XOR — na pinagsama-sama para makabuo ng anumang klasikal na circuit, ang mga quantum gate naman ang gumaganap ng parehong papel sa quantum computing. Dahil ang mga Qubit ay may karagdagang mga katangian sa quantum mechanics, ang mga quantum gate ay mas mayaman sa kalidad. Kahit maaari pa ring ilarawan ang kanilang epekto sa mga basis state na $|0\rangle$ at $|1\rangle$ gamit ang truth table, hindi pa rin nito nakukuha ang buong larawan. Para sa mga quantum gate, mas natural ang gamitin ang matrix representation, dahil gumagana rin ito sa mga superposition ng mga basis state.

Sa ibaba, ipakikilala natin ang mga pinakakaraniwang quantum gate at kung paano nila binabago ang mga Qubit na kanilang tinatawid. Kung saan akma, iuugnay natin ang mga ito sa mga pamilyar na klasikal na gate.

Mga single-qubit gate

Gate na $X$: Ito ang quantum na katumbas ng operasyong NOT. Eksaktong kapareho ng klasikal na NOT gate ang hitsura ng truth table nito:

Input	Output
$\vert 0\rangle$	$\vert 1\rangle$
$\vert 1\rangle$	$\vert 0\rangle$

At ang matrix representation:

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

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

from qiskit import QuantumCircuit

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

Sa napaka-simpleng circuit diagram na ito, ang Qubit ay kinakatawan ng isang wire — ang itim na pahalang na linya — at ang gate ay lumalabas bilang isang kahon sa wire na iyon.

Hadamard gate: Lumilikha ng superposition state. Truth table:

Input	Output
$\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)$

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

Ganito ang paglikha ng Circuit na may Hadamard gate:

from qiskit import QuantumCircuit

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

Gate na $Z$: Nagdaragdag ng phase shift na $\Delta \phi = \pi$ sa estado na $|1\rangle$:

Input	Output
$\vert 0\rangle$	$\vert 0\rangle$
$\vert 1\rangle$	$-\vert 1\rangle$

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

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

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

Gate na $T$: Nagdaragdag ng phase shift na $\Delta \phi = \pi/4$ sa estado na $|1\rangle$:

Input	Output
$\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}$

Sa Qiskit, ganito ang hitsura ng Circuit na may gate na $T$:

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

Mga multi-qubit gate

Ang mga two-qubit gate ay maaaring katulad ng mga klasikal na two-bit gate, ngunit may isang mahalagang pagkakaiba: lahat ng quantum gate ay dapat na nare-reverse. Sa termino ng linear algebra, ibig sabihin nito ay kinakatawan sila ng mga unitary matrix. Kaya naman, dalawang input na Qubit ang laging nagma-map sa dalawang output na Qubit, at maaaring ibalik ang operasyon sa prinsipyo. Ito ay kabaliktaran ng mga klasikal na gate na nakita natin sa itaas, tulad ng AND o OR, na nagtatambak ng impormasyon at hindi nare-reverse — kapag may naibigay na output, hindi mo matukoy nang tiyak ang input.

CNOT (Controlled-NOT) gate: Ang dalawang input na Qubit ay tinatawag na "control" at "target" na Qubit. Nananatiling hindi nagbabago ang control qubit, ngunit ang estado nito ang nagtatakda kung ano ang mangyayari sa target qubit. Kung ang control qubit ay nasa estado na $\vert 1\rangle$, isang gate na $X$ ang ia-apply sa target; kung ang estado ng control qubit ay $\vert 0\rangle$, walang pagbabagong gagawin. Sa notasyong nasa ibaba, ipagpalagay na ang Qubit na $A$ (ang pinakakanang Qubit) ang control, at ang Qubit na $B$ (ang pinakakaliwang Qubit) ang target. Sa ibaba, ang notasyong ginagamit ay $CNOT(q_{control},q_{target})\vert BA\rangle.$

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

Input	Output
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 11\rangle$
$\vert 10\rangle$	$\vert 10\rangle$
$\vert 11\rangle$	$\vert 01\rangle$

Kaya naman, ang matrix na kumakatawan sa aksyong ito ay:

$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")

Ito ang unang circuit diagram na nakikita nating may dalawang Qubit, na kinakatawan ng dalawang wire. Ang CNOT gate ay ipinapatupad sa pagitan ng dalawang Qubit, na may $q_0$ bilang control at $q_1$ bilang target.

Suriin ang iyong pag-unawa

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

Karamihan sa mga gate ay may parehong matrix form sa Qiskit at sa ibang mga aklat. Ngunit ang CNOT gate ay gumagana sa dalawang Qubit, kaya naman biglang nagiging isyu ang pagkakasunud-sunod ng mga Qubit. Ang mga teksto na nag-uutos ng mga Qubit bilang $\vert q_0,q_1,...\rangle$ ay magpapakita ng ibang matrix form para sa kanilang mga CNOT gate. I-verify sa pamamagitan ng malinaw na matrix multiplication na ang CNOT matrix sa itaas ay may tamang epekto sa estado na $\vert 01\rangle.$

Sagot:

$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$

SWAP gate: Binabago ng gate na ito ang mga estado ng dalawang Qubit. Truth table:

Input	Output
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 10\rangle$
$\vert 10\rangle$	$\vert 01\rangle$
$\vert 11\rangle$	$\vert 11\rangle$

Kaya naman, ang matrix na kumakatawan sa aksyong ito ay:

$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")

Ang SWAP gate ay maaaring mabuo mula sa tatlong CNOT. Para makita kung paano, maaari nating i-decompose() ang gate gamit ang Qiskit:

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

Dito unang nakikita natin kung paano ipinapakita ang maraming gate sa isang circuit diagram. Binabasa natin ito mula kaliwa hanggang kanan, kaya ang gate sa kaliwa ang unang ina-apply.

Suriin ang iyong pag-unawa

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

I-verify na ang kumbinasyon ng mga CNOT sa itaas ay nagreresulta sa isang SWAP gate. Magagawa mo ito sa pamamagitan ng matrix multiplication o anumang iba pang paraan.

Sagot:

Sa matrix multiplication:

$\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$

Gamit ang truth table para makita kung paano nagbabago ang mga estado sa bawat CNOT. Sa huling kolum, ang mga estado ay dapat na katumbas ng kolum na "output" ng SWAP truth table:

Input	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$

Toffoli gate (o "controlled-controlled-NOT" (CCNOT)): Ito ay isang gate na gumagamit ng tatlong Qubit. Maaaring makuha na agad mula sa pangalan na "controlled-controlled-NOT" kung paano ito gumagana: may dalawang control qubit at isang target qubit, at ang estado ng target qubit ay nababago lamang kung parehong control qubit ay nasa estado na $\vert 1\rangle$. Pinapanatili natin ang pagkakasunud-sunod na ginamit natin sa CNOT:

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

Kaya naman ang truth table ay:

Input	Output
$\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$

At ang matrix na kumakatawan sa aksyong ito ay:

$$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")

Ang Toffoli gate ay maaari ring i-decompose sa mga CNOT, kasama ang ilang iba pang gate. Gayunpaman, ito ay mas kumplikado kaysa sa SWAP gate decomposition, kaya ito ay iiwanang opsyonal na pagsasanay sa katapusan ng modyul para galugarin at i-verify ang decomposisyong ito.

Mga Measurement

Ang mga Measurement ay may espesyal na papel sa quantum computing — isang papel na walang katumbas sa klasikal na computing. Habang sa klasikal na computing ay maaari mong tingnan ang iyong mga bit sa anumang punto ng iyong pagpili sa panahon ng isang algorithm, sa quantum computing naman ay dapat kang maging maingat sa kung kailan titingnan ang iyong mga Qubit dahil nasisira ng measurement ang kanilang estado at winawasak ang superposition na nagbibigay sa mga Qubit ng kanilang computational na kumplikasyon.

Sa partikular, kapag may ibinigay na $N$-bit na quantum state na $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$, isang measurement ang magbu-bumagsak ng estado sa isa sa mga basis function na $\vert i\rangle$ na may probabilidad na katumbas ng $\vert c_i\vert ^2$.

Ngunit ang mapanirang epektong ito ng isang measurement ay hindi laging isang hadlang. Ito ay isang mahalagang sangkukunan sa ilang mga algorithm at protocol, tulad ng quantum teleportation at quantum key distribution.

Sa Qiskit, kapag ginawa ang isang measurement, ito ay ipinapadala sa isang klasikal na rehistro kung saan ito nai-imbak bilang isang klasikal na bit. Ganito ang hitsura ng paglikha ng Circuit na may measurement:

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

Mga Circuit

Ngayon na alam na natin kung paano gumagana ang mga Qubit, Gate, at Measurement, gawin na natin at i-execute ang ating sariling quantum Circuit! Para dito, kailangan naming ipakilala sa inyo ang isang kapaki-pakinabang na proseso na tinatawag na Qiskit patterns.

Qiskit patterns framework

Ang Qiskit patterns framework ay isang pangkalahatang pamamaraan para sa pag-approach at paglutas ng mga problema gamit ang isang quantum computer. Ito ay binubuo ng apat na hakbang:

1. Pag-map ng aming problema sa mga quantum Circuit at operator
2. Pag-optimize ng Circuit para sa target na hardware
3. Pag-execute sa target na hardware
4. Post-processing ng aming mga resulta

Para mailarawan ang mga hakbang na ito, ipapatupad natin ang isang quantum na bersyon ng half-adder circuit na tinalakay sa itaas.

1. Pag-map

Ang klasikal na adder circuit ay gumagamit ng XOR at AND gate para kalkulahin ang sum at carry bit, ayon sa pagkakasunud-sunod. Maaari nating iayon ang mga gate na ito sa quantum na konteksto para makagawa ng quantum half adder. Una, dahil ang mga quantum gate ay nare-reverse, hindi natin maaaring basta-basta i-overwrite ang mga input. Sa halip, nagpapakilala tayo ng dalawang helper qubit na sinimulan sa $\vert 0\rangle$ para iimbak ang mga output ng sum at carry. Kaya naman, ang ating buong quantum state ay binubuo ng mga Qubit na $A$ at $B$, at ang mga sum at carry qubit, na tatawaging $S$ at $C$:

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

Ngayon, kailangan natin ng mga quantum gate na nagagawa ang ginawa ng XOR at AND gate sa klasikal na circuit.

Sum:

Para sa XOR, nag-a-apply tayo ng dalawang CNOT, bawat isa ay may control qubit na $A$ at $B$ at target qubit na $S$ para sa pareho. Kung magkaiba ang $A$ at $B$, isa sa mga CNOT gate ang magbabalik ng $S$ sa estado na $\vert 1\rangle$. Kung parehong $\vert 0\rangle$ ang $A$ at $B$, walang mangyayari sa $S$ at mananatili ito sa estado na $\vert 0\rangle$. Kung parehong $\vert 1\rangle$ ang $A$ at $B$, ang estado ng $S$ ay magbabago nang dalawang beses, na ibabalik ito sa estado na $\vert 0\rangle$.

Carry:

Para sa carry bit, kailangan natin ng isang bagay na gumagana tulad ng klasikal na AND gate.

Suriin ang iyong pag-unawa

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

Tumingin ulit sa mga gate na ating tinalakay para malaman kung alin ang quantum gate na gagamitin natin bilang kapalit ng klasikal na AND gate:

Sagot:

Ang Toffoli gate! Tandaan, ang Toffoli, o controlled-controlled-NOT gate, ay nagbabalik ng target state kung at tanging kung parehong control qubit 0 AT control qubit 1 ay nasa estado na $\vert 1\rangle$. Kaya naman, kung ang target qubit ay nagsisimula sa estado na $\vert 0\rangle$, mayroon itong parehong epekto ng AND gate.

Kaya naman, mayroon na tayong lahat ng ingredients na kailangan para gumawa ng quantum Circuit:

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

Sa itaas ay ang circuit diagram para sa quantum half-adder circuit. Tulad ng nabanggit kanina, ang mga wire ay kumakatawan sa mga Qubit na $0$ hanggang $3$ na nakaayos mula sa itaas hanggang ibaba, at ang klasikal na bit register ay ang ibabang double-lined na wire. Pagkatapos, nagbabasa mula kaliwa hanggang kanan, nakikita natin kung paano ina-apply ang mga gate sa bawat Qubit sa pamamagitan ng pagtingin kung saan lumalabas ang mga kahon sa kaukulang mga wire. Sa huli, ang mga measurement ay ipinapakita sa katapusan. Binubumagsak ng mga measurement ang mga estado ng Qubit sa mga tiyak na halaga ng $0$ o $1$, at ang mga resulta ay ipinapadala sa isang klasikal na rehistro.

Isang subtlety: kahit na ang circuit diagram ay iguguhit mula kaliwa hanggang kanan, kapag isinusulat ang kaukulang matrix expression ay kailangan nating basahin ito mula kanan hanggang kaliwa. Ito ay dahil sa matrix multiplication, ang operator na pinakamalapit sa state vector (na pinaka-kanan) ang unang kumikilos. Kaya naman, halimbawa, ang circuit sa itaas (hindi kasama ang mga measurement) ay isusulat bilang:

$$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. Pag-optimize:

Susunod, kailangan nating i-optimize ang Circuit para mapatakbo sa quantum hardware. Ang optimization na ito ay nagagawa sa pamamagitan ng Transpiler, na nagsasalin ng abstract na Circuit na ipinapakita sa itaas sa mga instruksyon na mauunawaan ng quantum computer. Itinatakda nito ang mga lohikal na Qubit sa itaas sa mga tunay, pisikal na Qubit sa processor at sinusulat muli ang mga gate sa mga termino ng sarili nitong native na set ng mga gate na na-optimize para tumakbo sa quantum computer. Sa wakas, ang Transpiler ay nagpapatupad din ng tinatawag na "error suppression and mitigation" para subukang bawasan ang epekto ng mga error sa resulta. Hindi ito gaanong mahalaga para sa ating napaka-simpleng Circuit, ngunit kung magpapatuloy ka sa iyong paglalakbay sa quantum computing para magpatakbo ng mas kumplikadong mga Circuit, makikita mo sa lalong madaling panahon ang halaga ng error suppression at mitigation. Kung gusto mong malaman ang higit pa tungkol dito, tingnan ang kurso ni Olivia Lane, Quantum Computing in Practice.

Una, ini-load natin ang mga pakete na kinakailangan para makipag-ugnayan sa mga quantum computer ng IBM® at pumili ng Backend para patakbuhin. Maaari tayong pumili ng pinaka-hindi abala na Backend, o pumili ng isang tiyak na Backend na alam natin ang mga katangian.

Mayroon sa ibaba ang code para sa pag-save ng iyong mga kredensyal sa unang paggamit. Tiyaking burahin ang impormasyong ito mula sa notebook pagkatapos itong i-save sa iyong environment, para hindi aksidenteng maibahagi ang iyong mga kredensyal kapag ibinabahagi mo ang notebook. Tingnan ang Set up your IBM Cloud account at Initialize the service in an untrusted environment para sa karagdagang gabay.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

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

# Load saved credentials
service = QiskitRuntimeService()

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

ibm_fez

Ngayon, ginagamit natin ang Transpiler para i-optimize ang Circuit. Maaari tayong pumili ng optimization level mula 0 (walang optimization) hanggang 3 (pinakamataas na optimization). Para makita kung ano ang nilalaman ng bawat level, bisitahin ang gabay na Set transpiler optimization level. Ang resulting na Circuit ay magmumukhang lubhang naiiba mula sa lohikal na Circuit na ginawa natin sa ating hakbang sa pag-map.

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

Ang "Sampler" ay isang primitive na dinisenyo para mag-sample ng mga posibleng estado na nagmumula sa isang quantum Circuit, at mangolekta ng mga istatistika kung anong mga estado ang maaaring masukat at sa anong probabilidad. Dito natin ini-import ang Qiskit Runtime Sampler:

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

sampler = Sampler(mode=backend)

Kung naubos na ang iyong inilaan na oras sa mga tunay na quantum computer o kung wala kang koneksyon sa internet, baka mas gusto mong gumamit ng simulator. Para gawin ito, patakbuhin ang cell sa ibaba at i-uncomment ang kaukulang linya sa hakbang na "Execute".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

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

noise_model = NoiseModel.from_backend(backend)

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

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

3. Pag-execute

Pagkatapos ihanda ang Circuit, maaari na nating patakbuhin ito sa quantum computer!

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

Handa na tayong tingnan ang ating mga resulta! Magpapakita tayo ng histogram ng 100 na sample ng Circuit.

from qiskit.visualization import plot_histogram

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

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

Ang histogram sa itaas ay nagpapakita ng mga resulta ng measurement ng lahat ng apat na Qubit sa katapusan ng Circuit. Ang isang perpektong quantum computer na may zero noise ay palaging makakakuha ng parehong mga halaga para sa mga Qubit, ngunit sa katotohanan, ang noise ay magiging sanhi ng ilang mga run na makagawa ng mga error.

Suriin ang iyong pag-unawa

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

Gamit ang bitstring na may pinakamaraming bilang bilang iyong mga halaga para sa $A$, $B$, $S$, at $C$, i-verify na gumana ang quantum adder circuit.

Sagot:

Kailangan nating i-verify na $A+B = S+2 \times C$. Tandaan na ang pagkakasunud-sunod ng bitstring ay sumusunod sa little-endian notation, kaya binabasa ito bilang CSBA.

Mula sa histogram sa itaas, nakikita natin na ang 0000 na bitstring ang nangingibabaw.

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

Bumalik at baguhin ang mga halaga ng $A$ at $B$ sa $A=1$ at $B=1$ at dumaan muli sa mga hakbang ng Qiskit patterns para muling patakbuhin ang Circuit. I-verify na gumana muli ang adder circuit.

Sagot:

Dapat kang makakuha ng histogram na may nangingibabaw na bitstring na 1011:

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

Isa sa mga karagdagang katangian ng quantum half-adder kumpara sa klasikal na half-adder ay maaari itong tumakbo gamit ang mga quantum na input. Ibig sabihin, maaari itong "magdagdag" ng mga Qubit na $A$ at $B$ kahit nasa superposition state ang mga ito. Sa seksyon ng Challenge Questions sa ibaba, hihilingin sa inyo na ihanda ang mga Qubit sa mga superposition at tingnan kung ano ang mangyayari!

Konklusyon

Ang modyul na ito ay dinisenyo para bigyan kayo ng matibay na pangunahing pag-unawa sa mga pangunahing prinsipyo sa likod ng quantum computing sa pamamagitan ng paghahambing nito sa klasikal na computing. Tiningnan natin ang klasikal na half-adder circuit at pagkatapos ay ipinakita kung paano iayon ang Circuit para tumakbo gamit ang mga Qubit sa isang quantum computer. Handa ka na ngayong tuklasin ang iba pang mga Qiskit in the Classroom module!

Mga kritikal na konsepto:

• Sa kabaligtaran ng mga klasikal na bit na maaari lamang kumuha ng mga halagang 0 at 1, ang mga Qubit ay maaari ring nasa mga superposition na estado ng parehong 0 at 1.
• Ang maraming Qubit ay maaaring nasa isang superposition sa mga klasikal na pinahihintulutang bitstring na tinatawag na computational basis states.
• Ang maraming Qubit ay maaaring maging entangled upang ang estado ng isa ay nakasalalay sa estado ng isa pa.
• Ang kombensyon ng Qiskit ay ang paggamit ng little-endian notation, na naglalagay ng pinaka-hindi mahalaga na Qubit, $q_0$, sa pinakakanang posisyon at ang pinaka-mahalaga na Qubit, $q_N$, sa kaliwa.
• Ang mga quantum gate ay mga nare-reverse na operasyon na kinakatawan ng mga unitary matrix na kumikilos sa mga quantum state vector. Sa notasyong ito, ang matrix na pinakamalapit sa vector (na pinaka-kanan) ang kumikilos muna.
• Ang mga Measurement ay bumubuwag ng isang quantum superposition state sa isa sa mga klasikal na pinahihintulutang estado nito, na may probabilidad na katumbas ng parisukat ng amplitude ng kaukulang computational basis state sa superposition.
• Ang mga quantum Circuit ay madalas na kinakatawan gamit ang mga quantum circuit diagram, kung saan ang mga Qubit ay inilalarawan bilang mga pahalang na wire, at ang mga quantum gate ay lumalabas sa mga wire na ito mula kaliwa hanggang kanan.
• Para patakbuhin ang isang quantum Circuit, gumagamit tayo ng apat na hakbang sa proseso ng Qiskit patterns: Map, Optimize, Execute, Post-process.

Mga Tanong

Mga Tanong sa Tama/Mali

1. Ang isang solong bit sa isang klasikal na computer ay maaari lamang humawak ng halagang 0 o 1.

2. Ang entanglement ay nangangahulugang ang estado ng isang Qubit ay independyente sa estado ng isa pa.

3. Ang mga quantum gate ay karaniwang mga hindi nare-reverse na operasyon.

4. Inilalagay ng kombensyon ng Qiskit ang pinaka-hindi mahalaga na Qubit, $q_0$, sa pinakakaliwang posisyon.

5. Ang pagsukat ng isang quantum state ay palaging nagbibigay ng eksaktong parehong resulta kung paulit-ulit na gagawin.

6. Ang Hadamard gate ay lumilikha ng superposition sa isang solong Qubit.

7. Ang mga quantum Circuit ay maaaring magsama ng mga operasyong measurement na binubuwag ang superposition state sa isa sa mga klasikal na pinahihintulutang estado.

8. Ang bilang ng mga posibleng klasikal na estado para sa $N$ na bit ay $2N$.

9. Ang mga probabilidad ng resulta para sa mga quantum measurement ay ibinibigay ng mga squared amplitude ng mga klasikal na masusukat na basis state.

Mga Tanong sa Maikling Sagot

1. Ano ang ilang pangunahing pagkakaiba sa pagitan ng isang bit at isang Qubit?

2. Ano ang nangyayari sa isang quantum state kapag ito ay nasukat?

3. Bakit gumagamit tayo ng little-endian notation sa Qiskit?

4. Ano ang apat na hakbang sa proseso ng Qiskit patterns?

Mga Challenge na Tanong:

1. Sa modyul, ginamit lang natin ang adder para magdagdag ng mga klasikal na pinahihintulutang estado para sa $A$ at $B$. Ngunit maaari rin nating ihanda ang $A$ at $B$ sa mga superposition! Baguhin ang code para ihanda ang bawat Qubit sa isang pantay na superposition ng 0 at 1, pagkatapos ay patakbuhin ang bagong Circuit at kumuha ng bagong histogram. Ano ang makikita mo? Ipaliwanag kung ano ang nangyayari.

2. Toffoli gate decomposition. Gamitin ang decompose() para ipakita kung paano nadi-decompose ang Toffoli gate sa mga single- at two-qubit gate, pagkatapos ay i-verify ang konstruksyong ito gamit ang matrix multiplication. Tandaan na kahit ang mga circuit diagram ay binabasa mula kaliwa hanggang kanan, ang mga matrix ay inaapply sa mga quantum state mula kanan hanggang kaliwa!