Mulakan dengan Qiskit di dalam kelas

Untuk modul Qiskit dalam Bilik Darjah ini, pelajar perlu mempunyai persekitaran Python yang berfungsi dengan pakej berikut dipasang:

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

Untuk menyediakan dan memasang pakej di atas, lihat panduan Pasang Qiskit. Untuk menjalankan kerja pada komputer kuantum sebenar, pelajar perlu membuat akaun dengan IBM Quantum® dengan mengikuti langkah-langkah dalam panduan Sediakan akaun IBM Cloud® anda.

Modul ini telah diuji dan menggunakan 2 saat masa QPU pada pemproses Heron v2. Ini hanya anggaran sahaja. Penggunaan sebenar anda mungkin berbeza.

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

Pengenalan

Dalam modul Qiskit dalam Bilik Darjah, kamu akan berpeluang menggunakan komputer kuantum untuk meneroka pelbagai konsep dalam bidang berkaitan pengkomputeran kuantum seperti mekanik kuantum, sains komputer, kimia, dan lain-lain. Modul ini berfungsi sebagai prasyarat kepada modul-modul yang lain — ia memperkenalkan asas pengkomputeran kuantum dan cara menggunakan Qiskit untuk menjalankan litar kuantum.

Pertama kita akan memberi gambaran ringkas tentang cara komputer klasik berfungsi, kemudian kita akan tunjukkan bagaimana konsep-konsep ini disesuaikan untuk memenuhi paradigma pengkomputeran kuantum. Akhirnya, kita akan tunjukkan cara menggabungkan konsep-konsep ini untuk membina dan melaksanakan litar kuantum pertama kamu.

Komputer klasik

Kamu mungkin sudah biasa dengan asas cara komputer klasik berfungsi, tetapi di sini kita akan menyerlahkan beberapa ciri utama supaya kita boleh membuat perbandingan dengan komputer kuantum.

Unit maklumat asas: bit

Komputer klasik memproses maklumat klasik, dan unit asas maklumat klasik ialah bit. Satu bit boleh menyimpan jawapan kepada satu soalan "ya/tidak". Kita biasanya mewakili dua keadaan binari sebuah bit sebagai "0" dan "1".

Ulasan nombor binari

Menggabungkan bit membolehkan kamu menyimpan lebih banyak maklumat. Contohnya, jika kamu ingin menyimpan nombor dari 0 hingga 15, kamu boleh 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 menukar nombor binari $N$ bit kepada nombor asas-10 yang biasa, kamu darabkan bit paling kurang bererti (paling kanan) dengan $2^0 = 1$, bit seterusnya ke kiri dengan $2^1 = 2$, kemudian seterusnya dengan $2^2 = 4$, dan seterusnya, sehingga kamu mencapai bit paling bererti (bit paling kiri), yang kamu darabkan dengan $2^{N-1}$.

Jadi, itu bermakna $N$ bit boleh berada dalam salah satu daripada $2^N$ keadaan yang berbeza.

Semak kefahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaian.

Berapa banyak bit yang kamu perlukan untuk mewakili nombor 86? Tuliskan rentetan bit yang mengekod nombor ini dalam binari.

Jawapan:

Ingat, $N$ bit membolehkan kamu mewakili nombor $0$ hingga $2^N - 1$, jadi menggunakan enam bit akan membawa kita hingga $2^6 - 1 = 63$. Itu tidak cukup. Kita tambah satu lagi bit untuk mencapai $2^7 - 1 = 127$. Sekarang mari kita pecahkan 86 kepada kuasa-kuasa 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 asas: gate

Sekarang, komputer perlu dapat melakukan sesuatu dengan bit untuk, ya, mengira. Gate binari adalah operasi yang membentuk blok binaan asas bagi semua algoritma dan kod yang lebih rumit.

Gate satu-bit:

NOT

Apabila kamu hanya mempunyai satu bit, hanya ada satu cara kamu boleh mengubah keadaannya: balikkan keadaan dari 0 ke 1 atau dari 1 ke 0. Kita panggil ini gate "NOT". Kesan gate ini — dan gate-gate lain yang akan kita bincangkan di bawah — boleh diwakili dalam apa yang dipanggil "jadual kebenaran," dengan lajur untuk keadaan input dan output qubit. Jadual kebenaran untuk gate NOT ialah:

