Implementasyon sa Qiskit

Sa seksyong ito, titingnan natin ang ilang implementasyon sa Qiskit ng mga konsepto na ipinakilala sa araling ito. Kung gusto mong patakbuhin ang mga implementasyong ito nang ikaw mismo, na lubos na hinihikayat, tingnan ang pahina ng Install Qiskit sa IBM Quantum Documentation para sa mga detalye kung paano i-set up ang Qiskit.

Dapat maintindihan na ang Qiskit ay patuloy na nino-develop, at pangunahing nakatuon sa pag-maximize ng performance ng mga quantum computer na ginagamit nito, na patuloy ding nagbabago. Dahil dito, ang Qiskit ay sumasailalim sa mga pagbabago na maaaring paminsan-minsan ay magdulot ng code deprecation. Sa isip ito, palagi naming isasagawa ang mga sumusunod na command bago ipakita ang mga halimbawa ng Qiskit code sa kursong ito, para malinaw kung aling bersyon ng Qiskit ang ginamit. Simula sa Qiskit v1.0, ito ay isang simpleng paraan para makita kung anong bersyon ng Qiskit ang kasalukuyang naka-install.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

from qiskit import __version__

print(__version__)

2.1.1

Kung pinapatakbo mo ito sa isang cloud-based na Python environment, maaaring kailangan mong i-install ang ilan sa mga sumusunod na package:

#!pip install qiskit
#!pip install jupyter
#!pip install sympy
#!pip install matplotlib
#!pip install pylatexenc

Mga vector at matrix sa Python

Gumagamit ang Qiskit ng programming language na Python, kaya bago talakayin ang Qiskit nang espesipiko, maaaring makatulong na maikli munang talakayin ang matrix at vector computations sa Python.

Sa Python, ang matrix at vector computations ay maaaring isagawa gamit ang array class mula sa NumPy library, na nagbibigay ng functionality para sa maraming numerical at scientific computations. Ang sumusunod na code ay naglo-load ng library na ito, nagtatakda ng dalawang column vector, ket0 at ket1, na tumutugma sa qubit state vector na $\vert 0\rangle$ at $\vert 1\rangle,$ at pagkatapos ay ini-print ang kanilang average.

import numpy as np

ket0 = np.array([[1], [0]])
ket1 = np.array([[0], [1]])

print(ket0 / 2 + ket1 / 2)

[[0.5]
 [0.5]]

Maaari rin tayong gumamit ng array para gumawa ng mga matrix na maaaring kumatawan sa mga operasyon.

M1 = np.array([[1, 1], [0, 0]])
M2 = np.array([[1, 0], [0, 1]])
M = M1 / 2 + M2 / 2
print(M)

[[1.  0.5]
 [0.  0.5]]

Pakitandaan na ang lahat ng code na lumalabas sa loob ng isang aralin sa kursong ito ay inaasahang tatakbuhin nang sunud-sunod. Kaya naman, hindi na natin kailangang i-import muli ang NumPy dito, dahil na-import na ito.

Ang matrix multiplication, kasama na ang matrix-vector multiplication bilang isang espesyal na kaso, ay maaaring isagawa gamit ang matmul function mula sa NumPy.

print(np.matmul(M1, ket1))
print(np.matmul(M1, M2))
print(np.matmul(M, M))

[[1]
 [0]]
[[1 1]
 [0 0]]
[[1.   0.75]
 [0.   0.25]]

Ang output formatting na ito ay may kung ano mang kulang, sa visual na paraan. Isang solusyon, para sa mga sitwasyong nangangailangan ng mas maganda, ay ang gamitin angarray_to_latex function sa Qiskit, mula sa qiskit.visualization module. Tandaan na sa code na susunod, gumagamit tayo ng generic na display function ng Python. Sa kaibahan, ang partikular na gawi ng print ay maaaring depende sa kung ano ang ini-print, tulad ng ginagawa nito para sa mga array na tinukoy ng NumPy.

from qiskit.visualization import array_to_latex

display(array_to_latex(np.matmul(M1, ket1)))
display(array_to_latex(np.matmul(M1, M2)))
display(array_to_latex(np.matmul(M, M)))

$$\begin{bmatrix} 1 \\ 0 \\ \end{bmatrix}$$ $$\begin{bmatrix} 1 & 1 \\ 0 & 0 \\ \end{bmatrix}$$ $$\begin{bmatrix} 1 & \frac{3}{4} \\ 0 & \frac{1}{4} \\ \end{bmatrix}$$

Mga state, measurement, at operasyon

Ang Qiskit ay naglalaman ng ilang mga class na nagpapahintulot sa mga state, measurement, at operasyon na gawin at manipulahin — kaya naman hindi na kailangang i-program ang lahat ng kailangan para i-simulate ang mga quantum state, measurement, at operasyon sa Python. Kasama sa ibaba ang ilang halimbawa para makatulong sa iyo na magsimula.

