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, Anda 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 Anda.

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 Anda menyimpan lebih banyak maklumat. Contohnya, jika Anda ingin menyimpan nombor dari 0 hingga 15, Anda 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, Anda 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 Anda mencapai bit paling bererti (bit paling kiri), yang Anda darabkan dengan $2^{N-1}$.

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

Semak kefahaman Anda

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

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

Jawapan:

Ingat, $N$ bit membolehkan Anda 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. get binari adalah operasi yang membentuk blok binaan asas bagi semua algoritma dan kod yang lebih rumit.

get satu-bit:

NOT

Apabila Anda hanya mempunyai satu bit, hanya ada satu cara Anda 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

get 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.

litar:

Dengan menggabungkan gate-gate di atas, Anda boleh melakukan apa sahaja operasi yang Anda mahu pada komputer. Mari ambil contoh mudah: Menggunakan gate AND dan XOR, Anda boleh membina litar half-adder, yang mengira jumlah dua bit. Ini diwakili dalam gambar rajah litar 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 Anda

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

Sahkan bahawa jadual kebenaran di atas menghasilkan penyelesaian yang betul untuk litar 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 Anda 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 Anda

Baca soalan di bawah, fikirkan jawapan Anda, 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 Anda

Baca soalan di bawah, fikirkan jawapan Anda, 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 Anda 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 Anda 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 Anda

Baca soalan di bawah, fikirkan jawapan Anda, 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}$$

get $\rightarrow$ get kuantum

Sama seperti gate klasik seperti NOT, AND, OR, dan XOR boleh digabungkan untuk membina litar klasik arbitrari, get kuantum memainkan peranan yang sama dalam pengkomputeran kuantum. Kerana qubit mempunyai ciri-ciri mekanik kuantum tambahan, get 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 get kuantum, selalunya lebih semula jadi menggunakan perwakilan matriks, kerana ia juga bertindak pada superposisi keadaan asas.

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

get satu-qubit

get $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 litar dengan get $X$ kelihatan seperti ini:

from qiskit import QuantumCircuit

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

Dalam gambar rajah litar yang sangat mudah ini, qubit diwakili oleh satu wayar, garis mendatar hitam, dan get 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}$

litar dengan get Hadamard dibuat seperti berikut:

from qiskit import QuantumCircuit

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

get $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 litar dengan get $Z$ kelihatan seperti ini:

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

get $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 litar dengan get $T$ kelihatan seperti ini:

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

get berbilang-qubit

get 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, Anda 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 get $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 litar pertama yang kita lihat dengan dua qubit, yang diwakili oleh dua wayar. get CNOT dilaksanakan antara dua qubit, dengan $q_0$ sebagai kawalan dan $q_1$ sebagai sasaran.

Uji pemahaman Anda

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

Kebanyakan get mempunyai bentuk matriks yang sama dalam Qiskit seperti di tempat lain. Tetapi get 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 get 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: get 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")

get SWAP sebenarnya boleh dibina daripada tiga CNOT. Untuk melihat caranya, kita boleh decompose() get tersebut dengan Qiskit:

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

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

Uji pemahaman Anda

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

Sahkan bahawa gabungan CNOT di atas menghasilkan get 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 Anda 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")

get Toffoli juga boleh didekomposisikan kepada CNOT, bersama beberapa gate lain. Walau bagaimanapun, ia jauh lebih rumit daripada dekomposisi get 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, Anda boleh memeriksa bit-bit Anda pada bila-bila masa yang dikehendaki semasa sesuatu algoritma, dalam pengkomputeran kuantum, Anda perlu sangat selektif tentang bila hendak melihat qubit-qubit Anda 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 litar 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")

litar

Sekarang kita dah tahu bagaimana qubit, get, dan pengukuran berfungsi, jom buat dan laksanakan litar kuantum kita sendiri! Untuk ini, kita perlu memperkenalkan Anda 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 litar kuantum dan operator
2. Pengoptimuman litar untuk perkakasan sasaran
3. Pelaksanaan pada perkakasan sasaran
4. Pasca-pemprosesan keputusan kita

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

1. Pemetaan

litar penambah klasik menggunakan get 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 litar 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 get AND klasik.

Uji pemahaman Anda

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

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

Jawapan:

Ia adalah get Toffoli! Ingat, get 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 get AND.

Jadi, sekarang kita mempunyai semua bahan yang diperlukan untuk membuat litar 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 litar untuk litar 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 litar 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, litar 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 litar untuk dijalankan pada perkakasan kuantum. Pengoptimuman ini dicapai melalui Transpiler, yang menterjemahkan litar 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 litar kita yang sangat mudah, tetapi jika Anda meneruskan perjalanan pengkomputeran kuantum untuk menjalankan litar yang lebih kompleks, Anda akan segera melihat nilai penindasan dan pengurangan ralat. Jika Anda 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 Anda semasa penggunaan pertama. Pastikan Anda memadam maklumat ini daripada notebook selepas menyimpannya ke persekitaran Anda, supaya kelayakan Anda tidak terdedah secara tidak sengaja apabila Anda berkongsi notebook. Lihat Sediakan akaun IBM Cloud Anda 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 litar. 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. litar yang dihasilkan akan kelihatan sangat berbeza daripada litar 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 litar 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 Anda telah menghabiskan masa yang diperuntukkan pada komputer kuantum sebenar atau jika Anda tidak mempunyai sambungan internet, Anda 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 litar, 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 litar.

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 litar. 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 Anda

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

Menggunakan bitstring dengan kiraan terbanyak sebagai nilai Anda untuk $A$, $B$, $S$, dan $C$, sahkan bahawa litar 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 litar. Sahkan bahawa litar 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, Anda akan diminta untuk menyediakan qubit dalam superposisi dan melihat apa yang berlaku!

Kesimpulan

Modul ini direka untuk memberikan Anda pemahaman asas yang kukuh tentang prinsip-prinsip asas di sebalik pengkomputeran kuantum dengan membandingkannya dengan pengkomputeran klasik. Kita melihat litar penambah separuh klasik dan kemudian menunjukkan kepada Anda cara menyesuaikan litar untuk dijalankan dengan qubit pada komputer kuantum. Kini Anda 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.
• get 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.
• litar kuantum sering diwakili menggunakan rajah litar kuantum, di mana qubit digambarkan sebagai wayar mendatar, dan gate kuantum muncul di sepanjang wayar ini dari kiri ke kanan.
• Untuk menjalankan litar 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. get 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. get Hadamard mencipta superposisi dalam satu qubit.

7. litar 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 litar baru dan dapatkan histogram baru. Apa yang Anda lihat? Jelaskan apa yang berlaku.

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