Pelaksanaan Qiskit

Dalam bahagian ini, kita akan melihat beberapa pelaksanaan Qiskit bagi konsep-konsep yang diperkenalkan dalam pelajaran ini. Jika anda ingin menjalankan pelaksanaan ini sendiri, yang sangat digalakkan, rujuk halaman Pasang Qiskit dalam Dokumentasi IBM Quantum untuk butiran tentang cara menyediakan Qiskit.

Perlu difahami bahawa Qiskit sedang dalam pembangunan berterusan, dan memberi tumpuan utama kepada memaksimumkan prestasi komputer kuantum yang digunakannya, yang turut terus berkembang. Akibatnya, Qiskit tertakluk kepada perubahan yang kadangkala boleh menyebabkan susutan kod. Dengan ini dalam fikiran, kita akan sentiasa melaksanakan arahan berikut sebelum membentangkan contoh kod Qiskit dalam kursus ini, supaya jelas versi Qiskit yang telah digunakan. Bermula dengan Qiskit v1.0, ini adalah cara mudah untuk melihat versi Qiskit yang sedang dipasang.

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

from qiskit import __version__

print(__version__)

2.1.1

Jika anda menjalankan ini dalam persekitaran Python berasaskan awan, anda mungkin perlu memasang beberapa pakej berikut:

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

Vektor dan matriks dalam Python

Qiskit menggunakan bahasa pengaturcaraan Python, jadi sebelum membincangkan Qiskit secara khusus, mungkin berguna untuk membincangkan secara ringkas pengiraan matriks dan vektor dalam Python.

Dalam Python, pengiraan matriks dan vektor boleh dilakukan menggunakan kelas array daripada pustaka NumPy, yang menyediakan fungsi untuk banyak pengiraan berangka dan saintifik. Kod berikut memuatkan pustaka ini, mentakrifkan dua vektor lajur, ket0 dan ket1, yang sepadan dengan vektor keadaan qubit $\vert 0\rangle$ dan $\vert 1\rangle,$ dan kemudian mencetak puratanya.

import numpy as np

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

print(ket0 / 2 + ket1 / 2)

[[0.5]
 [0.5]]

Kita juga boleh menggunakan array untuk mencipta matriks yang boleh mewakili operasi.

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

Sila ambil perhatian bahawa semua kod yang muncul dalam pelajaran tertentu dalam kursus ini dijangka dijalankan secara berurutan. Oleh itu, kita tidak perlu mengimport NumPy lagi di sini, kerana ia telah pun diimport.

Pendaraban matriks, termasuk pendaraban matriks-vektor sebagai kes khas, boleh dilakukan menggunakan fungsi matmul daripada 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]]

Format output ini agak kurang menarik secara visual. Satu penyelesaian, untuk situasi yang memerlukan sesuatu yang lebih cantik, adalah dengan menggunakan fungsi array_to_latex dalam Qiskit, daripada modul qiskit.visualization. Perhatikan bahawa, dalam kod yang berikut, kita menggunakan fungsi display generik Python. Sebaliknya, tingkah laku khusus print mungkin bergantung pada apa yang dicetak, seperti yang berlaku untuk tatasusunan yang ditakrifkan oleh 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}$$

Keadaan, pengukuran, dan operasi

Qiskit merangkumi beberapa kelas yang membolehkan keadaan, pengukuran, dan operasi dicipta dan dimanipulasi — jadi tidak perlu mengaturcara semua yang diperlukan untuk mensimulasi keadaan kuantum, pengukuran, dan operasi dalam Python. Beberapa contoh untuk membantu anda bermula disertakan di bawah.

Takrifkan dan paparkan vektor keadaan

Kelas Statevector dalam Qiskit menyediakan fungsi untuk mentakrifkan dan memanipulasi vektor keadaan kuantum. Dalam kod yang berikut, kelas Statevector diimport dan beberapa vektor ditakrifkan. (Kita juga mengimport fungsi sqrt daripada pustaka NumPy untuk mengira punca kuasa dua. Fungsi ini boleh, secara alternatif, dipanggil sebagai np.sqrt dengan syarat NumPy telah diimport, seperti yang telah dilakukan di atas; ini hanyalah cara berbeza untuk mengimport dan menggunakan fungsi khusus ini sahaja.)

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

Kelas Statevector merangkumi kaedah draw untuk memaparkan vektor keadaan dalam pelbagai cara, termasuk text untuk teks biasa, latex untuk LaTeX yang dirender, dan latex_source untuk kod LaTeX, yang berguna untuk disalin dan ditampal ke dalam dokumen. (Gunakan print dan bukannya display untuk menunjukkan kod LaTeX dengan hasil terbaik.)

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

Kelas Statevector juga merangkumi kaedah is_valid, yang menyemak sama ada vektor yang diberikan adalah vektor keadaan kuantum yang sah (dengan kata lain, bahawa ia mempunyai norma Euklid bersamaan 1):

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

True

False

Mensimulasi pengukuran menggunakan Statevector