Tukuyin at ipakita ang mga state vector

AngStatevector class sa Qiskit ay nagbibigay ng functionality para sa pagtukoy at pag-manipulate ng mga quantum state vector. Sa code na susunod, ang Statevector class ay ini-import at ilang vector ang tinukoy. (Ino-import din natin ang sqrt function mula sa NumPy library para kalkulahin ang square root. Ang function na ito ay maaaring, bilang alternatibo, tawaging np.sqrt basta na-import na ang NumPy, tulad ng ginawa sa itaas; ito ay isang ibang paraan lamang para i-import at gamitin ang partikular na function na ito nang mag-isa.)

from qiskit.quantum_info import Statevector
from numpy import sqrt

u = Statevector([1 / sqrt(2), 1 / sqrt(2)])
v = Statevector([(1 + 2.0j) / 3, -2 / 3])
w = Statevector([1 / 3, 2 / 3])

Ang Statevector class ay naglalaman ng draw method para ipakita ang mga state vector sa iba't ibang paraan, kasama ang text para sa plain text, latex para sa rendered LaTeX, at latex_source para sa LaTeX code, na maaaring maging kapaki-pakinabang para sa pag-cut at pag-paste sa mga dokumento. (Gamitin ang print sa halip na display para ipakita ang LaTeX code para sa pinakamainam na resulta.)

display(u.draw("text"))
display(u.draw("latex"))
print(u.draw("latex_source"))

[0.70710678+0.j,0.70710678+0.j]

$\frac{\sqrt{2}}{2} |0\rangle+\frac{\sqrt{2}}{2} |1\rangle$

\frac{\sqrt{2}}{2} |0\rangle+\frac{\sqrt{2}}{2} |1\rangle

Ang Statevector class ay naglalaman din ng is_valid method, na sinusuri kung ang isang ibinigay na vector ay isang valid na quantum state vector (sa ibang salita, na mayroon itong Euclidean norm na katumbas ng 1):

display(u.is_valid())
display(w.is_valid())

True

False

Pag-simulate ng mga measurement gamit ang Statevector

Susunod ay makikita natin ang isang paraan na ang mga measurement ng quantum state ay maaaring i-simulate sa Qiskit, gamit ang measure method mula sa Statevector class. Gamitin natin ang parehong qubit state vector v na tinukoy kanina.

display(v.draw("latex"))

$(\frac{1}{3} + \frac{2 i}{3}) |0\rangle- \frac{2}{3} |1\rangle$

Ang pagpapatakbo ng measure method ay nag-si-simulate ng isang standard basis measurement. Ibinabalik nito ang resulta ng measurement na iyon, kasama ang bagong quantum state vector ng sistema pagkatapos ng measurement. (Dito ay gumagamit tayo ng print function ng Python na may f prefix para sa formatted printing na may embedded na mga expression.)

outcome, state = v.measure()
print(f"Measured: {outcome}\nPost-measurement state:")
display(state.draw("latex"))

Measured: 1
Post-measurement state:

$- |1\rangle$

Ang mga resulta ng measurement ay probabilistiko, kaya ang method na ito ay maaaring magbalik ng iba't ibang resulta kapag pinatakbo nang maraming beses. Para sa partikular na halimbawa ng vector v na tinukoy sa itaas, tinutukoy ng measure method ang quantum state vector pagkatapos ng measurement na magiging

$$\biggl(\frac{1 + 2i}{\sqrt{5}}\biggr) \vert 0\rangle$$

(sa halip na $\vert 0\rangle$) o

$$- \vert 1\rangle$$

(sa halip na $\vert 1\rangle$), depende sa resulta ng measurement. Sa parehong kaso, ang mga alternatibo sa $\vert 0\rangle$ at $\vert 1\rangle$ ay, sa katunayan, katumbas ng mga state vector na ito; sinasabing sila ay katumbas hanggang sa isang global phase dahil ang isa ay katumbas ng isa pa na pinarami ng isang complex number sa unit circle. Ang isyung ito ay tinalakay nang mas detalyado sa aralin ng Quantum circuits, at ligtas na maaaring balewalain sa ngayon.

Ang Statevector ay magta-throw ng error kung ang measure method ay inilapat sa isang invalid na quantum state vector.

Ang Statevector ay may kasamang sample_counts method din na nagpapahintulot sa pag-simulate ng kahit ilang measurement sa sistema, sa bawat oras na nagsisimula sa isang sariwang kopya ng state. Halimbawa, ang sumusunod na code ay nagpapakita ng resulta ng pagsukat ng vector v $1000$ na beses, na (na may mataas na posibilidad) ay nagbubunga ng resulta na $0$ humigit-kumulang $5$ sa bawat $9$ beses (o humigit-kumulang $556$ sa $1000$ na pagsubok) at ang resulta na $1$ humigit-kumulang $4$ sa bawat $9$ beses (o humigit-kumulang $444$ sa $1000$ na pagsubok). Ipinapakita rin ng code na susunod ang plot_histogram function mula sa qiskit.visualization module para visualisahin ang mga resulta.