Input	Output
0	1
1	0

Gate berbilang-bit:

AND

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

Input	Output
00	0
01	0
10	0
11	1

OR

OR adalah gate dua-bit lain dengan satu bit output. Ia menghasilkan 1 jika salah satu bit adalah 1:

Input	Output
00	0
01	1
10	1
11	1

XOR

XOR bermaksud "exclusive OR" dan ia seperti gate OR, tetapi menghasilkan 1 jika hanya satu daripada bit input adalah 1. Ia menghasilkan 0 jika kedua-duanya 1 atau kedua-duanya 0:

Input	Output
00	0
01	1
10	1
11	0

Pengukuran:

Biasanya, apabila belajar tentang pengkomputeran klasik, tidak banyak perhatian diberikan kepada proses membaca keadaan bit. Ini kerana ia tidak terlalu rumit dari perspektif konseptual. Kamu boleh mengukur bit pada bila-bila masa sebelum, semasa, atau selepas pengiraan, dan ia tidak menjejaskan hasilnya. Ini tidak berlaku dalam pengkomputeran kuantum, seperti yang akan kita bincangkan di bawah.

Circuit:

Dengan menggabungkan gate-gate di atas, kamu boleh melakukan apa sahaja operasi yang kamu mahu pada komputer. Mari ambil contoh mudah: Menggunakan gate AND dan XOR, kamu boleh membina Circuit half-adder, yang mengira jumlah dua bit. Ini diwakili dalam gambar rajah Circuit logik, di mana wayar mewakili bit dan gate yang beroperasi pada bit ditunjukkan sebagai simbol pada wayar yang sepadan:

Jadi, dua bit disalin dan dimasukkan melalui gate AND dan gate XOR. Hasil gate XOR ialah "bit jumlah" (S), yang kekal di tempat satu nombor binari, dan hasil gate AND ialah "bit pembawa" (C), iaitu nilai digit paling bererti seterusnya dalam nombor binari. Berikut ialah jadual kebenarannya:

$A$	$B$	Jumlah ($A \oplus B$)	Pembawa ($A \wedge B$)
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

Semak kefahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaian.

Sahkan bahawa jadual kebenaran di atas menghasilkan penyelesaian yang betul untuk Circuit penambah. Iaitu, untuk setiap empat pilihan A dan B, sahkan bahawa $A+B=S+2 \times C$.

Jawapan:

$$\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 asas maklumat klasik, bit kuantum, atau "Qubit," adalah unit asas maklumat kuantum. Seperti bit klasik, keadaan sebuah Qubit boleh sama ada 0 atau 1, yang biasanya kita nyatakan sebagai $\vert 0\rangle$ dan $\vert 1\rangle$. Tetapi tidak seperti bit klasik, bit kuantum juga boleh berada dalam superposisi kedua-dua keadaan $\vert 0\rangle$ dan $\vert 1\rangle$ pada masa yang sama. Secara umum, sebuah Qubit boleh berada dalam mana-mana keadaan $\vert \psi\rangle$ dalam bentuk:

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

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

Fasa kuantum

Kerana $c_0$ dan $c_1$ adalah kompleks, masing-masing boleh ditulis sebagai $c_i = \vert c_i\vert e^{i\phi_i}$ di mana $\phi_i$ dipanggil fasa. Jika kita darabkan keseluruhan keadaan dengan faktor fasa keseluruhan yang sama, tiada apa yang berubah secara fizikal — ini dipanggil fasa global, dan ia tidak mempunyai kesan yang boleh diperhatikan.

Atas sebab itu, adalah lazim untuk "memfaktorkan" $e^{i\phi_0}$, memberikan:

$\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 fasa relatif keadaan kuantum, yang memang mempunyai kesan yang boleh diperhatikan.

Fasa ini memainkan peranan yang sangat penting dalam pengkomputeran kuantum, dan kamu akan meneroka pelbagai kesannya dalam modul Qiskit dalam Bilik Darjah yang seterusnya.

Berbilang Qubit

Walaupun keadaan berbilang bit boleh dinyatakan dengan mudah sebagai rentetan 0 dan 1, keadaan berbilang Qubit menjadi sedikit lebih rumit kerana prinsip superposisi dan kekusutan.

