Mulai menggunakan Qiskit di kelas

Untuk modul Qiskit in Classrooms ini, siswa harus memiliki lingkungan Python yang berfungsi dengan paket-paket berikut terinstal:

• qiskit v2.1.0 atau lebih baru
• qiskit-ibm-runtime v0.40.1 atau lebih baru
• qiskit-aer v0.17.0 atau lebih baru
• qiskit.visualization
• numpy
• pylatexenc

Untuk mengatur dan menginstal paket-paket di atas, lihat panduan Install Qiskit. Agar bisa menjalankan job di komputer kuantum sungguhan, siswa perlu membuat akun di IBM Quantum® dengan mengikuti langkah-langkah di panduan Set up your IBM Cloud® account.

Modul ini telah diuji dan menggunakan 2 detik waktu QPU pada prosesor Heron v2. Ini hanya perkiraan. Penggunaan aktualmu bisa berbeda.

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

Pengantar

Dalam modul Qiskit in the Classroom, kamu akan berkesempatan menggunakan komputer kuantum untuk menjelajahi berbagai konsep di bidang yang berdekatan dengan komputasi kuantum seperti mekanika kuantum, ilmu komputer, kimia, dan lainnya. Modul ini menjadi prasyarat untuk modul-modul lainnya — modul ini memperkenalkan dasar-dasar komputasi kuantum dan cara menggunakan Qiskit untuk menjalankan sirkuit kuantum.

Pertama, kita akan memberi kamu gambaran singkat tentang cara kerja komputer klasik, lalu kita tunjukkan bagaimana konsep-konsep tersebut diadaptasi ke paradigma komputasi kuantum. Terakhir, kita tunjukkan cara menggabungkan konsep-konsep ini untuk membangun dan mengeksekusi sirkuit kuantum pertamamu.

Komputer klasik

Kamu mungkin sudah familiar dengan dasar-dasar cara kerja komputer klasik, tapi di sini kita akan menyoroti beberapa fitur utama agar kita bisa membandingkannya dengan komputer kuantum.

Unit informasi dasar: bit

Komputer klasik memproses informasi klasik, dan unit dasar informasi klasik adalah bit. Satu bit bisa menyimpan jawaban dari satu pertanyaan "ya/tidak". Kita biasanya merepresentasikan dua keadaan biner dari sebuah bit sebagai "0" dan "1".

Tinjauan bilangan biner

Menggabungkan bit memungkinkan kamu menyimpan lebih banyak informasi. Misalnya, jika kamu ingin menyimpan angka dari 0 hingga 15, kamu bisa melakukannya dengan empat bit seperti berikut:

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

Secara umum, untuk mengonversi bilangan biner sebanyak $N$ bit ke angka basis-10 yang biasa kamu kenal, kalikan bit paling tidak signifikan (paling kanan) dengan $2^0 = 1$, bit berikutnya ke kiri dengan $2^1 = 2$, lalu berikutnya dengan $2^2 = 4$, dan seterusnya, hingga mencapai bit paling signifikan (paling kiri), yang dikali $2^{N-1}$.

Jadi, artinya $N$ bit bisa berada di salah satu dari $2^N$ keadaan yang berbeda.

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Berapa bit yang kamu butuhkan untuk merepresentasikan angka 86? Tuliskan bitstring yang mengkodekan angka ini dalam biner.

Jawaban:

Ingat, $N$ bit memungkinkan kamu merepresentasikan angka $0$ hingga $2^N - 1$, jadi menggunakan enam bit akan menghasilkan angka hingga $2^6 - 1 = 63$. Itu belum cukup. Kita tambahkan satu bit lagi untuk mencapai $2^7 - 1 = 127$. Sekarang mari kita uraikan 86 ke dalam pangkat 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}$$

Operasi dasar: gate

Sekarang, komputer perlu bisa melakukan sesuatu dengan bit agar bisa, ya, melakukan komputasi. Gate biner adalah operasi yang membentuk blok bangunan fundamental dari semua algoritma dan kode yang lebih kompleks.

Gate satu bit:

NOT

Jika kamu hanya punya satu bit, hanya ada satu cara untuk mengubah keadaannya: membalik keadaan dari 0 ke 1 atau dari 1 ke 0. Kita menyebut ini Gate "NOT". Efek gate ini — dan gate-gate lain yang akan kita bahas di bawah — dapat direpresentasikan dalam apa yang disebut "tabel kebenaran," dengan kolom untuk keadaan input dan output dari qubit. Tabel kebenaran untuk Gate NOT adalah:

