Implementasi Qiskit

Di bagian ini, kita akan melihat beberapa implementasi Qiskit dari konsep-konsep yang diperkenalkan dalam pelajaran ini. Jika kamu ingin menjalankan implementasi ini sendiri, yang sangat disarankan, lihat halaman Install Qiskit di IBM Quantum Documentation untuk detail cara menyiapkan Qiskit.

Perlu dipahami bahwa Qiskit terus dikembangkan, dan terutama berfokus pada memaksimalkan kinerja komputer kuantum yang dioperasikannya, yang juga terus berkembang. Akibatnya, Qiskit dapat mengalami perubahan yang sesekali mengakibatkan deprecation kode. Dengan mempertimbangkan hal ini, kita selalu akan menjalankan perintah berikut sebelum menyajikan contoh kode Qiskit dalam kursus ini, sehingga jelas versi Qiskit mana yang digunakan. Mulai dari Qiskit v1.0, ini adalah cara sederhana untuk melihat versi Qiskit yang saat ini terinstal.

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

from qiskit import __version__

print(__version__)

2.1.1

Jika kamu menjalankan ini di lingkungan Python berbasis cloud, kamu mungkin perlu menginstal beberapa paket berikut:

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

Vektor dan matriks di Python

Qiskit menggunakan bahasa pemrograman Python, jadi sebelum membahas Qiskit secara khusus, mungkin berguna untuk membahas secara singkat komputasi matriks dan vektor di Python.

Di Python, komputasi matriks dan vektor bisa dilakukan menggunakan kelas array dari pustaka NumPy, yang menyediakan fungsionalitas untuk banyak komputasi numerik dan ilmiah. Kode berikut memuat pustaka ini, mendefinisikan dua vektor kolom, ket0 dan ket1, yang sesuai dengan vektor keadaan qubit $\vert 0\rangle$ dan $\vert 1\rangle,$ lalu mencetak rata-ratanya.

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 bisa menggunakan array untuk membuat matriks yang bisa merepresentasikan 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]]

Perlu dicatat bahwa semua kode yang muncul dalam pelajaran tertentu dalam kursus ini diharapkan dijalankan secara berurutan. Oleh karena itu, kita tidak perlu mengimpor NumPy lagi di sini, karena sudah diimpor sebelumnya.

Perkalian matriks, termasuk perkalian matriks-vektor sebagai kasus khusus, bisa dilakukan menggunakan fungsi matmul dari 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 masih kurang ideal secara visual. Salah satu solusi, untuk situasi yang membutuhkan tampilan yang lebih indah, adalah menggunakan fungsi array_to_latex di Qiskit, dari modul qiskit.visualization. Perhatikan bahwa dalam kode berikut, kita menggunakan fungsi generik display dari Python. Sebaliknya, perilaku spesifik print mungkin tergantung pada apa yang dicetak, seperti yang terjadi pada array yang didefinisikan 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 menyertakan beberapa kelas yang memungkinkan keadaan, pengukuran, dan operasi dibuat dan dimanipulasi — sehingga tidak perlu memprogram semua yang diperlukan untuk mensimulasikan keadaan kuantum, pengukuran, dan operasi di Python. Beberapa contoh untuk membantu kamu memulai termasuk di bawah ini.

Mendefinisikan dan menampilkan vektor keadaan