Ingat bahawa $N$ bit boleh berada dalam salah satu daripada $2^N$ keadaan yang mungkin dari nombor binari 000...000 hingga 111...111. Tetapi kini, kerana prinsip superposisi, $N$ Qubit boleh berada dalam superposisi semua keadaan ini serentak!

Ini boleh dinyatakan sebagai

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

di mana, seperti dalam kes klasik, keadaan $\vert i\rangle$ sepadan dengan keadaan di mana setiap Qubit berada dalam gabungan 0 dan 1 yang betul untuk menghasilkan nombor binari $i$. Ini dikenali sebagai "keadaan asas pengiraan" sistem kuantum. Contohnya, keadaan tiga-Qubit boleh ditulis sebagai superposisi lapan keadaan asas pengiraannya:

$$\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$. Konvensyennya adalah membaca keadaan Qubit dari kanan ke kiri, supaya keadaan Qubit $0$ adalah keadaan paling kanan dan keadaan Qubit $N-1$ adalah yang paling kiri. Ini dikenali sebagai notasi "little-endian", dan mungkin kelihatan tidak intuitif pada mulanya, kerana kita terbiasa membaca dari kiri ke kanan.

Semak kefahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaian.

Pada pandangan pertama, mungkin kelihatan tidak intuitif untuk memesan Qubit dari kanan ke kiri seperti dalam notasi little-endian, tetapi sebenarnya ia adalah perkara yang sangat logik untuk dilakukan! Jelaskan mengapa. (Ingat perbincangan kita di atas tentang penukaran binari ke nombor asas-10.)

Jawapan:

Jika kita memesan Qubit dari kanan ke kiri, supaya Qubit 0 adalah yang paling kanan dan Qubit N-1 adalah yang paling kiri, adalah logik untuk mengaitkan Qubit $0$ dengan bit paling kurang bererti, yang didarab dengan $2^0$ dan Qubit $N-1$ dengan bit paling bererti, yang didarab dengan $2^{N-1}$.

Kekusutan

Seperti yang kita sebutkan sebelumnya, ciri utama lain Qubit adalah bahawa ia boleh berkusut antara satu sama lain. Mari 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 boleh sama ada $\vert 0\rangle$ atau $\vert 1\rangle$ dengan kebarangkalian yang sama, begitu juga dengan keadaan Qubit 1. Tetapi kebarangkalian ini tidak lagi bebas antara satu sama lain. Jika kita mendapati keadaan Qubit 0 adalah $\vert 0\rangle$, maka kita tahu bahawa Qubit 1 juga akan berada dalam $\vert 0\rangle$. Ini benar tidak kira seberapa jauh jarak antara satu sama lain, itulah sebabnya tindakan mengukur keadaan yang berkusut kadangkala dirujuk sebagai "tindakan seram dari jauh."

Kekusutan juga boleh mengambil bentuk lain. Contohnya, keadaan

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

menghasilkan hasil yang bertentangan setiap kali: jika satu Qubit diukur $\vert 0\rangle$, yang satu lagi dijamin berada dalam keadaan $\vert 1\rangle$.

Semak kefahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaian.

Adakah keadaan $\vert \psi\rangle = \vert 11\rangle$ berkusut? Mengapa atau mengapa tidak?

Jawapan:

Ia tidak berkusut. Walaupun hasilnya sentiasa sama apabila kamu mengukur kedua-dua Qubit, ini hanya kerana setiap Qubit sentiasa ditetapkan dalam keadaan $\vert 1\rangle$. Hasil pengukuran satu Qubit sebenarnya tidak bergantung pada yang lain — kedua-duanya hanyalah sentiasa $\vert 1\rangle$.

Secara umum, jika kamu boleh menerangkan keadaan setiap Qubit secara berasingan dan kemudian mendarabkannya seperti ini:

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

Maka ia dikenali sebagai "keadaan produk" dan tidak berkusut.

Notasi vektor

Selalunya berguna untuk menggunakan vektor dan matriks untuk melihat bagaimana keadaan kuantum berubah di bawah operasi yang berbeza. Dalam perwakilan ini, keadaan kuantum kita akan menjadi vektor, dan gate kuantum kita (dibincangkan dalam bahagian seterusnya) akan menjadi matriks yang mengubah vektor.

Untuk Qubit tunggal, bentuk vektor 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 arbitrari $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ boleh ditulis sebagai $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