Input	Output
0	1
1	0

Gate multi-bit:

AND

AND adalah gate dua bit yang mengambil dua bit input dan menghasilkan satu bit output. Menghasilkan 1 jika kedua bit input adalah 1, dan 0 jika sebaliknya:

Input	Output
00	0
01	0
10	0
11	1

OR

OR adalah gate dua bit lain dengan satu bit output. Menghasilkan 1 jika salah satu bit adalah 1:

Input	Output
00	0
01	1
10	1
11	1

XOR

XOR singkatan dari "exclusive OR" dan mirip dengan Gate OR, tapi menghasilkan 1 jika hanya satu dari bit input yang bernilai 1. Menghasilkan 0 jika keduanya bernilai 1 atau keduanya bernilai 0:

Input	Output
00	0
01	1
10	1
11	0

Pengukuran:

Biasanya, ketika belajar tentang komputasi klasik, tidak banyak perhatian yang diberikan pada proses membaca keadaan bit. Ini karena tidak terlalu rumit dari sudut pandang konseptual. Kamu bisa mengukur bit kapan saja sebelum, selama, atau setelah komputasi, dan itu tidak mempengaruhi hasilnya. Hal ini tidak berlaku dalam komputasi kuantum, seperti yang akan kita bahas di bawah.

Circuit:

Dengan menggabungkan gate-gate di atas, kamu bisa melakukan segala jenis operasi yang diinginkan pada komputer. Mari kita ambil contoh sederhana: Menggunakan gate AND dan XOR, kamu bisa membangun sirkuit half-adder, yang menghitung jumlah dua bit. Ini direpresentasikan dalam diagram sirkuit logika, di mana kabel-kabel merepresentasikan bit dan gate-gate yang beroperasi pada bit ditampilkan sebagai simbol pada kabel yang sesuai:

Jadi, dua bit disalin dan dimasukkan ke gate AND dan gate XOR. Hasil dari gate XOR adalah "bit jumlah" (S), yang tetap berada di posisi satuan bilangan biner, dan hasil dari gate AND adalah "bit carry" (C), yaitu nilai digit paling signifikan berikutnya dalam bilangan biner. Berikut tabel kebenarannya:

$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

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Verifikasi bahwa tabel kebenaran di atas menghasilkan solusi yang benar untuk sirkuit adder. Yaitu, untuk masing-masing dari empat pilihan A dan B, verifikasi bahwa $A+B=S+2 \times C$.

Jawaban:

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

Komputer kuantum

Bit $\rightarrow$ qubit

Sama seperti bit adalah unit dasar informasi klasik, bit kuantum, atau "qubit," adalah unit dasar informasi kuantum. Seperti bit klasik, keadaan sebuah Qubit bisa berupa 0 atau 1, yang biasanya kita notasikan sebagai $\vert 0\rangle$ dan $\vert 1\rangle$. Tapi tidak seperti bit klasik, bit kuantum juga bisa berada dalam superposisi dari kedua keadaan $\vert 0\rangle$ dan $\vert 1\rangle$ secara bersamaan. Secara umum, sebuah Qubit bisa berada dalam keadaan $\vert \psi\rangle$ dengan bentuk:

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

di mana $c_0$ dan $c_1$ adalah amplitudo kompleks dengan $\vert c_0 \vert ^2+\vert c_1\vert ^2=1$.

Fase kuantum

Karena $c_0$ dan $c_1$ adalah bilangan kompleks, masing-masing bisa ditulis sebagai $c_i = \vert c_i\vert e^{i\phi_i}$ di mana $\phi_i$ disebut fase. Jika kita mengalikan seluruh keadaan dengan faktor fase keseluruhan yang sama, tidak ada yang berubah secara fisik — ini disebut fase global, dan tidak memiliki konsekuensi yang bisa diamati.

Untuk itu, konvensinya adalah "memfaktorkan" $e^{i\phi_0}$, sehingga:

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

di mana $\phi = \phi_1-\phi_0$ adalah fase relatif dari keadaan kuantum, yang memang memiliki konsekuensi yang bisa diamati.

Fase ini memainkan peran yang sangat penting dalam komputasi kuantum, dan kamu akan menjelajahi berbagai konsekuensinya dalam modul Qiskit in the Classroom berikutnya.

Banyak qubit