Kelas Statevector di Qiskit menyediakan fungsionalitas untuk mendefinisikan dan memanipulasi vektor keadaan kuantum. Dalam kode berikut, kelas Statevector diimpor dan beberapa vektor didefinisikan. (Kita juga mengimpor fungsi sqrt dari pustaka NumPy untuk menghitung akar kuadrat. Fungsi ini, sebagai alternatif, bisa dipanggil sebagai np.sqrt asalkan NumPy sudah diimpor, seperti yang telah dilakukan di atas; ini hanyalah cara berbeda untuk mengimpor dan menggunakan fungsi spesifik ini saja.)

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 menyertakan metode draw untuk menampilkan vektor keadaan dengan berbagai cara, termasuk text untuk teks biasa, latex untuk LaTeX yang dirender, dan latex_source untuk kode LaTeX, yang berguna untuk disalin dan ditempel ke dokumen. (Gunakan print daripada display untuk menampilkan kode 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 menyertakan metode is_valid, yang memeriksa apakah vektor yang diberikan adalah vektor keadaan kuantum yang valid (dengan kata lain, bahwa ia memiliki norma Euclidean sama dengan 1):

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

True

False

Mensimulasikan pengukuran menggunakan Statevector

Selanjutnya kita akan melihat salah satu cara pengukuran keadaan kuantum bisa disimulasikan di Qiskit, menggunakan metode measure dari kelas Statevector. Mari kita gunakan vektor keadaan qubit v yang sama yang didefinisikan sebelumnya.

display(v.draw("latex"))

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

Menjalankan metode measure mensimulasikan pengukuran basis standar. Ini mengembalikan hasil pengukuran tersebut, ditambah vektor keadaan kuantum baru dari sistem setelah pengukuran. (Di sini kita menggunakan fungsi print Python dengan awalan f untuk pencetakan terformat dengan ekspresi yang disematkan.)

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

Measured: 1
Post-measurement state:

$- |1\rangle$

Hasil pengukuran bersifat probabilistik, sehingga metode ini bisa mengembalikan hasil yang berbeda saat dijalankan beberapa kali. Untuk contoh khusus vektor v yang didefinisikan di atas, metode measure mendefinisikan vektor keadaan kuantum setelah pengukuran menjadi

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

(bukan $\vert 0\rangle$) atau

$$- \vert 1\rangle$$

(bukan $\vert 1\rangle$), tergantung pada hasil pengukuran. Dalam kedua kasus, alternatif dari $\vert 0\rangle$ dan $\vert 1\rangle$ sebenarnya setara dengan vektor keadaan tersebut; dikatakan ekuivalen hingga fase global karena satu sama dengan yang lain dikalikan dengan bilangan kompleks pada lingkaran satuan. Masalah ini dibahas lebih rinci dalam pelajaran Quantum circuits, dan untuk saat ini bisa diabaikan.

Statevector akan menghasilkan error jika metode measure diterapkan pada vektor keadaan kuantum yang tidak valid.

Statevector juga dilengkapi metode sample_counts yang memungkinkan simulasi sejumlah pengukuran pada sistem, setiap kali dimulai dengan salinan baru dari keadaan. Misalnya, kode berikut menunjukkan hasil pengukuran vektor v sebanyak $1000$ kali, yang (dengan probabilitas tinggi) menghasilkan hasil $0$ kira-kira $5$ dari setiap $9$ kali (atau sekitar $556$ dari $1000$ percobaan) dan hasil $1$ kira-kira $4$ dari setiap $9$ kali (atau sekitar $444$ dari $1000$ percobaan). Kode berikut juga mendemonstrasikan fungsi plot_histogram dari modul qiskit.visualization untuk memvisualisasikan hasilnya.

from qiskit.visualization import plot_histogram

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

Menjalankan kode ini sendiri beberapa kali, dengan jumlah sampel yang berbeda sebagai pengganti $1000,$ mungkin berguna untuk mengembangkan intuisi tentang bagaimana jumlah percobaan mempengaruhi berapa kali setiap hasil muncul. Dengan semakin banyak sampel, fraksi sampel untuk setiap kemungkinan kemungkinan akan semakin mendekati probabilitas yang sesuai. Fenomena ini, secara lebih umum, dikenal sebagai hukum bilangan besar dalam teori probabilitas.

Melakukan operasi dengan Operator dan Statevector

Operasi uniter bisa didefinisikan di Qiskit menggunakan kelas Operator, seperti dalam contoh berikut. Kelas ini menyertakan metode draw dengan argumen serupa dengan Statevector. Perhatikan bahwa opsi latex menghasilkan hasil 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 bisa menerapkan operasi uniter pada vektor keadaan menggunakan metode 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$

Pratinjau Circuit kuantum

Circuit kuantum tidak akan diperkenalkan secara formal sampai pelajaran Quantum circuits, yang merupakan pelajaran ketiga dalam kursus ini, tapi kita tetap bisa bereksperimen dengan mengomposisikan operasi uniter qubit menggunakan kelas QuantumCircuit di Qiskit. Secara khusus, kita bisa mendefinisikan Circuit kuantum (yang, dalam kasus ini, hanyalah urutan operasi uniter yang dilakukan pada satu qubit) sebagai 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 metode draw dari kelas QuantumCircuit dengan renderer mpl (singkatan dari Matplotlib, pustaka visualisasi Python). Ini adalah satu-satunya renderer yang akan kita gunakan untuk Circuit kuantum dalam kursus ini, tapi ada opsi lain, termasuk renderer berbasis teks dan berbasis LaTeX.

Operasi diterapkan secara berurutan, dimulai dari kiri dan berakhir di kanan dalam diagram. Cara praktis untuk mendapatkan matriks uniter yang sesuai dengan Circuit ini adalah menggunakan metode from_circuit dari 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 bisa menginisialisasi vektor keadaan kuantum awal dan kemudian mengevolusi keadaan itu sesuai dengan urutan operasi yang dijelaskan 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$

Kode berikut mensimulasikan eksperimen di mana keadaan yang diperoleh dari Circuit di atas diukur dengan pengukuran basis standar sebanyak 4000 kali (menggunakan salinan keadaan yang baru setiap kali).

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