from qiskit.visualization import plot_histogram

statistics = v.sample_counts(1000)
plot_histogram(statistics)

Ang pagpapatakbo ng code na ito nang maraming beses, na may iba't ibang bilang ng sample sa halip na $1000,$ ay maaaring makatulong sa pagbuo ng ilang intuisyon kung paano naiimpluwensyahan ng bilang ng mga pagsubok ang bilang ng mga beses na lumalabas ang bawat resulta. Sa mas marami at mas maraming sample, ang fraction ng mga sample para sa bawat posibilidad ay malamang na magiging mas malapit at mas malapit sa katumbas na posibilidad. Ang fenomenong ito, sa mas pangkalahatang paraan, ay kilala bilang batas ng malalaking numero sa probability theory.

Magsagawa ng mga operasyon gamit ang Operator at Statevector

Ang mga unitary operation ay maaaring tukuyin sa Qiskit gamit ang Operator class, tulad ng sa halimbawa na sumusunod. Ang class na ito ay naglalaman ng draw method na may katulad na mga argumento sa Statevector. Tandaan na ang latex option ay nagpo-produce ng mga resulta na katumbas ng array_from_latex.

from qiskit.quantum_info import Operator

Y = Operator([[0, -1.0j], [1.0j, 0]])
H = Operator([[1 / sqrt(2), 1 / sqrt(2)], [1 / sqrt(2), -1 / sqrt(2)]])
S = Operator([[1, 0], [0, 1.0j]])
T = Operator([[1, 0], [0, (1 + 1.0j) / sqrt(2)]])

display(T.draw("latex"))

$$\begin{bmatrix} 1 & 0 \\ 0 & \frac{\sqrt{2}}{2} + \frac{\sqrt{2} i}{2} \\ \end{bmatrix}$$

Maaari nating ilapat ang isang unitary operation sa isang state vector gamit ang evolve method.

v = Statevector([1, 0])

v = v.evolve(H)
v = v.evolve(T)
v = v.evolve(H)
v = v.evolve(S)
v = v.evolve(Y)

display(v.draw("latex"))

$(0.1464466094 - 0.3535533906 i) |0\rangle+(-0.3535533906 + 0.8535533906 i) |1\rangle$

Isang preview ng quantum circuits

Ang mga quantum circuit ay hindi pormal na ipapakilala hanggang sa aralin ng Quantum circuits, na siyang ikatlong aralin sa kursong ito, ngunit maaari pa rin tayong mag-eksperimento sa pag-compose ng mga qubit unitary operation gamit angQuantumCircuit class sa Qiskit. Sa partikular, maaari tayong tumukoy ng quantum circuit (na, sa kasong ito, ay magiging isang pagkakasunud-sunod ng mga unitary operation na isinasagawa sa isang qubit) tulad ng sumusunod.

from qiskit import QuantumCircuit

circuit = QuantumCircuit(1)

circuit.h(0)
circuit.t(0)
circuit.h(0)
circuit.s(0)
circuit.y(0)

display(circuit.draw(output="mpl"))

Dito ay ginagamit natin ang draw method mula sa QuantumCircuit class na may mpl renderer (maikli para sa Matplotlib, isang Python visualization library). Ito ang tanging renderer na gagamitin natin para sa mga quantum circuit sa kursong ito, ngunit may iba pang mga opsyon, kasama ang isang text-based at isang LaTeX-based na renderer.

Ang mga operasyon ay inilalapat nang sunud-sunod, nagsisimula sa kaliwa at nagtatapos sa kanan sa diagram. Isang maginhawang paraan para makuha ang unitary matrix na tumutugma sa circuit na ito ay ang gamitin ang from_circuit method mula sa Operator class.

display(Operator.from_circuit(circuit).draw("latex"))

$$\begin{bmatrix} 0.1464466094 - 0.3535533906 i & 0.8535533906 + 0.3535533906 i \\ -0.3535533906 + 0.8535533906 i & 0.3535533906 + 0.1464466094 i \\ \end{bmatrix}$$

Maaari rin tayong mag-initialize ng panimulang quantum state vector at pagkatapos ay paunlarin ang state na iyon ayon sa pagkakasunud-sunod ng mga operasyong inilarawan ng circuit.

ket0 = Statevector([1, 0])
v = ket0.evolve(circuit)
display(v.draw("latex"))

$(0.1464466094 - 0.3535533906 i) |0\rangle+(-0.3535533906 + 0.8535533906 i) |1\rangle$

Ang sumusunod na code ay nag-si-simulate ng isang eksperimento kung saan ang state na nakuha mula sa circuit sa itaas ay sinusukat gamit ang isang standard basis measurement ng 4000 beses (gamit ang isang sariwang kopya ng state sa bawat oras).

statistics = v.sample_counts(4000)
display(plot_histogram(statistics))