Sementara keadaan beberapa bit bisa diekspresikan secara sederhana sebagai string 0 dan 1, keadaan beberapa qubit menjadi sedikit lebih rumit karena prinsip superposisi dan entanglement.

Ingat bahwa $N$ bit bisa berada di salah satu dari $2^N$ keadaan yang mungkin mulai dari bilangan biner 000...000 hingga 111...111. Tapi sekarang, karena prinsip superposisi, $N$ qubit bisa berada dalam superposisi dari semua keadaan tersebut sekaligus!

Ini bisa diekspresikan sebagai

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

di mana, seperti dalam kasus klasik, keadaan $\vert i\rangle$ bersesuaian dengan keadaan di mana setiap qubit berada dalam kombinasi 0 dan 1 yang tepat untuk menghasilkan bilangan biner $i$. Ini dikenal sebagai "keadaan basis komputasi" dari sistem kuantum. Misalnya, keadaan tiga qubit bisa ditulis sebagai superposisi dari delapan keadaan basis komputasinya:

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

Setiap qubit dalam sistem ditandai dengan indeks $0$ hingga $N-1$. Konvensinya adalah membaca keadaan qubit dari kanan ke kiri, sehingga keadaan qubit $0$ adalah yang paling kanan dan keadaan qubit $N-1$ adalah yang paling kiri. Ini dikenal sebagai notasi "little-endian," dan mungkin terasa tidak intuitif pada awalnya karena kita terbiasa membaca dari kiri ke kanan.

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Pada pandangan pertama, mungkin terasa tidak intuitif untuk mengurutkan qubit dari kanan ke kiri seperti dalam notasi little-endian, tapi sebenarnya ini sangat logis! Jelaskan mengapa. (Ingat diskusi kita di atas tentang konversi bilangan biner ke basis-10.)

Jawaban:

Jika kita mengurutkan qubit dari kanan ke kiri, sehingga qubit 0 paling jauh ke kanan dan qubit N-1 paling jauh ke kiri, maka logis untuk mengasosiasikan qubit $0$ dengan bit paling tidak signifikan, yang dikalikan dengan $2^0$ dan qubit $N-1$ dengan bit paling signifikan, yang dikalikan dengan $2^{N-1}$.

Entanglement

Seperti yang kita sebutkan sebelumnya, fitur kunci lain dari qubit adalah bahwa mereka bisa terjerat satu sama lain. Mari kita ambil contoh keadaan dua qubit, di mana $c_0 = c_3 = \frac{1}{\sqrt{2}}$ dan $c_1 = c_2 = 0$:

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

Jadi, keadaan qubit 0 bisa berupa $\vert 0\rangle$ atau $\vert 1\rangle$ dengan probabilitas yang sama, begitu pula dengan keadaan qubit 1. Tapi probabilitas-probabilitas ini tidak lagi saling independen. Jika kita menemukan keadaan qubit 0 adalah $\vert 0\rangle$, maka kita tahu bahwa qubit 1 juga akan berada dalam $\vert 0\rangle$. Ini berlaku tidak peduli seberapa jauh satu sama lain, itulah mengapa tindakan mengukur keadaan yang terjerat terkadang disebut sebagai "aksi seram dari jarak jauh."

Entanglement juga bisa mengambil bentuk lain. Misalnya, keadaan

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

menghasilkan hasil yang berlawanan setiap saat: jika satu qubit diukur $\vert 0\rangle$, yang lain dijamin ditemukan dalam keadaan $\vert 1\rangle$.

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Apakah keadaan $\vert \psi\rangle = \vert 11\rangle$ terjerat? Mengapa atau mengapa tidak?

Jawaban:

Ini tidak terjerat. Meskipun hasilnya selalu sama saat kamu mengukur kedua qubit, ini hanya karena setiap qubit selalu berada dalam keadaan $\vert 1\rangle$. Hasil pengukuran satu qubit sebenarnya tidak bergantung pada yang lain — keduanya hanya selalu $\vert 1\rangle$.

Secara umum, jika kamu bisa mendeskripsikan keadaan setiap qubit secara terpisah lalu mengalikannya seperti ini:

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

Maka ini dikenal sebagai "keadaan produk" dan tidak terjerat.

Notasi vektor

Seringkali berguna untuk menggunakan vektor dan matriks untuk melihat bagaimana keadaan kuantum berubah di bawah operasi yang berbeda. Dalam representasi ini, keadaan kuantum kita akan berupa vektor, dan gate kuantum kita (dibahas di bagian berikutnya) akan berupa matriks yang mentransformasi vektor.