Untuk keadaan $n$-Qubit umum, kita memerlukan vektor berdimensi $2^n$, dengan keadaan asas dipesan seperti yang dijangkakan, dalam nilai binari menaik:

$$\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 dalam fikiran, kita boleh memperkenalkan gate kuantum yang diperlukan, kesannya pada keadaan kuantum, dan bentuk matriksnya.

Semak kefahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaian.

Terdapat empat keadaan asas pengiraan untuk sistem dua-Qubit. Tuliskan setiap satu dalam notasi ket dan vektor.

Jawapan:

$$\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 boleh digabungkan untuk membina litar klasik arbitrari, Gate kuantum memainkan peranan yang sama dalam pengkomputeran kuantum. Kerana Qubit mempunyai ciri-ciri mekanik kuantum tambahan, Gate kuantum adalah lebih kaya. Walaupun kita masih boleh menerangkan tindakannya pada keadaan asas $|0\rangle$ dan $|1\rangle$ dengan jadual kebenaran, ini tidak menangkap keseluruhan gambarannya. Untuk Gate kuantum, selalunya lebih semula jadi menggunakan perwakilan matriks, kerana ia juga bertindak pada superposisi keadaan asas.

Di bawah kita akan memperkenalkan Gate kuantum yang paling umum dan cara ia mengubah Qubit yang berinteraksi dengannya. Apabila berkaitan, kita akan menghubungkannya semula dengan gate klasik yang biasa.

Gate satu-Qubit

Gate $X$: Ini adalah setara kuantum operasi NOT. Jadual kebenarannya kelihatan sama persis seperti gate NOT klasik:

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

Dan perwakilan matriks:

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

Dalam Qiskit, membuat Circuit dengan Gate $X$ kelihatan seperti ini:

from qiskit import QuantumCircuit

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

Dalam gambar rajah Circuit yang sangat mudah ini, Qubit diwakili oleh satu wayar, garis mendatar hitam, dan Gate muncul sebagai kotak pada wayar tersebut.

Gate Hadamard: Mencipta keadaan superposisi. Jadual 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)$

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

Circuit dengan Gate Hadamard dibuat seperti berikut:

from qiskit import QuantumCircuit

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

Gate $Z$: Menambah anjakan fasa $\Delta \phi = \pi$ pada 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}$

Dalam Qiskit, membuat Circuit dengan Gate $Z$ kelihatan seperti ini:

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

Gate $T$: Menambah anjakan fasa $\Delta \phi = \pi/4$ pada 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}$

Dalam Qiskit, membuat Circuit dengan Gate $T$ kelihatan seperti ini:

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

Gate berbilang-Qubit

Gate dua-Qubit boleh menyerupai gate dua-bit klasik, tetapi dengan satu syarat penting: semua gate kuantum mestilah boleh dibalikkan. Dari sudut aljabar linear, ini bermakna ia diwakili oleh matriks unitari. Oleh itu, dua Qubit input sentiasa memetakan kepada dua Qubit output, dan operasi itu boleh, secara prinsipnya, dibuat balik. Ini berbeza dengan gate klasik yang kita lihat sebelum ini seperti AND atau OR, yang kehilangan maklumat dan tidak boleh dibalikkan — diberi output, kamu tidak boleh menentukan input secara unik.

Gate CNOT (Controlled-NOT): Dua Qubit input dipanggil Qubit "kawalan" dan "sasaran". Qubit kawalan kekal tidak berubah, tetapi keadaannya menentukan apa yang berlaku kepada Qubit sasaran. Jika Qubit kawalan berada dalam keadaan $\vert 1\rangle$, maka Gate $X$ dikenakan pada sasaran itu; jika keadaan Qubit kawalan ialah $\vert 0\rangle$, maka tiada perubahan dibuat. Dalam notasi di bawah, andaikan Qubit $A$ (Qubit paling kanan) adalah kawalan, dan Qubit $B$ (Qubit paling kiri) adalah sasaran. Di bawah, notasi yang digunakan ialah $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 mewakili tindakan ini ialah:

$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 rajah Circuit pertama yang kita lihat dengan dua Qubit, yang diwakili oleh dua wayar. Gate CNOT dilaksanakan antara dua Qubit, dengan $q_0$ sebagai kawalan dan $q_1$ sebagai sasaran.

