เริ่มต้นใช้งาน Qiskit ในห้องเรียน

สำหรับโมดูล Qiskit in Classrooms นี้ นักเรียนต้องมี Python environment ที่ใช้งานได้พร้อมติดตั้งแพ็คเกจต่อไปนี้:

• qiskit v2.1.0 หรือใหม่กว่า
• qiskit-ibm-runtime v0.40.1 หรือใหม่กว่า
• qiskit-aer v0.17.0 หรือใหม่กว่า
• qiskit.visualization
• numpy
• pylatexenc

สำหรับการตั้งค่าและติดตั้งแพ็คเกจข้างต้น ดูคู่มือ ติดตั้ง Qiskit เพื่อรัน job บนคอมพิวเตอร์ควอนตัมจริง นักเรียนต้องสร้างบัญชีกับ IBM Quantum® โดยทำตามขั้นตอนในคู่มือ ตั้งค่าบัญชี IBM Cloud®

โมดูลนี้ผ่านการทดสอบและใช้เวลา QPU 2 วินาทีบนโปรเซสเซอร์ Heron v2 ตัวเลขนี้เป็นการประมาณเท่านั้น การใช้งานจริงของคุณอาจแตกต่างกัน

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

บทนำ

ในโมดูล Qiskit in the Classroom คุณจะได้ใช้คอมพิวเตอร์ควอนตัมเพื่อสำรวจแนวคิดต่างๆ ในสาขาที่เกี่ยวข้องกับการประมวลผลเชิงควอนตัม เช่น กลศาสตร์ควอนตัม วิทยาการคอมพิวเตอร์ เคมี และอื่นๆ โมดูลนี้เป็นพื้นฐานสำหรับโมดูลอื่นๆ — มันแนะนำหลักการพื้นฐานของการประมวลผลเชิงควอนตัมและวิธีใช้ Qiskit เพื่อรันวงจรควอนตัม

เราจะเริ่มด้วยภาพรวมคร่าวๆ ของการทำงานของคอมพิวเตอร์แบบคลาสสิก จากนั้นแสดงให้เห็นว่าแนวคิดเหล่านี้ถูกปรับใช้ในกระบวนทัศน์การประมวลผลเชิงควอนตัมอย่างไร สุดท้ายเราจะแสดงวิธีนำแนวคิดเหล่านี้มารวมกันเพื่อสร้างและรันวงจรควอนตัมแรกของคุณ

คอมพิวเตอร์แบบคลาสสิก

คุณน่าจะรู้จักพื้นฐานของการทำงานของคอมพิวเตอร์แบบคลาสสิกอยู่แล้ว แต่ที่นี่เราจะเน้นคุณสมบัติสำคัญบางอย่างเพื่อเปรียบเทียบกับคอมพิวเตอร์ควอนตัม

หน่วยข้อมูลพื้นฐาน: bits

คอมพิวเตอร์แบบคลาสสิกประมวลผลข้อมูลแบบคลาสสิก และหน่วยพื้นฐานของข้อมูลแบบคลาสสิกคือ bit bit เดียวสามารถเก็บคำตอบของคำถาม "ใช่/ไม่ใช่" ได้หนึ่งข้อ เราแทนสองสถานะไบนารีของ bit ด้วย "0" และ "1"

ทบทวนเลขฐานสอง

การรวม bits ช่วยให้คุณเก็บข้อมูลได้มากขึ้น ตัวอย่างเช่น ถ้าต้องการเก็บตัวเลขตั้งแต่ 0 ถึง 15 คุณสามารถทำได้ด้วย four bits ดังนี้:

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

โดยทั่วไป ในการแปลงจากเลขไบนารี $N$ บิตเป็นเลขฐานสิบที่คุ้นเคย คุณคูณ bit ที่มีนัยสำคัญน้อยที่สุด (ขวาสุด) ด้วย $2^0 = 1$ bit ถัดไปทางซ้ายด้วย $2^1 = 2$ แล้ว bit ถัดไปด้วย $2^2 = 4$ และต่อไปเรื่อยๆ จนถึง bit ที่มีนัยสำคัญมากที่สุด (ซ้ายสุด) ซึ่งคูณด้วย $2^{N-1}$

ดังนั้น $N$ bits สามารถอยู่ในสถานะที่แตกต่างกันได้ $2^N$ สถานะ

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

คุณต้องใช้กี่ bits เพื่อแทนตัวเลข 86? เขียน bitstring ที่เข้ารหัสตัวเลขนี้ในรูปเลขไบนารี

เฉลย:

จำไว้ว่า $N$ bits ให้คุณแทนตัวเลขตั้งแต่ $0$ ถึง $2^N - 1$ ดังนั้นใช้หก bits จะได้ถึง $2^6 - 1 = 63$ ยังไม่พอ เพิ่มอีกหนึ่ง bit จะได้ $2^7 - 1 = 127$ ตอนนี้แยก 86 เป็นกำลังของ 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}$$

การดำเนินการพื้นฐาน: gates

คอมพิวเตอร์ต้องสามารถ ทำอะไรบางอย่าง กับ bits ได้เพื่อคำนวณ Binary gates คือการดำเนินการที่เป็นบล็อกพื้นฐานของอัลกอริธึมและโค้ดที่ซับซ้อนยิ่งขึ้น

Single-bit gate:

NOT