Untuk satu qubit, bentuk vektor dari keadaan dipilih sebagai: $\vert 0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$ $\vert 1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$ Dengan cara ini, keadaan sembarang $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ bisa ditulis sebagai $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

Untuk keadaan $n$-qubit umum, kita akan membutuhkan vektor berdimensi $2^n$, dengan keadaan basis yang diurutkan seperti yang mungkin kamu harapkan, dalam nilai biner yang meningkat:

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

Dengan pilihan notasi vektor ini, kita bisa memperkenalkan gate kuantum yang dibutuhkan, efeknya pada keadaan kuantum, dan bentuk matriksnya.

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Ada empat keadaan basis komputasi untuk sistem dua qubit. Tuliskan masing-masing dalam notasi ket dan vektor.

Jawaban:

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

Gate $\rightarrow$ gate kuantum

Sama seperti gate klasik seperti NOT, AND, OR, dan XOR bisa digabungkan untuk membangun sirkuit klasik sembarang, gate kuantum memainkan peran yang sama dalam komputasi kuantum. Karena qubit memiliki fitur mekanika kuantum tambahan, gate kuantum pun menjadi lebih kaya. Meskipun kita masih bisa mendeskripsikan aksinya pada keadaan basis $|0\rangle$ dan $|1\rangle$ dengan tabel kebenaran, ini tidak menangkap gambaran keseluruhan. Untuk gate kuantum, seringkali lebih alami menggunakan representasi matriks, karena gate juga bekerja pada superposisi keadaan basis.

Di bawah ini kita akan memperkenalkan gate kuantum yang paling umum dan bagaimana mereka mentransformasi qubit yang berinteraksi dengannya. Jika berlaku, kita akan menghubungkannya kembali ke gate klasik yang sudah familiar.

Gate satu qubit

Gate $X$: Ini adalah padanan kuantum dari operasi NOT. Tabel kebenarannya terlihat persis seperti Gate NOT klasik:

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

Dan representasi matriksnya:

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

Di Qiskit, membuat Circuit dengan Gate $X$ terlihat seperti ini:

from qiskit import QuantumCircuit

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

Dalam diagram Circuit yang sangat sederhana ini, qubit direpresentasikan oleh sebuah kabel, garis horizontal hitam, dan gate muncul sebagai kotak pada kabel tersebut.

Gate Hadamard: Membuat keadaan superposisi. Tabel kebenaran:

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

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

Circuit dengan Gate Hadamard dibuat sebagai berikut:

from qiskit import QuantumCircuit

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

Gate $Z$: Menambahkan pergeseran fase $\Delta \phi = \pi$ ke keadaan $|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}$

Di Qiskit, membuat Circuit dengan Gate $Z$ terlihat seperti ini:

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

Gate $T$: Menambahkan pergeseran fase $\Delta \phi = \pi/4$ ke keadaan $|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}$

Di Qiskit, membuat Circuit dengan Gate $T$ terlihat seperti ini:

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

Gate multi-qubit

Gate dua qubit bisa menyerupai gate dua bit klasik, tapi dengan satu catatan penting: semua gate kuantum harus reversibel. Dalam istilah aljabar linear, artinya mereka direpresentasikan oleh matriks uniter. Dengan demikian, dua qubit input selalu dipetakan ke dua qubit output, dan operasi tersebut, pada prinsipnya, bisa dibalik. Ini bertentangan dengan gate klasik yang kita lihat di atas seperti AND atau OR, yang kehilangan informasi dan tidak dapat dibalik — diberikan output, kamu tidak dapat menentukan input secara unik.

Gate CNOT (Controlled-NOT): Dua qubit input disebut qubit "kontrol" dan "target". Qubit kontrol tetap tidak berubah, tapi keadaannya menentukan apa yang terjadi pada qubit target. Jika qubit kontrol berada dalam keadaan $\vert 1\rangle$, maka Gate $X$ diterapkan pada target; jika keadaan qubit kontrol adalah $\vert 0\rangle$, maka tidak ada perubahan yang dibuat. Dalam notasi di bawah, asumsikan qubit $A$ (qubit paling kanan) adalah kontrol, dan qubit $B$ (qubit paling kiri) adalah target. Di bawah, notasi yang digunakan adalah $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$

Jadi, matriks yang merepresentasikan aksi ini adalah:

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

Ini adalah diagram Circuit pertama yang kita lihat dengan dua qubit, yang direpresentasikan oleh dua kabel. Gate CNOT diimplementasikan di antara dua qubit, dengan $q_0$ sebagai kontrol dan $q_1$ sebagai target.