Seterusnya kita akan melihat satu cara pengukuran keadaan kuantum boleh disimulasi dalam Qiskit, menggunakan kaedah measure daripada kelas Statevector. Mari kita gunakan vektor keadaan qubit v yang sama seperti yang ditakrifkan sebelum ini.

display(v.draw("latex"))

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

Menjalankan kaedah measure mensimulasi pengukuran asas standard. Ia mengembalikan hasil pengukuran tersebut, ditambah dengan vektor keadaan kuantum baru sistem selepas pengukuran. (Di sini kita menggunakan fungsi print Python dengan awalan f untuk percetakan berformat dengan ungkapan terbenam.)

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

Measured: 1
Post-measurement state:

$- |1\rangle$

Hasil pengukuran adalah berkebarangkalian, jadi kaedah ini boleh mengembalikan hasil yang berbeza apabila dijalankan beberapa kali. Untuk contoh khusus vektor v yang ditakrifkan di atas, kaedah measure mentakrifkan vektor keadaan kuantum selepas pengukuran berlaku sebagai

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

(berbanding $\vert 0\rangle$) atau

$$- \vert 1\rangle$$

(berbanding $\vert 1\rangle$), bergantung pada hasil pengukuran. Dalam kedua-dua kes, alternatif kepada $\vert 0\rangle$ dan $\vert 1\rangle$ sebenarnya setara dengan vektor keadaan ini; ia dikatakan setara sehingga fasa global kerana satu sama dengan yang lain didarab dengan nombor kompleks pada bulatan unit. Isu ini dibincangkan dengan lebih terperinci dalam pelajaran Litar kuantum, dan boleh diabaikan buat masa ini.

Statevector akan melemparkan ralat jika kaedah measure digunakan pada vektor keadaan kuantum yang tidak sah.

Statevector juga dilengkapi dengan kaedah sample_counts yang membolehkan simulasi sebarang bilangan pengukuran pada sistem, setiap kali bermula dengan salinan segar keadaan tersebut. Sebagai contoh, kod berikut menunjukkan hasil pengukuran vektor v sebanyak $1000$ kali, yang (dengan kebarangkalian tinggi) menghasilkan hasil $0$ kira-kira $5$ daripada setiap $9$ kali (atau kira-kira $556$ daripada $1000$ percubaan) dan hasil $1$ kira-kira $4$ daripada setiap $9$ kali (atau kira-kira $444$ daripada $1000$ percubaan). Kod yang berikut juga menunjukkan fungsi plot_histogram daripada modul qiskit.visualization untuk memvisualisasikan keputusan.

from qiskit.visualization import plot_histogram

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

Menjalankan kod ini sendiri beberapa kali, dengan bilangan sampel yang berbeza menggantikan $1000,$ mungkin berguna untuk membina intuisi tentang bagaimana bilangan percubaan mempengaruhi bilangan kali setiap hasil muncul. Dengan lebih banyak sampel, pecahan sampel bagi setiap kemungkinan berkemungkinan semakin hampir kepada kebarangkalian yang sepadan. Fenomena ini, secara lebih amnya, dikenali sebagai hukum nombor besar dalam teori kebarangkalian.

Lakukan operasi dengan Operator dan Statevector

Operasi unitari boleh ditakrifkan dalam Qiskit menggunakan kelas Operator, seperti dalam contoh yang berikut. Kelas ini merangkumi kaedah draw dengan argumen yang serupa dengan Statevector. Perhatikan bahawa pilihan latex menghasilkan keputusan yang setara dengan 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}$$

Kita boleh menggunakan operasi unitari pada vektor keadaan menggunakan kaedah evolve.

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$

Pratonton litar kuantum

Circuit tidak akan diperkenalkan secara rasmi sehingga pelajaran Litar kuantum, yang merupakan pelajaran ketiga dalam kursus ini, tetapi kita tetap boleh bereksperimen dengan menggubah operasi unitari qubit menggunakan kelas QuantumCircuit dalam Qiskit. Khususnya, kita boleh mentakrifkan Circuit kuantum (yang dalam kes ini hanya merupakan urutan operasi unitari yang dilakukan pada satu qubit) seperti berikut.

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

Di sini kita menggunakan kaedah draw daripada kelas QuantumCircuit dengan renderer mpl (singkatan untuk Matplotlib, pustaka visualisasi Python). Ini adalah satu-satunya renderer yang akan kita gunakan untuk litar kuantum dalam kursus ini, tetapi terdapat pilihan lain, termasuk renderer berasaskan teks dan berasaskan LaTeX.

Operasi-operasi digunakan secara berurutan, bermula dari kiri dan berakhir di kanan dalam gambar rajah. Cara yang berguna untuk mendapatkan matriks unitari yang sepadan dengan Circuit ini adalah menggunakan kaedah from_circuit daripada kelas Operator.

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

Kita juga boleh memulakan vektor keadaan kuantum permulaan dan kemudian mengevolusi keadaan tersebut mengikut urutan operasi yang diterangkan oleh 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$

Kod berikut mensimulasi eksperimen di mana keadaan yang diperoleh daripada Circuit di atas diukur dengan pengukuran asas standard sebanyak 4000 kali (menggunakan salinan segar keadaan setiap kali).

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