เมื่อมี bit เดียว มีเพียงวิธีเดียวที่คุณสามารถเปลี่ยนสถานะได้: พลิกสถานะจาก 0 เป็น 1 หรือจาก 1 เป็น 0 เราเรียกสิ่งนี้ว่า gate "NOT" ผลกระทบของ gate นี้ — และ gate อื่นๆ ที่เราจะพูดถึงด้านล่าง — สามารถแสดงใน "truth table" ที่มีคอลัมน์สำหรับสถานะอินพุตและเอาต์พุตของ qubit truth table สำหรับ NOT gate คือ:

อินพุต	เอาต์พุต
0	1
1	0

Multi-bit gates:

AND

AND คือ two-bit gate ที่รับ input bit สองตัวและส่งออก bit เดียว มันส่งออก 1 ถ้า input bits ทั้งสองเป็น 1 มิฉะนั้นส่งออก 0:

อินพุต	เอาต์พุต
00	0
01	0
10	0
11	1

OR

OR คืออีก two-bit gate ที่มี output bit เดียว มันส่งออก 1 ถ้า bit ใดบิตหนึ่ง เป็น 1:

อินพุต	เอาต์พุต
00	0
01	1
10	1
11	1

XOR

XOR ย่อมาจาก "exclusive OR" และมันเหมือน OR gate แต่ส่งออก 1 ถ้า มีเพียง input bit เดียว เท่านั้นที่เป็น 1 มันส่งออก 0 ถ้าทั้งคู่เป็น 1 หรือทั้งคู่เป็น 0:

อินพุต	เอาต์พุต
00	0
01	1
10	1
11	0

Measurements:

โดยทั่วไปเมื่อเรียนเกี่ยวกับการประมวลผลแบบคลาสสิก จะไม่ค่อยให้ความสนใจกับกระบวนการอ่านค่าสถานะของ bits เพราะมันไม่ซับซ้อนในเชิงแนวคิด คุณสามารถวัด bits ได้ทุกเมื่อก่อน ระหว่าง หรือหลังการคำนวณ และมันไม่ส่งผลต่อผลลัพธ์ แต่ไม่ใช่เช่นนั้นในการประมวลผลเชิงควอนตัม ดังที่เราจะพูดถึงด้านล่าง

Circuits:

ด้วยการรวม gates ข้างต้น คุณสามารถทำการดำเนินการใดๆ ที่ต้องการบนคอมพิวเตอร์ได้ ตัวอย่างง่ายๆ: ใช้ AND และ XOR gates คุณสามารถสร้าง half-adder circuit ซึ่งคำนวณผลรวมของ bits สองตัว สิ่งนี้แสดงในแผนภาพวงจรลอจิก ที่สายไฟแทน bits และ gates ที่ทำงานบน bits แสดงเป็นสัญลักษณ์บนสายไฟที่สอดคล้องกัน:

ดังนั้น bits ทั้งสองถูกคัดลอกและส่งผ่านทั้ง AND gate และ XOR gate ผลลัพธ์ของ XOR gate คือ "sum bit" (S) ซึ่งอยู่ในตำแหน่งหลักหน่วยของเลขไบนารี และผลลัพธ์ของ AND gate คือ "carry bit" (C) ซึ่งเป็นค่าของหลักถัดไปที่มีนัยสำคัญมากกว่าในเลขไบนารี นี่คือ truth table:

$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

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

ตรวจสอบว่า truth table ข้างต้นให้คำตอบที่ถูกต้องสำหรับ adder circuit นั่นคือ สำหรับตัวเลือก A และ B ทั้งสี่แบบ ตรวจสอบว่า $A+B=S+2 \times C$

เฉลย:

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

คอมพิวเตอร์ควอนตัม

Bits $\rightarrow$ Qubits

เช่นเดียวกับที่ bits เป็นหน่วยพื้นฐานของข้อมูลแบบคลาสสิก quantum bits หรือ "Qubits" คือหน่วยพื้นฐานของข้อมูลเชิงควอนตัม เช่นเดียวกับ bit แบบคลาสสิก สถานะของ Qubit สามารถเป็น 0 หรือ 1 ซึ่งเราแทนด้วย $\vert 0\rangle$ และ $\vert 1\rangle$ แต่ต่างจาก bit แบบคลาสสิก quantum bit ยังสามารถอยู่ใน superposition ของทั้งสถานะ $\vert 0\rangle$ และ $\vert 1\rangle$ พร้อมกันได้ โดยทั่วไป Qubit สามารถอยู่ในสถานะ $\vert \psi\rangle$ ในรูปแบบ:

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

ที่ $c_0$ และ $c_1$ คือ complex amplitudes ที่มี $\vert c_0 \vert ^2+\vert c_1\vert ^2=1$

เฟสเชิงควอนตัม

เนื่องจาก $c_0$ และ $c_1$ เป็นจำนวนเชิงซ้อน แต่ละตัวสามารถเขียนเป็น $c_i = \vert c_i\vert e^{i\phi_i}$ ที่ $\phi_i$ เรียกว่า เฟส ถ้าเราคูณสถานะทั้งหมดด้วยตัวประกอบเฟสรวมเดียวกัน ไม่มีอะไรเปลี่ยนแปลงทางกายภาพ — เรียกว่า global phase และไม่มีผลที่สังเกตได้

ด้วยเหตุนั้น เป็นธรรมเนียมที่จะ "แยกออก" $e^{i\phi_0}$ ทำให้ได้:

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

ที่ $\phi = \phi_1-\phi_0$ คือ relative phase ของสถานะควอนตัม ซึ่ง มี ผลที่สังเกตได้