Cek pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Sebagian besar Gate memiliki bentuk matriks yang sama di Qiskit seperti di tempat lain. Tapi Gate CNOT bekerja pada dua Qubit, sehingga tiba-tiba konvensi pengurutan Qubit menjadi masalah. Teks yang mengurutkan Qubit $\vert q_0,q_1,...\rangle$ akan menunjukkan bentuk matriks yang berbeda untuk Gate CNOT mereka. Verifikasi dengan perkalian matriks eksplisit bahwa matriks CNOT di atas memiliki aksi yang benar pada keadaan $\vert 01\rangle.$

Jawaban:

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

Gate SWAP: Gate ini menukar keadaan dua Qubit. Tabel kebenaran:

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$

Jadi, matriks yang merepresentasikan aksi ini adalah:

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

Gate SWAP sebenarnya bisa dibangun dari tiga CNOT. Untuk melihat caranya, kita bisa decompose() Gate tersebut dengan Qiskit:

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

Di sini kita melihat untuk pertama kalinya bagaimana beberapa Gate ditampilkan dalam diagram Circuit. Kita membacanya dari kiri ke kanan, jadi Gate paling kiri diterapkan pertama.

Cek pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Verifikasi bahwa kombinasi CNOT di atas menghasilkan Gate SWAP. Kamu bisa melakukannya dengan perkalian matriks atau metode lain apa pun.

Jawaban:

Dengan perkalian matriks:

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

Menggunakan tabel kebenaran untuk melihat bagaimana keadaan berubah dengan setiap CNOT. Pada kolom terakhir, keadaan harus setara dengan kolom "output" dari tabel kebenaran SWAP:

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$

Gate Toffoli (atau "controlled-controlled-NOT" (CCNOT)): Ini adalah Gate tiga Qubit. Nama "controlled-controlled-NOT" mungkin sudah memberi tahu kamu cara kerjanya: ada dua Qubit kontrol dan satu Qubit target, dan keadaan Qubit target dibalik hanya jika kedua Qubit kontrol berada dalam keadaan $\vert 1\rangle$. Kita menggunakan konvensi pengurutan yang sama seperti yang kita gunakan dengan CNOT:

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

Jadi tabel kebenarannya adalah:

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$

Dan matriks yang merepresentasikan aksi ini adalah:

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

Gate Toffoli juga bisa didekomposisi menjadi CNOT, bersama dengan beberapa Gate lainnya. Namun, ini jauh lebih rumit daripada dekomposisi Gate SWAP, sehingga akan dibiarkan sebagai latihan opsional di akhir modul untuk mengeksplorasi dan memverifikasi dekomposisi ini.

Pengukuran

Pengukuran memainkan peran khusus dalam komputasi kuantum — peran yang tidak memiliki analog dalam komputasi klasik. Sementara dalam komputasi klasik, kamu bisa memeriksa bit-bit kamu di titik mana pun yang kamu pilih selama suatu algoritma, dalam komputasi kuantum, kamu harus sangat selektif tentang kapan harus melihat Qubit-mu karena pengukuran meruntuhkan keadaannya dan menghancurkan superposisi yang memberi Qubit kompleksitas komputasinya.

Secara khusus, diberikan keadaan kuantum $N$-bit $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$, sebuah pengukuran akan meruntuhkan keadaan ke salah satu fungsi basis $\vert i\rangle$ dengan probabilitas sama dengan $\vert c_i\vert ^2$.

Tapi efek destruktif dari pengukuran ini tidak selalu menjadi hambatan. Ini sebenarnya adalah sumber daya kunci dalam algoritma dan protokol tertentu, seperti teleportasi kuantum dan distribusi kunci kuantum.

Di Qiskit, ketika pengukuran dilakukan, pengukuran tersebut dikirim ke register klasik di mana disimpan sebagai bit klasik. Membuat Circuit dengan pengukuran terlihat seperti ini:

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

Circuit

Sekarang kita tahu cara kerja Qubit, Gate, dan pengukuran, mari kita buat dan jalankan Circuit kuantum kita sendiri! Untuk ini, kita perlu mengenalkan kamu pada alur kerja yang berguna yang disebut Qiskit patterns.

Kerangka Qiskit patterns

Kerangka Qiskit patterns adalah prosedur umum untuk mendekati dan memecahkan masalah dengan komputer kuantum. Ini terdiri dari empat langkah:

1. Pemetaan masalah kita ke Circuit kuantum dan operator
2. Optimasi Circuit untuk hardware target
3. Eksekusi pada hardware target
4. Pasca-pemrosesan hasil kita

Untuk mengilustrasikan langkah-langkah ini, kita akan mengimplementasikan versi kuantum dari Circuit half-adder yang dibahas di atas.

1. Pemetaan

Circuit adder klasik menggunakan Gate XOR dan AND untuk menghitung bit sum dan carry, masing-masing. Kita bisa mengadaptasi Gate-Gate ini ke konteks kuantum untuk membuat quantum half adder. Pertama, ingat bahwa Gate kuantum bersifat reversibel, kita tidak bisa begitu saja menimpa input-nya. Sebaliknya, kita memperkenalkan dua Qubit helper yang diinisialisasi ke $\vert 0\rangle$ untuk menyimpan output sum dan carry. Jadi, keadaan kuantum penuh kita akan terdiri dari Qubit $A$ dan $B$, serta Qubit sum dan carry, yang akan kita beri label $S$ dan $C$:

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

Sekarang, kita perlu Gate kuantum yang menyelesaikan apa yang Gate XOR dan AND lakukan dalam Circuit klasik.

Sum:

Untuk XOR, kita menerapkan dua CNOT, masing-masing dengan Qubit kontrol $A$ dan $B$ serta Qubit target $S$ untuk keduanya. Jika $A$ dan $B$ berbeda, maka salah satu Gate CNOT akan membalik $S$ ke keadaan $\vert 1\rangle$. Jika $A$ dan $B$ keduanya $\vert 0\rangle$, maka tidak ada yang terjadi pada $S$ dan tetap dalam keadaan $\vert 0\rangle$. Jika $A$ dan $B$ keduanya $\vert 1\rangle$, maka keadaan $S$ akan dibalik dua kali, membawanya kembali ke keadaan $\vert 0\rangle$.

Carry:

Untuk bit carry, kita perlu sesuatu yang bekerja seperti Gate AND klasik.

Cek pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Lihat kembali Gate-Gate yang telah kita diskusikan untuk melihat apakah kamu bisa menebak Gate kuantum mana yang akan kita gunakan sebagai pengganti Gate AND klasik:

Jawaban:

Itu adalah Gate Toffoli! Ingat, Gate Toffoli, atau controlled-controlled-NOT, membalik keadaan target jika dan hanya jika Qubit kontrol 0 DAN Qubit kontrol 1 keduanya $\vert 1\rangle$. Jadi, jika Qubit target dimulai dalam keadaan $\vert 0\rangle$, maka aksinya sama dengan Gate AND.

Jadi, sekarang kita memiliki semua bahan yang kita butuhkan untuk membuat Circuit kuantum:

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

Di atas adalah diagram Circuit untuk Circuit quantum half-adder. Seperti yang disebutkan sebelumnya, kabel mewakili Qubit $0$ hingga $3$ yang diurutkan dari atas ke bawah, dan register bit klasik adalah kabel berlapis ganda di bagian bawah. Kemudian, membaca dari kiri ke kanan, kita melihat bagaimana Gate diterapkan pada setiap Qubit dengan melihat di mana kotak-kotak muncul pada kabel yang sesuai. Terakhir, pengukuran ditampilkan di bagian akhir. Pengukuran meruntuhkan keadaan Qubit menjadi nilai $0$ atau $1$ yang pasti, dan hasilnya dikirim ke register klasik.

Satu hal yang perlu diperhatikan: meskipun diagram Circuit digambar dari kiri ke kanan, ketika menulis ekspresi matriks yang sesuai kita harus membacanya dari kanan ke kiri. Ini karena dalam perkalian matriks, operator yang paling dekat dengan vektor keadaan (yang paling kanan) bertindak pertama. Jadi, misalnya, Circuit di atas (mengabaikan pengukuran) akan ditulis sebagai:

$$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. Optimasi:

Selanjutnya, kita perlu mengoptimalkan Circuit untuk dijalankan pada hardware kuantum. Optimasi ini dilakukan melalui Transpiler, yang menerjemahkan Circuit abstrak yang ditunjukkan di atas menjadi instruksi yang akan dipahami oleh komputer kuantum. Ini menetapkan Qubit logis di atas ke Qubit fisik nyata pada prosesor dan menulis ulang Gate dalam hal set Gate native-nya sendiri yang telah dioptimalkan untuk dijalankan pada komputer kuantum. Akhirnya, Transpiler juga mengimplementasikan sesuatu yang disebut "penekanan dan mitigasi kesalahan" untuk mencoba meminimalkan efek kesalahan pada hasil. Ini tidak terlalu penting untuk Circuit kita yang sangat sederhana, tapi jika kamu melanjutkan perjalanan komputasi kuantum untuk menjalankan Circuit yang lebih rumit, kamu akan segera melihat nilai penekanan dan mitigasi kesalahan. Jika kamu ingin mempelajari lebih lanjut tentang ini, lihat kursus Olivia Lane, Quantum Computing in Practice.

Pertama, kita memuat paket yang diperlukan untuk berkomunikasi dengan komputer kuantum IBM® dan memilih Backend untuk dijalankan. Kita bisa memilih Backend yang paling tidak sibuk, atau memilih Backend tertentu yang propertinya sudah kita ketahui.

Ada kode di bawah ini untuk menyimpan kredensial kamu saat pertama kali digunakan. Pastikan untuk menghapus informasi ini dari notebook setelah menyimpannya ke lingkunganmu, agar kredensialmu tidak secara tidak sengaja dibagikan saat kamu berbagi notebook. Lihat Siapkan akun IBM Cloud kamu dan Inisialisasi layanan di lingkungan yang tidak tepercaya untuk panduan lebih lanjut.

# 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

Sekarang, kita menggunakan Transpiler untuk mengoptimalkan Circuit. Kita bisa memilih tingkat optimasi dari 0 (tanpa optimasi) hingga 3 (optimasi tertinggi). Untuk melihat apa yang dihasilkan setiap tingkat, kunjungi panduan Atur tingkat optimasi Transpiler. Circuit yang dihasilkan akan terlihat sangat berbeda dari Circuit logis yang kita buat pada langkah pemetaan.

# 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" adalah primitif yang dirancang untuk mengambil sampel kemungkinan keadaan yang dihasilkan dari Circuit kuantum, dan mengumpulkan statistik tentang keadaan apa yang mungkin diukur dan dengan probabilitas berapa. Kita mengimpor Qiskit Runtime Sampler di sini:

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

sampler = Sampler(mode=backend)

Jika kamu telah menghabiskan waktu yang dialokasikan pada komputer kuantum nyata atau jika kamu tidak memiliki koneksi internet, kamu mungkin lebih memilih menggunakan simulator. Untuk melakukan ini, jalankan sel di bawah ini dan batalkan komentar pada baris terkait di langkah "Eksekusi".

# 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. Eksekusi

Setelah mempersiapkan Circuit, kita sekarang bisa menjalankannya di komputer kuantum!

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. Pasca-pemrosesan

Sekarang kita siap melihat hasil kita! Kita akan menampilkan histogram dari 100 sampel Circuit.

from qiskit.visualization import plot_histogram

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

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

Histogram di atas menunjukkan hasil pengukuran dari keempat Qubit di akhir Circuit. Komputer kuantum ideal dengan nol noise akan selalu mengukur Qubit memiliki nilai yang sama setiap kali, tapi pada kenyataannya, noise akan menyebabkan beberapa run menghasilkan kesalahan.

Cek pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Menggunakan bitstring dengan jumlah terbanyak sebagai nilai kamu untuk $A$, $B$, $S$, dan $C$, verifikasi bahwa Circuit quantum adder bekerja.

Jawaban:

Kita perlu memverifikasi bahwa $A+B = S+2 \times C$. Ingat bahwa urutan bitstring mengikuti notasi little-endian, jadi dibaca CSBA.

Dari histogram di atas, kita melihat bahwa bitstring 0000 adalah yang dominan.

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

Kembali dan ubah nilai $A$ dan $B$ menjadi $A=1$ dan $B=1$ lalu jalani kembali langkah-langkah Qiskit patterns untuk menjalankan ulang Circuit. Verifikasi bahwa Circuit adder bekerja lagi.

Jawaban:

Kamu seharusnya mendapatkan histogram dengan bitstring dominan 1011:

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

Salah satu fitur tambahan dari quantum half-adder dibanding classical half-adder adalah bahwa ia bisa berjalan dengan input kuantum. Artinya, ia bisa "menjumlahkan" Qubit $A$ dan $B$ meskipun keduanya berada dalam keadaan superposisi. Di bagian Pertanyaan Tantangan di bawah, kamu akan diminta untuk mempersiapkan Qubit dalam superposisi dan melihat apa yang terjadi!