Uji pemahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Kebanyakan Gate mempunyai bentuk matriks yang sama dalam Qiskit seperti di tempat lain. Tetapi Gate CNOT bertindak ke atas dua Qubit, dan tiba-tiba konvensyen penyusunan Qubit menjadi isu. Teks yang menyusun Qubit $\vert q_0,q_1,...\rangle$ akan menunjukkan bentuk matriks yang berbeza untuk Gate CNOT mereka. Sahkan melalui pendaraban matriks eksplisit bahawa matriks CNOT di atas mempunyai tindakan yang betul ke atas keadaan $\vert 01\rangle.$

Jawapan:

$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. Jadual 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 mewakili tindakan ini ialah:

$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 boleh dibina daripada tiga CNOT. Untuk melihat caranya, kita boleh decompose() Gate tersebut dengan Qiskit:

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

Di sini kita melihat buat pertama kali bagaimana pelbagai Gate ditunjukkan dalam rajah Circuit. Kita membacanya dari kiri ke kanan, jadi Gate paling kiri digunakan dahulu.

Uji pemahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Sahkan bahawa gabungan CNOT di atas menghasilkan Gate SWAP. Kamu boleh melakukannya dengan pendaraban matriks atau mana-mana kaedah lain.

Jawapan:

Dengan pendaraban 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 jadual kebenaran untuk melihat bagaimana keadaan berubah dengan setiap CNOT. Dalam lajur terakhir, keadaan mestilah setara dengan lajur "output" jadual 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 memberitahu kamu cara ia berfungsi: terdapat dua Qubit kawalan dan satu Qubit sasaran, dan keadaan Qubit sasaran dibalikkan hanya jika kedua-dua Qubit kawalan berada dalam keadaan $\vert 1\rangle$. Kita mengekalkan konvensyen penyusunan yang digunakan dengan CNOT:

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

Jadi jadual kebenarannya ialah:

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 mewakili tindakan ini ialah:

$$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 boleh didekomposisikan kepada CNOT, bersama beberapa gate lain. Walau bagaimanapun, ia jauh lebih rumit daripada dekomposisi Gate SWAP, jadi ia akan ditinggalkan sebagai latihan pilihan di akhir modul untuk diterokai dan disahkan.

Pengukuran

Pengukuran memainkan peranan istimewa dalam pengkomputeran kuantum — peranan yang tidak ada analognya dalam pengkomputeran klasik. Walaupun dalam pengkomputeran klasik, kamu boleh memeriksa bit-bit kamu pada bila-bila masa yang dikehendaki semasa sesuatu algoritma, dalam pengkomputeran kuantum, kamu perlu sangat selektif tentang bila hendak melihat Qubit-qubit kamu kerana pengukuran meruntuhkan keadaan mereka dan memusnahkan superposisi yang memberikan Qubit kerumitan pengiraan mereka.

Khususnya, diberi keadaan kuantum $N$-bit $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$, satu pengukuran akan meruntuhkan keadaan kepada salah satu fungsi asas $\vert i\rangle$ dengan kebarangkalian sama dengan $\vert c_i\vert ^2$.

Tetapi kesan merosakkan pengukuran ini tidak sentiasa menjadi halangan. Ia sebenarnya adalah sumber utama dalam algoritma dan protokol tertentu, seperti teleportasi kuantum dan pengedaran kunci kuantum.

Dalam Qiskit, apabila pengukuran dibuat, ia dihantar ke daftar klasik di mana ia disimpan sebagai bit klasik. Membuat Circuit dengan pengukuran kelihatan 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 dah tahu bagaimana Qubit, Gate, dan pengukuran berfungsi, jom buat dan laksanakan Circuit kuantum kita sendiri! Untuk ini, kita perlu memperkenalkan kamu kepada aliran kerja yang berguna yang dipanggil corak Qiskit.

Kerangka corak Qiskit

Kerangka corak Qiskit adalah prosedur umum untuk mendekati dan menyelesaikan masalah dengan komputer kuantum. Ia terdiri daripada empat langkah:

1. Pemetaan masalah kita kepada Circuit kuantum dan operator
2. Pengoptimuman Circuit untuk perkakasan sasaran
3. Pelaksanaan pada perkakasan sasaran
4. Pasca-pemprosesan keputusan kita