เฟสนี้มีบทบาทสำคัญมากในการประมวลผลเชิงควอนตัม และคุณจะได้สำรวจผลกระทบต่างๆ ของมันในโมดูล Qiskit in the Classroom ถัดไป

หลาย Qubits

ในขณะที่สถานะของหลาย bits สามารถแสดงได้ง่ายๆ เป็นสตริงของ 0 และ 1 สถานะของหลาย Qubits ซับซ้อนขึ้นนิดหน่อยเพราะหลักการ superposition และ entanglement

จำไว้ว่า $N$ bits สามารถอยู่ในหนึ่งในสถานะที่เป็นไปได้ $2^N$ สถานะ ตั้งแต่เลขไบนารี 000...000 ถึง 111...111 แต่ตอนนี้ เพราะหลักการ superposition $N$ Qubits สามารถอยู่ใน superposition ของ ทุก สถานะเหล่านั้นพร้อมกัน!

สิ่งนี้สามารถแสดงเป็น

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

ที่ เช่นเดียวกับกรณีคลาสสิก สถานะ $\vert i\rangle$ สอดคล้องกับสถานะที่แต่ละ Qubit อยู่ในการรวมกันของ 0 และ 1 ที่ถูกต้องเพื่อให้ได้เลขไบนารี $i$ เรียกว่า "computational basis states" ของระบบควอนตัม ตัวอย่างเช่น สถานะสาม-Qubit สามารถเขียนเป็น superposition ของ computational basis states แปดตัว:

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

แต่ละ Qubit ในระบบแทนด้วยดัชนี $0$ ถึง $N-1$ ธรรมเนียมคือการอ่านสถานะ Qubit จากขวาไปซ้าย ดังนั้นสถานะของ Qubit $0$ อยู่ทางขวาสุดและสถานะของ Qubit $N-1$ อยู่ทางซ้ายสุด เรียกว่า "little-endian" notation และอาจดูไม่ตรงสัญชาตญาณในตอนแรก เพราะเราคุ้นเคยกับการอ่านจากซ้ายไปขวา

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

เมื่อมองแวบแรก การเรียง Qubits จากขวาไปซ้ายแบบ little-endian notation อาจดูไม่ตรงสัญชาตญาณ แต่มันเป็นสิ่งที่สมเหตุสมผลมาก! อธิบายว่าทำไม (นึกถึงการอภิปรายข้างต้นเกี่ยวกับการแปลงเลขไบนารีเป็นฐานสิบ)

เฉลย:

ถ้าเราเรียง Qubits จากขวาไปซ้าย ทำให้ Qubit 0 อยู่ขวาสุดและ Qubit N-1 อยู่ซ้ายสุด มันสมเหตุสมผลที่จะเชื่อม Qubit $0$ กับ bit ที่มีนัยสำคัญน้อยที่สุด ซึ่งคูณด้วย $2^0$ และ Qubit $N-1$ กับ bit ที่มีนัยสำคัญมากที่สุด ซึ่งคูณด้วย $2^{N-1}$

Entanglement

ดังที่เราได้กล่าวไว้ก่อนหน้า คุณสมบัติสำคัญอีกอย่างของ Qubits คือสามารถ entangle กันได้ ตัวอย่างเช่น สถานะสอง-Qubit ที่ $c_0 = c_3 = \frac{1}{\sqrt{2}}$ และ $c_1 = c_2 = 0$:

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

ดังนั้นสถานะของ Qubit 0 อาจเป็น $\vert 0\rangle$ หรือ $\vert 1\rangle$ ด้วยความน่าจะเป็นเท่ากัน และเช่นเดียวกันกับสถานะของ Qubit 1 แต่ความน่าจะเป็นเหล่านี้ไม่เป็นอิสระต่อกันอีกต่อไป ถ้าเราพบว่าสถานะของ Qubit 0 เป็น $\vert 0\rangle$ เราก็ รู้ ว่า Qubit 1 จะอยู่ใน $\vert 0\rangle$ ด้วย ไม่ว่าจะอยู่ห่างกันแค่ไหน นั่นคือเหตุผลที่การวัดสถานะ entangled บางครั้งเรียกว่า "spooky action at a distance"

Entanglement ยังมีรูปแบบอื่นด้วย ตัวอย่างเช่น สถานะ

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

ให้ผลลัพธ์ตรงข้ามทุกครั้ง: ถ้า Qubit หนึ่งวัดได้ $\vert 0\rangle$ อีกตัวจะต้องอยู่ในสถานะ $\vert 1\rangle$

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

สถานะ $\vert \psi\rangle = \vert 11\rangle$ มี entanglement หรือไม่? เพราะอะไร?

เฉลย:

ไม่มี entanglement แม้ว่าผลลัพธ์จะเหมือนกันเสมอเมื่อวัด Qubits ทั้งสอง แต่นั่นเป็นเพราะแต่ละ Qubit ถูกตรึงอยู่ในสถานะ $\vert 1\rangle$ เสมอ ผลลัพธ์ของการวัด Qubit หนึ่งไม่ได้ขึ้นอยู่กับอีกตัว — ทั้งคู่แค่เป็น $\vert 1\rangle$ เสมอ

โดยทั่วไป ถ้าคุณสามารถอธิบายสถานะของแต่ละ Qubit แยกกันแล้วคูณรวมกันแบบนี้:

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

เรียกว่า "product state" และ ไม่มี entanglement

สัญกรณ์เวกเตอร์