Kesimpulan

Modul ini dirancang untuk memberimu pemahaman dasar yang kuat tentang prinsip-prinsip dasar di balik komputasi kuantum dengan membandingkannya dengan komputasi klasik. Kita melihat Circuit classical half-adder lalu menunjukkan cara mengadaptasi Circuit tersebut untuk dijalankan dengan Qubit di komputer kuantum. Sekarang kamu siap untuk menjelajahi modul-modul Qiskit in the Classroom lainnya!

Konsep penting:

• Berbeda dengan bit klasik yang hanya bisa mengambil nilai 0 dan 1, Qubit juga bisa berada dalam keadaan superposisi dari keduanya.
• Beberapa Qubit bisa berada dalam superposisi atas bitstring yang diizinkan secara klasik yang disebut keadaan basis komputasi.
• Beberapa Qubit bisa terjerat sehingga keadaan satu bergantung pada keadaan yang lain.
• Konvensi Qiskit adalah menggunakan notasi little-endian, yang menempatkan Qubit paling tidak signifikan, $q_0$, di posisi paling kanan dan Qubit paling signifikan, $q_N$, paling kiri.
• Gate kuantum adalah operasi reversibel yang direpresentasikan oleh matriks uniter yang bekerja pada vektor keadaan kuantum. Dalam notasi ini, matriks yang paling dekat dengan vektor (yang paling kanan) bertindak pertama.
• Pengukuran meruntuhkan keadaan superposisi kuantum menjadi salah satu keadaan yang diizinkan secara klasik, dengan probabilitas sama dengan kuadrat amplitudo keadaan basis komputasi yang sesuai dalam superposisi.
• Circuit kuantum sering direpresentasikan menggunakan diagram Circuit kuantum, di mana Qubit digambarkan sebagai kabel horizontal, dan Gate kuantum muncul di sepanjang kabel ini dari kiri ke kanan.
• Untuk menjalankan Circuit kuantum, kita menggunakan empat langkah dalam alur kerja Qiskit patterns: Peta, Optimasi, Eksekusi, Pasca-proses.

Pertanyaan

Pertanyaan Benar/Salah

1. Satu bit dalam komputer klasik hanya bisa menyimpan nilai 0 atau 1.

2. Keterikatan berarti keadaan satu Qubit tidak bergantung pada keadaan Qubit lain.

3. Gate kuantum umumnya adalah operasi yang tidak reversibel.

4. Konvensi Qiskit menempatkan Qubit paling tidak signifikan, $q_0$, di posisi paling kiri.

5. Mengukur keadaan kuantum selalu memberikan hasil yang sama persis jika diulang berkali-kali.

6. Gate Hadamard menciptakan superposisi dalam satu Qubit.

7. Circuit kuantum mungkin menyertakan operasi pengukuran yang meruntuhkan keadaan superposisi menjadi salah satu keadaan yang diizinkan secara klasik.

8. Jumlah kemungkinan keadaan klasik untuk $N$ bit adalah $2N$.

9. Probabilitas hasil untuk pengukuran kuantum diberikan oleh kuadrat amplitudo keadaan basis yang dapat diukur secara klasik.

Pertanyaan Jawaban Singkat

1. Apa saja perbedaan utama antara bit dan Qubit?

2. Apa yang terjadi pada keadaan kuantum ketika diukur?

3. Mengapa kita menggunakan notasi little-endian di Qiskit?

4. Apa saja empat langkah dalam alur kerja Qiskit patterns?

Pertanyaan Tantangan:

1. Dalam modul ini, kita hanya menggunakan adder untuk menjumlahkan keadaan yang diizinkan secara klasik untuk $A$ dan $B$. Tapi kita juga bisa mempersiapkan $A$ dan $B$ dalam superposisi! Ubah kode untuk mempersiapkan setiap Qubit dalam superposisi yang sama dari 0 dan 1, lalu jalankan Circuit baru dan dapatkan histogram baru. Apa yang kamu lihat? Jelaskan apa yang terjadi.

2. Dekomposisi Gate Toffoli. Gunakan decompose() untuk menunjukkan bagaimana Gate Toffoli didekomposisi menjadi Gate satu dan dua Qubit, lalu verifikasi konstruksi ini dengan perkalian matriks. Ingat bahwa meskipun diagram Circuit dibaca dari kiri ke kanan, matriks diterapkan ke keadaan kuantum dari kanan ke kiri!