Untuk menggambarkan langkah-langkah ini, kita akan melaksanakan versi kuantum Circuit penambah separuh yang dibincangkan di atas.

1. Pemetaan

Circuit penambah klasik menggunakan Gate XOR dan AND untuk mengira bit jumlah dan bawa masing-masing. Kita boleh menyesuaikan gate-gate ini kepada konteks kuantum untuk membuat penambah separuh kuantum. Pertama, mengingati bahawa gate kuantum adalah boleh dibalikkan, kita tidak boleh hanya menimpa input. Sebaliknya, kita memperkenalkan dua Qubit pembantu yang dimulakan kepada $\vert 0\rangle$ untuk menyimpan output jumlah dan bawa. Jadi, keadaan kuantum penuh kita akan terdiri daripada Qubit $A$ dan $B$, dan Qubit jumlah dan bawa, yang akan kita labelkan $S$ dan $C$:

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

Sekarang, kita perlukan gate kuantum yang mencapai apa yang gate XOR dan AND lakukan dalam Circuit klasik.

Jumlah:

Untuk XOR, kita gunakan dua CNOT, masing-masing dengan Qubit kawalan $A$ dan $B$ dan Qubit sasaran $S$ untuk kedua-duanya. Jika $A$ dan $B$ berbeza, maka salah satu gate CNOT akan membalikkan $S$ kepada keadaan $\vert 1\rangle$. Jika $A$ dan $B$ kedua-duanya $\vert 0\rangle$, maka tiada apa yang berlaku kepada $S$ dan ia kekal dalam keadaan $\vert 0\rangle$. Jika $A$ dan $B$ kedua-duanya $\vert 1\rangle$, maka keadaan $S$ akan dibalikkan dua kali, membawanya kembali kepada keadaan $\vert 0\rangle$.

Bawa:

Untuk bit bawa, kita perlukan sesuatu yang berfungsi seperti Gate AND klasik.

Uji pemahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Lihat kembali gate-gate yang telah kita bincangkan untuk melihat sama ada kamu boleh meneka gate kuantum mana yang akan kita gunakan sebagai ganti Gate AND klasik:

Jawapan:

Ia adalah Gate Toffoli! Ingat, Gate Toffoli, atau controlled-controlled-NOT, membalikkan keadaan sasaran jika dan hanya jika Qubit kawalan 0 DAN Qubit kawalan 1 kedua-duanya berada dalam keadaan $\vert 1\rangle$. Jadi, jika Qubit sasaran bermula dalam keadaan $\vert 0\rangle$, maka ia mempunyai tindakan yang sama seperti Gate AND.

Jadi, sekarang kita mempunyai semua bahan yang diperlukan 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 ialah rajah Circuit untuk Circuit penambah separuh kuantum. Seperti yang disebutkan sebelumnya, wayar mewakili Qubit $0$ hingga $3$ disusun dari atas ke bawah, dan daftar bit klasik ialah wayar bergaris dua di bawah. Kemudian, membaca dari kiri ke kanan, kita melihat bagaimana gate dikenakan kepada setiap Qubit dengan melihat di mana kotak muncul pada wayar yang berkaitan. Akhirnya, pengukuran ditunjukkan di penghujung. Pengukuran meruntuhkan keadaan Qubit kepada nilai $0$ atau $1$ yang pasti, dan keputusan dihantar ke daftar klasik.

Satu kehalusan: walaupun rajah Circuit dilukis dari kiri ke kanan, ketika menulis ungkapan matriks yang sepadan kita mesti membacanya dari kanan ke kiri. Ini kerana dalam pendaraban matriks, operator yang paling dekat dengan vektor keadaan bertindak dahulu. Jadi, sebagai contoh, 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. Pengoptimuman:

Seterusnya, kita perlu mengoptimumkan Circuit untuk dijalankan pada perkakasan kuantum. Pengoptimuman ini dicapai melalui Transpiler, yang menterjemahkan Circuit abstrak yang ditunjukkan di atas kepada arahan yang akan difahami oleh komputer kuantum. Ia menetapkan Qubit logik di atas kepada Qubit fizikal sebenar pada pemproses dan menulis semula gate dari segi set gate natif tersendiri yang telah dioptimumkan untuk dijalankan pada komputer kuantum. Akhirnya, Transpiler juga melaksanakan sesuatu yang dipanggil "penindasan dan pengurangan ralat" untuk cuba meminimumkan kesan ralat pada keputusan. Ini tidak begitu penting untuk Circuit kita yang sangat mudah, tetapi jika kamu meneruskan perjalanan pengkomputeran kuantum untuk menjalankan Circuit yang lebih kompleks, kamu akan segera melihat nilai penindasan dan pengurangan ralat. Jika kamu ingin mengetahui lebih lanjut mengenai perkara ini, lihat kursus Olivia Lane, Pengkomputeran Kuantum dalam Amalan.

Pertama, kita memuatkan pakej yang diperlukan untuk berkomunikasi dengan komputer kuantum IBM® dan memilih Backend untuk dijalankan. Kita boleh memilih Backend yang paling sibuk, atau memilih Backend tertentu yang sifatnya kita ketahui.

Terdapat kod di bawah untuk menyimpan kelayakan kamu semasa penggunaan pertama. Pastikan kamu memadam maklumat ini daripada notebook selepas menyimpannya ke persekitaran kamu, supaya kelayakan kamu tidak terdedah secara tidak sengaja apabila kamu berkongsi notebook. Lihat Sediakan akaun IBM Cloud kamu dan Mulakan perkhidmatan dalam persekitaran tidak dipercayai untuk panduan 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 mengoptimumkan Circuit. Kita boleh memilih tahap pengoptimuman dari 0 (tiada pengoptimuman) hingga 3 (pengoptimuman tertinggi). Untuk melihat apa yang setiap tahap melibatkan, lawati panduan Tetapkan tahap pengoptimuman Transpiler. Circuit yang dihasilkan akan kelihatan sangat berbeza daripada Circuit logik yang kita buat dalam langkah pemetaan kita.

# 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 direka untuk mengambil sampel keadaan yang mungkin terhasil daripada Circuit kuantum, dan mengumpulkan statistik tentang keadaan yang mungkin diukur dan dengan kebarangkalian berapa. Kita mengimport 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 masa yang diperuntukkan pada komputer kuantum sebenar atau jika kamu tidak mempunyai sambungan internet, kamu mungkin lebih suka menggunakan simulator. Untuk melakukan ini, jalankan sel di bawah dan nyahkomen baris yang berkaitan dalam langkah "Laksana".

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

Selepas menyediakan Circuit, kita kini boleh menjalankannya pada 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-pemprosesan

Sekarang kita bersedia untuk melihat keputusan kita! Kita akan memaparkan histogram bagi 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 keputusan pengukuran kesemua empat Qubit di penghujung Circuit. Komputer kuantum ideal dengan sifar hingar seharusnya mengukur Qubit menghasilkan nilai yang sama setiap kali, tetapi dalam realiti, hingar akan menyebabkan beberapa larian menghasilkan ralat.

Uji pemahaman kamu

Baca soalan di bawah, fikirkan jawapan kamu, kemudian klik segitiga untuk mendedahkan penyelesaiannya.

Menggunakan bitstring dengan kiraan terbanyak sebagai nilai kamu untuk $A$, $B$, $S$, dan $C$, sahkan bahawa Circuit penambah kuantum berfungsi.

Jawapan:

Kita perlu mengesahkan bahawa $A+B = S+2 \times C$. Ingat bahawa susunan bitstring mengikut notasi little-endian, jadi ia dibaca CSBA.

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

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

Pergi balik dan tukar nilai $A$ dan $B$ kepada $A=1$ dan $B=1$ dan lalui langkah-langkah corak Qiskit sekali lagi untuk menjalankan semula Circuit. Sahkan bahawa Circuit penambah berfungsi sekali lagi.

Jawapan:

Kamu sepatutnya mendapat histogram dengan bitstring dominan ialah 1011:

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

Salah satu ciri tambahan penambah separuh kuantum berbanding penambah separuh klasik ialah ia boleh dijalankan dengan input kuantum. Iaitu, ia boleh "menambah" Qubit $A$ dan $B$ walaupun mereka berada dalam keadaan superposisi. Dalam bahagian Soalan Cabaran di bawah, kamu akan diminta untuk menyediakan Qubit dalam superposisi dan melihat apa yang berlaku!

Kesimpulan