บ่อยครั้งมีประโยชน์ในการใช้เวกเตอร์และเมทริกซ์เพื่อดูว่าสถานะควอนตัมเปลี่ยนแปลงอย่างไรภายใต้การดำเนินการต่างๆ ในการแทนนี้ สถานะควอนตัมจะเป็นเวกเตอร์ และ quantum gates (ที่จะอภิปรายในส่วนถัดไป) จะเป็นเมทริกซ์ที่แปลงเวกเตอร์

สำหรับ Qubit เดียว รูปแบบเวกเตอร์ของสถานะถูกเลือกเป็น: $\vert 0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$ $\vert 1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$ ด้วยวิธีนี้ สถานะทั่วไป $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ สามารถเขียนเป็น $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

สำหรับสถานะ $n$-Qubit ทั่วไป เราต้องการเวกเตอร์ $2^n$ มิติ โดยมีสถานะฐานเรียงตามลำดับที่คาดได้ ตามค่าไบนารีที่เพิ่มขึ้น:

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

เมื่อมีสัญกรณ์เวกเตอร์นี้ในใจ เราสามารถแนะนำ quantum gates ที่จำเป็น ผลกระทบต่อสถานะควอนตัม และรูปแบบเมทริกซ์ของมัน

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

มี computational basis states สี่ตัวสำหรับระบบสอง-Qubit เขียนแต่ละตัวในสัญกรณ์ทั้ง ket และเวกเตอร์

เฉลย:

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

Gates $\rightarrow$ quantum gates

เช่นเดียวกับที่ classical gates อย่าง NOT, AND, OR และ XOR สามารถรวมกันเพื่อสร้างวงจรแบบคลาสสิกที่ต้องการได้ quantum gates มีบทบาทเดียวกันในการประมวลผลเชิงควอนตัม เนื่องจาก Qubits มีคุณสมบัติเชิงกลศาสตร์ควอนตัมเพิ่มเติม quantum gates จึงมีความหลากหลายกว่า แม้ว่าเราจะยังอธิบายการทำงานบน basis states $|0\rangle$ และ $|1\rangle$ ด้วย truth table ได้ แต่มันไม่ได้ครอบคลุมภาพทั้งหมด สำหรับ quantum gates มักจะเป็นธรรมชาติมากกว่าในการใช้การแทนเมทริกซ์ เพราะมันยังทำงานบน superpositions ของ basis states ด้วย

ด้านล่างเราจะแนะนำ quantum gates ที่พบบ่อยที่สุดและวิธีที่มันแปลง Qubits ที่มันทำงานด้วย เมื่อเหมาะสม เราจะเชื่อมโยงกลับไปยัง classical gates ที่คุ้นเคย

Single-qubit gates

$X$ gate: นี่คือการดำเนินการเทียบเท่า NOT ในเชิงควอนตัม truth table ของมันดูเหมือน classical NOT gate:

อินพุต	เอาต์พุต
$\vert 0\rangle$	$\vert 1\rangle$
$\vert 1\rangle$	$\vert 0\rangle$

และการแทนเมทริกซ์:

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

ใน Qiskit การสร้าง Circuit ด้วย $X$ gate มีลักษณะดังนี้:

from qiskit import QuantumCircuit

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

ในแผนภาพ Circuit ที่เรียบง่ายมากนี้ Qubit แทนด้วยสายไฟ เส้นแนวนอนสีดำ และ gate แสดงขึ้นเป็นกล่องบนสายไฟนั้น

Hadamard gate: สร้างสถานะ superposition truth table:

อินพุต	เอาต์พุต
$\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)$

การแทนเมทริกซ์: $H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$

Circuit ที่มี Hadamard gate สร้างได้ดังนี้:

from qiskit import QuantumCircuit

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

$Z$ gate: เพิ่ม phase shift ที่ $\Delta \phi = \pi$ ให้กับสถานะ $|1\rangle$:

อินพุต	เอาต์พุต
$\vert 0\rangle$	$\vert 0\rangle$
$\vert 1\rangle$	$-\vert 1\rangle$

$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$

ใน Qiskit การสร้าง Circuit ด้วย $Z$ gate มีลักษณะดังนี้:

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

$T$ gate: เพิ่ม phase shift ที่ $\Delta \phi = \pi/4$ ให้กับสถานะ $|1\rangle$:

อินพุต	เอาต์พุต
$\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}$

ใน Qiskit การสร้าง Circuit ด้วย $T$ gate มีลักษณะดังนี้:

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

Multi-qubit gates

Two-qubit gates อาจดูคล้าย classical two-bit gates แต่มีข้อแม้สำคัญหนึ่งอย่าง: quantum gates ทั้งหมดต้องเป็น reversible ในเทอมพีชคณิตเชิงเส้น หมายความว่ามันแทนด้วยเมทริกซ์ unitary ดังนั้น input Qubits สองตัวจะแมปเป็น output Qubits สองตัวเสมอ และการดำเนินการสามารถย้อนกลับได้ในหลักการ สิ่งนี้ต่างจาก classical gates ที่เราเห็นข้างต้นอย่าง AND หรือ OR ซึ่งสูญเสียข้อมูลและเป็น irreversible — เมื่อได้รับ output ไม่สามารถระบุ input ได้อย่างชัดเจน