Modul ini direka untuk memberikan kamu pemahaman asas yang kukuh tentang prinsip-prinsip asas di sebalik pengkomputeran kuantum dengan membandingkannya dengan pengkomputeran klasik. Kita melihat Circuit penambah separuh klasik dan kemudian menunjukkan kepada kamu cara menyesuaikan Circuit untuk dijalankan dengan Qubit pada komputer kuantum. Kini kamu bersedia untuk meneroka modul-modul Qiskit dalam Kelas yang lain!

Konsep penting:

• Berbeza dengan bit klasik yang hanya boleh mengambil nilai 0 dan 1, Qubit juga boleh berada dalam keadaan superposisi kedua-dua 0 dan 1.
• Pelbagai Qubit boleh berada dalam superposisi ke atas bitstring yang dibenarkan secara klasik yang dipanggil keadaan asas pengiraan.
• Pelbagai Qubit boleh berjalin supaya keadaan satu bergantung pada keadaan yang lain.
• Konvensyen Qiskit adalah menggunakan notasi little-endian, yang meletakkan Qubit paling tidak signifikan, $q_0$, di kedudukan paling kanan dan Qubit paling signifikan, $q_N$, paling kiri.
• Gate kuantum adalah operasi boleh balik yang diwakili oleh matriks unitari yang bertindak ke atas vektor keadaan kuantum. Dalam notasi ini, matriks yang paling dekat dengan vektor (yang paling kanan) bertindak dahulu.
• Pengukuran meruntuhkan keadaan superposisi kuantum kepada salah satu keadaan yang dibenarkan secara klasik, dengan kebarangkalian sama dengan kuasa dua amplitud keadaan asas pengiraan yang sepadan dalam superposisi.
• Circuit kuantum sering diwakili menggunakan rajah Circuit kuantum, di mana Qubit digambarkan sebagai wayar mendatar, dan gate kuantum muncul di sepanjang wayar ini dari kiri ke kanan.
• Untuk menjalankan Circuit kuantum, kita menggunakan empat langkah dalam aliran kerja corak Qiskit: Peta, Optimum, Laksana, Pasca-proses.

Soalan

Soalan Benar/Palsu

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

2. Keterjalin bermakna keadaan satu Qubit adalah bebas daripada keadaan Qubit yang lain.

3. Gate kuantum umumnya adalah operasi yang tidak boleh dibalikkan.

4. Konvensyen Qiskit meletakkan Qubit paling tidak signifikan, $q_0$, di kedudukan paling kiri.

5. Mengukur keadaan kuantum sentiasa memberikan keputusan yang sama jika diulang berkali-kali.

6. Gate Hadamard mencipta superposisi dalam satu Qubit.

7. Circuit kuantum mungkin merangkumi operasi pengukuran yang meruntuhkan keadaan superposisi kepada salah satu keadaan yang dibenarkan secara klasik.

8. Bilangan keadaan klasik yang mungkin untuk $N$ bit ialah $2N$.

9. Kebarangkalian hasil pengukuran kuantum diberikan oleh amplitud kuasa dua keadaan asas yang boleh diukur secara klasik.

Soalan Jawapan Pendek

1. Apakah beberapa perbezaan utama antara bit dan Qubit?

2. Apa yang berlaku kepada keadaan kuantum apabila ia diukur?

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

4. Apakah empat langkah dalam aliran kerja corak Qiskit?

Soalan Cabaran:

1. Dalam modul ini, kita hanya menggunakan penambah untuk menambah keadaan yang dibenarkan secara klasik untuk $A$ dan $B$. Tetapi kita juga boleh menyediakan $A$ dan $B$ dalam superposisi! Tukar kod untuk menyediakan setiap Qubit dalam superposisi sama rata 0 dan 1, kemudian jalankan Circuit baru dan dapatkan histogram baru. Apa yang kamu lihat? Jelaskan apa yang berlaku.

2. Dekomposisi Gate Toffoli. Gunakan decompose() untuk menunjukkan bagaimana Gate Toffoli didekomposisikan kepada gate satu-Qubit dan dua-Qubit, kemudian sahkan pembinaan ini dengan pendaraban matriks. Ingat bahawa walaupun rajah Circuit dibaca dari kiri ke kanan, matriks dikenakan kepada keadaan kuantum dari kanan ke kiri!