CNOT (Controlled-NOT) gate: Qubits input สองตัวเรียกว่า "control" และ "target" Qubits Qubit control ยังคงไม่เปลี่ยนแปลง แต่สถานะของมันกำหนดสิ่งที่เกิดขึ้นกับ target Qubit ถ้า Qubit control อยู่ในสถานะ $\vert 1\rangle$ จะมีการใช้ $X$ gate กับ target; ถ้าสถานะของ Qubit control เป็น $\vert 0\rangle$ ไม่มีการเปลี่ยนแปลง ในสัญกรณ์ด้านล่าง สมมติว่า Qubit $A$ (ขวาสุด) คือ control และ Qubit $B$ (ซ้ายสุด) คือ target สัญกรณ์ที่ใช้คือ $CNOT(q_{control},q_{target})\vert BA\rangle.$

$CNOT(A,B)\vert BA\rangle_{input} = \vert BA\rangle_{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$

ดังนั้น เมทริกซ์ที่แทนการทำงานนี้คือ:

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

นี่คือแผนภาพ Circuit แรกที่เราเห็นสอง Qubits ซึ่งแทนด้วยสายไฟสองเส้น CNOT gate ถูกใช้ระหว่าง Qubits สองตัว โดย $q_0$ เป็น control และ $q_1$ เป็น target

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

Gates ส่วนใหญ่มีรูปแบบเมทริกซ์เหมือนกันทุกที่ใน Qiskit แต่ CNOT gate ทำงานบน Qubits สองตัว ทำให้ธรรมเนียมการเรียงลำดับ Qubits กลายเป็นปัญหา ตำราที่เรียง Qubits $\vert q_0,q_1,...\rangle$ จะแสดงรูปแบบเมทริกซ์ที่แตกต่างกันสำหรับ CNOT gates ของตน ตรวจสอบโดยการคูณเมทริกซ์ว่าเมทริกซ์ CNOT ข้างต้นมีการทำงานที่ถูกต้องบนสถานะ $\vert 01\rangle$

เฉลย:

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

SWAP gate: Gate นี้สลับสถานะของ Qubits สองตัว truth table:

อินพุต	เอาต์พุต
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 10\rangle$
$\vert 10\rangle$	$\vert 01\rangle$
$\vert 11\rangle$	$\vert 11\rangle$

ดังนั้น เมทริกซ์ที่แทนการทำงานนี้คือ:

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

SWAP gate สามารถสร้างจาก CNOT สามตัว เพื่อดูวิธีการ เราสามารถ decompose() gate ด้วย Qiskit:

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

ที่นี่เราเห็นครั้งแรกว่า gates หลายตัวแสดงในแผนภาพ Circuit อย่างไร เราอ่านจากซ้ายไปขวา ดังนั้น gate ซ้ายสุดถูกใช้ก่อน

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

ตรวจสอบว่าการรวม CNOTs ข้างต้นให้ผล SWAP gate คุณสามารถทำได้ด้วยการคูณเมทริกซ์หรือวิธีอื่น

เฉลย:

ด้วยการคูณเมทริกซ์:

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

ใช้ truth table เพื่อดูว่าสถานะเปลี่ยนแปลงอย่างไรกับแต่ละ CNOT ในคอลัมน์สุดท้าย สถานะควรเทียบเท่ากับคอลัมน์ "output" ของ SWAP truth table:

อินพุต	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$

Toffoli gate (หรือ "controlled-controlled-NOT" (CCNOT)): นี่คือ gate สาม-Qubit ชื่อ "controlled-controlled-NOT" อาจบอกได้แล้วว่ามันทำงานอย่างไร: มี Qubits control สองตัวและ target Qubit หนึ่งตัว และสถานะของ target Qubit จะพลิกเฉพาะเมื่อ Qubits control ทั้งสอง อยู่ในสถานะ $\vert 1\rangle$ เราใช้ธรรมเนียมการเรียงลำดับเดียวกับที่ใช้กับ CNOT:

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

ดังนั้น truth table คือ:

อินพุต	เอาต์พุต
$\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$

และเมทริกซ์ที่แทนการทำงานนี้คือ:

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

Toffoli gate ก็สามารถแตกย่อยเป็น CNOTs พร้อม gates อื่นๆ ได้เช่นกัน แต่มันซับซ้อนกว่าการแตกย่อย SWAP gate มาก ดังนั้นจะเหลือไว้เป็นแบบฝึกหัดเสริมท้ายโมดูลสำหรับสำรวจและตรวจสอบการแตกย่อยนี้

Measurements

Measurements มีบทบาทพิเศษในการประมวลผลเชิงควอนตัม — บทบาทที่ไม่มีอะนาล็อกในการประมวลผลแบบคลาสสิก ในขณะที่ในการประมวลผลแบบคลาสสิก คุณสามารถตรวจ bits ได้ตลอดเวลาในอัลกอริธึม แต่ในการประมวลผลเชิงควอนตัม คุณต้องระมัดระวังมากว่าจะมองดู Qubits เมื่อใด เพราะการวัดยุบสถานะและทำลาย superposition ที่ให้ความซับซ้อนเชิงการประมวลผลกับ Qubits

โดยเฉพาะ เมื่อให้สถานะควอนตัม $N$-bit $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$ การวัดจะยุบสถานะไปยังหนึ่งใน basis functions $\vert i\rangle$ ด้วยความน่าจะเป็นเท่ากับ $\vert c_i\vert ^2$

แต่ผลกระทบทำลายล้างของการวัดไม่ใช่อุปสรรคเสมอไป มันเป็นทรัพยากรสำคัญในอัลกอริธึมและโปรโตคอลบางอย่าง เช่น quantum teleportation และ quantum key distribution

ใน Qiskit เมื่อทำการวัด มันจะถูกส่งไปยัง classical register ที่เก็บไว้เป็น classical bit การสร้าง Circuit ที่มีการวัดมีลักษณะดังนี้:

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

Circuits

ตอนนี้เรารู้วิธีทำงานของ Qubits, Gates และ Measurements แล้ว มาสร้างและรัน quantum circuit ของเราเอง! สำหรับสิ่งนี้ เราจะแนะนำ workflow ที่มีประโยชน์ที่เรียกว่า Qiskit patterns

กรอบงาน Qiskit patterns

กรอบงาน Qiskit patterns คือกระบวนการทั่วไปสำหรับการเข้าถึงและแก้ปัญหาด้วยคอมพิวเตอร์ควอนตัม ประกอบด้วยสี่ขั้นตอน:

1. Mapping ปัญหาของเราเป็น quantum circuits และ operators
2. Optimizing Circuit สำหรับ hardware เป้าหมาย
3. Executing บน hardware เป้าหมาย
4. Post-processing ผลลัพธ์ของเรา

เพื่อแสดงขั้นตอนเหล่านี้ เราจะใช้ quantum version ของ half-adder circuit ที่อภิปรายข้างต้น

1. Mapping

Classical adder circuit ใช้ XOR และ AND gate เพื่อคำนวณ sum และ carry bits ตามลำดับ เราสามารถปรับ gates เหล่านี้ในบริบทเชิงควอนตัมเพื่อสร้าง quantum half adder ขั้นแรก จำไว้ว่า quantum gates เป็น reversible เราไม่สามารถเขียนทับ inputs ได้ แต่เราแนะนำ helper Qubits สองตัวที่เริ่มต้นที่ $\vert 0\rangle$ เพื่อเก็บ sum และ carry outputs ดังนั้น สถานะควอนตัมทั้งหมดจะประกอบด้วย Qubits $A$ และ $B$ และ sum และ carry Qubits ซึ่งเราจะเรียกว่า $S$ และ $C$:

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

ตอนนี้ เราต้องการ quantum gates ที่ทำสิ่งที่ XOR และ AND gates ทำในวงจรคลาสสิก

Sum:

สำหรับ XOR เราใช้ CNOT สองตัว โดยมี Qubits control $A$ และ $B$ และ target Qubit $S$ สำหรับทั้งคู่ ถ้า $A$ และ $B$ ต่างกัน หนึ่งใน CNOT gates จะพลิก $S$ ไปเป็นสถานะ $\vert 1\rangle$ ถ้า $A$ และ $B$ ทั้งคู่เป็น $\vert 0\rangle$ ไม่มีอะไรเกิดขึ้นกับ $S$ และมันยังอยู่ในสถานะ $\vert 0\rangle$ ถ้า $A$ และ $B$ ทั้งคู่เป็น $\vert 1\rangle$ สถานะของ $S$ จะพลิกสองครั้งทำให้กลับสู่สถานะ $\vert 0\rangle$

Carry:

สำหรับ carry bit เราต้องการบางอย่างที่ทำงานเหมือน classical AND gate

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

ดู gates ที่เราพูดถึงอีกครั้งเพื่อดูว่าคุณเดาได้ไหมว่า quantum gate ไหนที่เราจะใช้แทน classical AND gate:

เฉลย:

มันคือ Toffoli gate! จำไว้ว่า Toffoli หรือ controlled-controlled-NOT gate พลิกสถานะ target เมื่อ control qubit 0 AND control qubit 1 ทั้งคู่เป็น $\vert 1\rangle$ เท่านั้น ดังนั้น ถ้า target qubit เริ่มในสถานะ $\vert 0\rangle$ มันก็มีการทำงานเหมือน AND gate

ดังนั้น ตอนนี้เรามีส่วนประกอบทั้งหมดที่ต้องการสำหรับสร้าง quantum circuit:

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

ข้างบนคือแผนภาพ Circuit สำหรับ quantum half-adder circuit ดังที่กล่าวไว้ก่อนหน้า สายไฟแทน Qubits $0$ ถึง $3$ เรียงจากบนลงล่าง และ classical bit register คือสายไฟสองเส้นล่างสุด จากนั้น อ่านจากซ้ายไปขวา เราเห็นว่า gates ถูกใช้กับแต่ละ Qubit อย่างไรโดยดูว่ากล่องปรากฏที่ไหนบนสายไฟที่สอดคล้องกัน สุดท้าย measurements แสดงอยู่ที่ปลาย Measurements ยุบสถานะ Qubit เป็นค่า $0$ หรือ $1$ ที่ชัดเจน และผลลัพธ์ถูกส่งไปยัง classical register

ความละเอียดอ่อนหนึ่งอย่าง: แม้ว่าแผนภาพ Circuit จะวาดจากซ้ายไปขวา แต่เมื่อเขียน matrix expression ที่สอดคล้องกัน เราต้องอ่านจากขวาไปซ้าย เนื่องจากในการคูณเมทริกซ์ operator ที่ใกล้กับ state vector ที่สุดจะทำงานก่อน ดังนั้น ตัวอย่างเช่น Circuit ข้างต้น (ไม่รวม measurements) จะเขียนเป็น:

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

ต่อไป เราต้องปรับแต่ง Circuit เพื่อรันบน quantum hardware การปรับแต่งนี้ทำผ่าน Transpiler ซึ่งแปล Circuit นามธรรมข้างต้นเป็นคำสั่งที่คอมพิวเตอร์ควอนตัมจะเข้าใจ มันกำหนด logical Qubits ข้างต้นให้กับ physical Qubits จริงบนโปรเซสเซอร์และเขียน gates ใหม่ในเทอมของ native gates ของมันเองที่ถูกปรับให้รันบนคอมพิวเตอร์ควอนตัม สุดท้าย Transpiler ยังใช้สิ่งที่เรียกว่า "error suppression and mitigation" เพื่อลดผลกระทบของ errors บนผลลัพธ์ สิ่งนี้ไม่สำคัญมากสำหรับ Circuit ที่เรียบง่ายของเรา แต่ถ้าคุณดำเนินต่อในเส้นทางการประมวลผลเชิงควอนตัมเพื่อรัน circuits ที่ซับซ้อนกว่า คุณจะเห็นคุณค่าของ error suppression and mitigation ในไม่ช้า ถ้าต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งนี้ ดูหลักสูตรของ Olivia Lane, Quantum Computing in Practice

ขั้นแรก เราโหลดแพ็คเกจที่จำเป็นสำหรับสื่อสารกับคอมพิวเตอร์ควอนตัม IBM® และเลือก Backend เพื่อรัน เราสามารถเลือก Backend ที่ไม่ยุ่งที่สุด หรือเลือก Backend เฉพาะที่เรารู้คุณสมบัติ

มีโค้ดด้านล่างสำหรับบันทึก credentials เมื่อใช้ครั้งแรก ลบข้อมูลนี้ออกจาก notebook หลังจากบันทึกในสภาพแวดล้อมของคุณแล้ว เพื่อไม่ให้ credentials ของคุณถูกแชร์โดยไม่ตั้งใจเมื่อคุณแชร์ notebook ดู ตั้งค่าบัญชี IBM Cloud และ เริ่มต้น service ในสภาพแวดล้อมที่ไม่น่าเชื่อถือ สำหรับคำแนะนำเพิ่มเติม

# 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

ตอนนี้ เราใช้ Transpiler เพื่อปรับแต่ง Circuit เราสามารถเลือก optimization level จาก 0 (ไม่ปรับแต่ง) ถึง 3 (ปรับแต่งสูงสุด) เพื่อดูว่าแต่ละ level ครอบคลุมอะไร เยี่ยมชมคู่มือ ตั้ง transpiler optimization level Circuit ที่ได้จะดูแตกต่างอย่างมากจาก logical circuit ที่เราสร้างในขั้นตอน mapping

# 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" คือ primitive ที่ออกแบบมาเพื่อสุ่มตัวอย่างสถานะที่เป็นไปได้จาก quantum circuit และรวบรวมสถิติว่าสถานะใดอาจถูกวัดและด้วยความน่าจะเป็นเท่าใด เรา import Qiskit Runtime Sampler ที่นี่:

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

sampler = Sampler(mode=backend)

ถ้าคุณใช้เวลาที่จัดสรรไว้บนคอมพิวเตอร์ควอนตัมจริงหมดแล้ว หรือไม่มีการเชื่อมต่ออินเทอร์เน็ต คุณอาจต้องการใช้ simulator ทำเช่นนี้โดยรัน cell ด้านล่างและ uncomment บรรทัดที่เกี่ยวข้องในขั้นตอน "Execute"

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

หลังจากเตรียม Circuit แล้ว เราสามารถรันบนคอมพิวเตอร์ควอนตัมได้!

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. Post-processing

ตอนนี้เราพร้อมดูผลลัพธ์แล้ว! เราจะแสดง histogram ของ 100 ตัวอย่างจาก Circuit

from qiskit.visualization import plot_histogram

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

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

histogram ข้างต้นแสดงผลลัพธ์การวัดของ Qubits ทั้งสี่ตัวที่ปลาย Circuit คอมพิวเตอร์ควอนตัมที่สมบูรณ์แบบไม่มี noise จะวัด Qubits ให้มีค่าเดียวกันทุกครั้ง แต่ในความเป็นจริง noise จะทำให้บางครั้งเกิด errors

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

ใช้ bitstring ที่มีจำนวนนับมากที่สุดเป็นค่าของ $A$, $B$, $S$ และ $C$ ตรวจสอบว่า quantum adder circuit ทำงานได้ถูกต้อง

เฉลย:

เราต้องตรวจสอบว่า $A+B = S+2 \times C$ จำไว้ว่าลำดับ bitstring ใช้ little-endian notation ดังนั้นอ่านเป็น CSBA

จาก histogram ข้างต้น เราเห็นว่า bitstring 0000 เป็นตัวที่โดดเด่น

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

ไปแก้ค่าของ $A$ และ $B$ เป็น $A=1$ และ $B=1$ แล้วทำขั้นตอน Qiskit patterns อีกครั้งเพื่อรัน Circuit ใหม่ ตรวจสอบว่า adder circuit ทำงานได้ถูกต้องอีกครั้ง

เฉลย:

คุณควรได้ histogram ที่มี bitstring โดดเด่นเป็น 1011:

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

หนึ่งในคุณสมบัติเพิ่มเติมของ quantum half-adder เหนือ classical half-adder คือมันสามารถรันด้วย quantum inputs ได้ กล่าวคือ มันสามารถ "บวก" Qubits $A$ และ $B$ แม้ว่าจะอยู่ในสถานะ superposition ในส่วนคำถาม Challenge ด้านล่าง คุณจะถูกขอให้เตรียม Qubits ใน superpositions และดูว่าเกิดอะไรขึ้น!

สรุป

โมดูลนี้ออกแบบมาเพื่อให้คุณมีความเข้าใจพื้นฐานที่มั่นคงของหลักการพื้นฐานเบื้องหลังการประมวลผลเชิงควอนตัมโดยเปรียบเทียบกับการประมวลผลแบบคลาสสิก เราดู classical half-adder circuit และแสดงวิธีปรับ Circuit เพื่อรันกับ Qubits บนคอมพิวเตอร์ควอนตัม ตอนนี้คุณพร้อมสำรวจโมดูล Qiskit in the Classroom อื่นๆ แล้ว!

แนวคิดสำคัญ:

• ตรงข้ามกับ classical bits ที่สามารถรับเฉพาะค่า 0 และ 1 Qubits ยังสามารถอยู่ใน superposition ของทั้ง 0 และ 1
• หลาย Qubits สามารถอยู่ใน superposition เหนือ bitstrings ที่ยอมรับในเชิงคลาสสิกที่เรียกว่า computational basis states
• หลาย Qubits สามารถ entangle กันได้ ทำให้สถานะของหนึ่งขึ้นอยู่กับสถานะของอีกตัว
• ธรรมเนียมของ Qiskit คือใช้ little-endian notation ซึ่งวาง Qubit ที่มีนัยสำคัญน้อยที่สุด $q_0$ ในตำแหน่งขวาสุดและ Qubit ที่มีนัยสำคัญมากที่สุด $q_N$ ซ้ายสุด
• Quantum gates คือการดำเนินการ reversible ที่แทนด้วยเมทริกซ์ unitary ซึ่งทำงานบน state vectors เชิงควอนตัม ในสัญกรณ์นี้ เมทริกซ์ที่ใกล้กับเวกเตอร์ที่สุด (อยู่ขวาสุด) ทำงานก่อน
• Measurements ยุบสถานะ superposition เชิงควอนตัมเป็นหนึ่งในสถานะที่ยอมรับในเชิงคลาสสิก ด้วยความน่าจะเป็นเท่ากับกำลังสองของ amplitude ของ computational basis state ที่สอดคล้องกันใน superposition
• วงจรควอนตัมมักแทนด้วย quantum circuit diagrams ที่ Qubits แสดงเป็นสายไฟแนวนอน และ quantum gates ปรากฏตามสายไฟเหล่านี้จากซ้ายไปขวา
• เพื่อรัน quantum circuit เราใช้สี่ขั้นตอนใน workflow Qiskit patterns: Map, Optimize, Execute, Post-process

คำถาม

คำถามจริง/เท็จ

1. bit เดียวในคอมพิวเตอร์แบบคลาสสิกสามารถเก็บค่าได้เพียง 0 หรือ 1 เท่านั้น

2. Entanglement หมายความว่าสถานะของ Qubit หนึ่งเป็นอิสระจากสถานะของอีกตัว

3. Quantum gates เป็นการดำเนินการที่โดยทั่วไป irreversible

4. ธรรมเนียมของ Qiskit วาง Qubit ที่มีนัยสำคัญน้อยที่สุด $q_0$ ในตำแหน่งซ้ายสุด

5. การวัดสถานะควอนตัมให้ผลลัพธ์เดียวกันเสมอถ้าทำซ้ำหลายครั้ง

6. Hadamard gate สร้าง superposition ใน Qubit เดียว

7. วงจรควอนตัมอาจรวม measurement operations ที่ยุบสถานะ superposition เป็นหนึ่งในสถานะที่ยอมรับในเชิงคลาสสิก

8. จำนวนสถานะคลาสสิกที่เป็นไปได้สำหรับ $N$ bits คือ $2N$

9. ความน่าจะเป็นของผลลัพธ์การวัดเชิงควอนตัมได้จาก amplitudes ยกกำลังสองของ basis states ที่วัดได้ในเชิงคลาสสิก

คำถามตอบสั้น

1. ความแตกต่างหลักระหว่าง bit และ Qubit มีอะไรบ้าง?

2. เกิดอะไรขึ้นกับสถานะควอนตัมเมื่อถูกวัด?

3. ทำไมเราใช้ little-endian notation ใน Qiskit?

4. สี่ขั้นตอนใน Qiskit patterns workflow มีอะไรบ้าง?

คำถาม Challenge:

1. ในโมดูลนี้ เราใช้ adder เพื่อบวก classically allowed states ของ $A$ และ $B$ เท่านั้น แต่เราสามารถเตรียม $A$ และ $B$ ใน superpositions ได้ด้วย! แก้โค้ดเพื่อเตรียมแต่ละ Qubit ใน superposition เท่ากันของ 0 และ 1 แล้วรัน circuit ใหม่และรับ histogram ใหม่ คุณเห็นอะไร? อธิบายว่าเกิดอะไรขึ้น

2. Toffoli gate decomposition ใช้ decompose() เพื่อแสดงวิธีที่ Toffoli gate ถูกแตกย่อยเป็น single- และ two-qubit gates แล้วตรวจสอบการสร้างนี้ด้วยการคูณเมทริกซ์ จำไว้ว่าแม้ว่าแผนภาพ circuit จะอ่านจากซ้ายไปขวา เมทริกซ์จะถูกใช้กับสถานะควอนตัมจากขวาไปซ้าย!