Quantum teleportation

โมดูล 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 เพื่อรันงานบนคอมพิวเตอร์ควอนตัมจริง นักเรียนต้องสร้างบัญชี IBM Quantum® โดยทำตามขั้นตอนในคู่มือ ตั้งค่าบัญชี IBM Cloud

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

# Added by doQumentation — required packages for this notebook
!pip install -q numpy 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'

ดู walkthrough ของโมดูลโดย Dr. Katie McCormick ด้านล่าง หรือคลิก ที่นี่ เพื่อดูบน YouTube

---

บทนำและพื้นหลัง

Quantum teleportation เป็นเทคนิคในฟิสิกส์ควอนตัมที่ช่วยให้ถ่ายโอนข้อมูลควอนตัมจากที่หนึ่งไปยังอีกที่หนึ่งโดยไม่ต้องเคลื่อนย้ายอนุภาคทางกายภาพ ต่างจากแนวคิด teleportation ในนิยายวิทยาศาสตร์ กระบวนการนี้ไม่เกี่ยวข้องกับการขนส่งสสาร แต่อาศัยหลักการของ quantum entanglement ซึ่งอนุภาคสองตัวจะเชื่อมต่อกันโดยไม่คำนึงถึงระยะทาง ผ่านชุดการวัดและการสื่อสารแบบคลาสสิกที่แม่นยำ สถานะควอนตัมของอนุภาคหนึ่งสามารถสร้างขึ้นใหม่ในอนุภาคอีกตัวที่ตำแหน่งห่างไกล ซึ่งเป็นการ "teleport" ข้อมูลควอนตัมโดยพฤตินัย ในโมดูลนี้ เราจะดูว่าสิ่งนี้ทำงานอย่างไรทางคณิตศาสตร์ และจากนั้นเราจะนำ quantum teleportation ไปใช้บนคอมพิวเตอร์ควอนตัมจริง บทนำที่นี่จะกระชับ สำหรับข้อมูลพื้นหลังเพิ่มเติมเกี่ยวกับข้อมูลควอนตัม และคำอธิบายเพิ่มเติมเกี่ยวกับ teleportation เราแนะนำหลักสูตรของ John Watrous เกี่ยวกับ พื้นฐานของข้อมูลควอนตัม และโดยเฉพาะส่วนเกี่ยวกับ Teleportation

บิตคลาสสิกสามารถอยู่ในสถานะ 0 หรือ 1 ได้ Quantum bits (Qubit) สามารถอยู่ในสถานะควอนตัมที่แทนด้วย $|0\rangle$ และ $|1\rangle$ และยังเป็นการรวมเชิงเส้นของสถานะเหล่านี้ที่เรียกว่า "ซูเปอร์โพสิชัน" เช่น $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$ โดยที่ $\alpha_0,\alpha_1 \in \mathbb{C},$ และ $|\alpha_0|^2+|\alpha_1|^2 = 1$ แม้ว่าสถานะสามารถอยู่ในซูเปอร์โพสิชันนี้ได้ การวัดสถานะจะ "คอลแลปส์" มันไปเป็นสถานะ $|0\rangle$ หรือ $|1\rangle$ พารามิเตอร์ $a$ และ $b$ เกี่ยวข้องกับความน่าจะเป็นของแต่ละผลการวัดตาม

$$P_0 = |\alpha_0|^2$$ $$P_1 = |\alpha_1|^2$$

ดังนั้นข้อจำกัดที่ว่า $|\alpha_0|^2+|\alpha_1|^2 = 1$

คุณสมบัติสำคัญอีกอย่างคือ Qubit สามารถ "entangled" ได้ ซึ่งหมายความว่าการวัด Qubit ตัวหนึ่งสามารถส่งผลต่อผลลัพธ์การวัดของ Qubit ที่ entangled ตัวอื่นได้ การทำความเข้าใจว่า entanglement แตกต่างจาก classical correlations ธรรมดาอย่างไรนั้นค่อนข้างยุ่งยาก มาอธิบายสัญลักษณ์ของเราก่อน เรียก Qubit สองตัวที่เป็นของเพื่อน 0 (Alice) และเพื่อน 1 (Bob) และแต่ละตัวอยู่ในสถานะ $|0\rangle$

$$|0\rangle_B|0\rangle_A$$

หรือ

$$|0\rangle_1|0\rangle_0$$

บางครั้งย่อเป็น

$$|00\rangle$$

สังเกตว่า Qubit ที่มีหมายเลข (หรือตัวอักษร) ต่ำที่สุดอยู่ทางขวาสุด นี่คือ convention ที่เรียกว่าสัญลักษณ์ "little-endian" ที่ใช้ตลอดทั้ง Qiskit หากสถานะสอง Qubit ของเพื่อนทั้งคู่คือ $|00\rangle$ และพวกเขาวัดสถานะของ Qubit ของตัวเอง พวกเขาแต่ละคนจะพบ 0 ในทำนองเดียวกันหาก Qubit อยู่ในสถานะ $|11\rangle$ การวัดแต่ละครั้งจะได้ 1 สิ่งนั้นไม่ต่างจากกรณีคลาสสิก อย่างไรก็ตาม ในการประมวลผลเชิงควอนตัม เราสามารถรวมสิ่งนี้กับซูเปอร์โพสิชันเพื่อได้สถานะเช่น

$$\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$

ในสถานะเช่นนี้ ยังไม่ทราบ ยังไม่ถูกกำหนดโดยธรรมชาติว่า Alice และ Bob มี Qubit ในสถานะ 0 หรือ 1 และยังคงทราบว่าพวกเขาจะวัดสถานะเดียวกันสำหรับ Qubit ของตัวเอง ตัวอย่างเช่น หาก Bob วัด Qubit ของตัวเองว่าอยู่ในสถานะ $|0\rangle$ วิธีเดียวที่เกิดขึ้นได้คือการวัดได้คอลแลปส์สถานะสอง Qubit ไปยังหนึ่งในสองสถานะที่เป็นไปได้ โดยเฉพาะไปยัง $|00\rangle$ ซึ่งทำให้ Qubit ของ Alice อยู่ในสถานะ $|0\rangle$ ด้วย

Qubit ที่ entangled กันในลักษณะนี้ไม่ต้องการให้ Qubit อยู่ใกล้กันทางกายภาพ กล่าวอีกนัยคือ เราสามารถ entangle Qubit แล้วแยกพวกมันออกระยะทางไกล และใช้ entanglement ของพวกมันเพื่อส่งข้อมูลได้ สถานะที่ entangled เช่นข้างต้นเป็นหน่วยพื้นฐานของ entanglement และบางครั้งเรียกว่า "e-bit" ซึ่งเป็น entanglement หนึ่งบิต e-bit เหล่านี้สามารถถือเป็นทรัพยากรในการสื่อสารเชิงควอนตัม เนื่องจาก e-bit แต่ละตัวที่แบ่งปันระหว่างพาร์ทเนอร์ที่อยู่ห่างไกลสามารถใช้ได้ ตามที่เราอธิบายที่นี่ เพื่อย้ายข้อมูลจากที่หนึ่งไปยังอีกที่หนึ่ง

ความคิดแรกของหลายคนที่เรียนรู้เรื่องนี้เป็นครั้งแรกคือเรื่องการละเมิด relativity: เราสามารถใช้สิ่งนี้ส่งข้อมูลเร็วกว่าแสงได้หรือไม่? โดยทุกวิถีทาง ยังคงตั้งคำถามและตรวจสอบกฎทางวิทยาศาสตร์ต่อไป แต่น่าเสียดายที่สิ่งนี้ไม่อนุญาตให้เราส่งข้อมูลเร็วกว่าแสง ด้วยเหตุผลที่จะชัดเจนขึ้นตลอดโมดูลนี้ Spoiler: น่าประหลาดใจที่ไม่ใช่เพราะความเร็วที่ "collapse" นี้เผยแพร่ ซึ่งดูเหมือนจะเกิดขึ้นเร็วกว่าแสง [1]

เราเริ่มต้นด้วยผู้ทำงานร่วมกันสองคนคือ Alice และ Bob ซึ่งในตอนแรกอยู่ในที่เดียวกันและสามารถทำงานร่วมกันบน Qubit เดียวกันได้ ผู้ทำงานร่วมกันเหล่านี้จะ entangle Qubit ของพวกเขา จากนั้นพวกเขาจะย้ายออกไปยังสองตำแหน่งทางภูมิศาสตร์ที่ต่างกัน นำ Qubit ที่เกี่ยวข้องไปด้วย Alice จะได้รับข้อมูลควอนตัมบน Qubit ใหม่ Q เราไม่ได้สมมติเกี่ยวกับข้อมูลบน Q สถานะของ Q อาจเป็นความลับที่ Alice ไม่รู้ มันอาจไม่รู้จากทุกคน แต่ Alice ได้รับมอบหมายให้ถ่ายโอนข้อมูลบน Q ให้กับ Bob เธอจะทำสิ่งนี้โดยใช้ quantum teleportation

เพื่อทำสิ่งนี้ เราจะต้องรู้จักการดำเนินการควอนตัมบางอย่างหรือ "gate"

Quantum operators (Gate)

สามารถข้ามส่วนนี้ได้หากคุณคุ้นเคยกับ quantum gate แล้ว หากต้องการเข้าใจ Gate เหล่านี้ดีขึ้น ดู พื้นฐานของข้อมูลควอนตัม โดยเฉพาะสองบทแรกเกี่ยวกับ IBM Quantum Learning

สำหรับ teleportation protocol นี้เราจะใช้ quantum gate สองประเภทหลัก: Hadamard Gate และ CNOT Gate อีกไม่กี่ตัวจะมีบทบาทรอง: $X$ Gate, $Z$ Gate และ SWAP Gate

โมดูลนี้สามารถทำให้เสร็จได้ด้วยพื้นฐาน linear algebra ที่จำกัดมาก แต่บางครั้งการแสดงภาพ Gate กลศาสตร์ควอนตัมโดยใช้เมทริกซ์และ vector อาจเป็นประโยชน์ ดังนั้นเราจึงนำเสนอรูปแบบเมทริกซ์/vector ของ Gate/สถานะควอนตัมที่นี่ด้วย

สถานะที่เราเพิ่งนำเสนอถูกเลือก (ส่วนหนึ่งตาม convention และส่วนหนึ่งตามข้อจำกัด) ให้มีรูปแบบ vector:

$$|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$$ $$|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$$

ในลักษณะนี้ สถานะตามต้องการ $|\psi\rangle = a|0\rangle+b|1\rangle$ สามารถเขียนเป็น

$$|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$$

มีทางเลือกในการขยายสัญลักษณ์ไปยังสถานะ Qubit หลายตัว แต่ทางเลือกด้านล่างค่อนข้างเป็นมาตรฐาน:

$$|00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix},|01\rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, |10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\0\end{pmatrix},|11\rangle = \begin{pmatrix}0 \\ 0 \\ 0 \\ 1\end{pmatrix}.$$

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

H Hadamard Gate: สร้างสถานะซูเปอร์โพสิชัน Gate สำหรับ Qubit เดี่ยว

$$H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right),$$ $$H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|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")

CNOT Controlled-NOT Gate: Gate นี้ใช้ Qubit สองตัว: control และ target ตรวจสอบสถานะของ control qubit ซึ่งไม่ถูกเปลี่ยนแปลง แต่ถ้า control qubit อยู่ในสถานะ $|1\rangle$ Gate จะเปลี่ยนสถานะของ target qubit ถ้าสถานะของ control qubit คือ $|0\rangle$ จะไม่มีการเปลี่ยนแปลงใดๆ ในสัญลักษณ์ด้านล่าง ถือว่า Qubit $A$ (Qubit ทางขวาสุด) เป็น control และ Qubit $B$ (Qubit ทางซ้ายสุด) เป็น target ด้านล่าง สัญลักษณ์ที่ใช้คือ $CNOT(q_{control},q_{target})|BA\rangle$

$$CNOT(A,B)|00\rangle = |00\rangle, \\ CNOT(A,B)|01\rangle = |11\rangle, \\ CNOT(A,B)|10\rangle = |10\rangle, \\ CNOT(A,B)|11\rangle = |01\rangle$$

คุณอาจเห็น CNOT เขียนด้วยลำดับของ control และ target ที่เข้าใจกันโดยปริยาย แต่ไม่มีความคลุมเครือดังกล่าวในโค้ดหรือแผนภาพ Circuit

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

CNOT gate มีลักษณะค่อนข้างต่างกันใน Circuit เนื่องจากต้องใช้สอง Qubit วิธีนำไปใช้มีดังนี้:

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

ทดสอบความเข้าใจ

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

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

คำตอบ:

$CNOT|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} = |11\rangle$

$X$ Gate: เทียบเท่ากับการดำเนินการ NOT Gate สำหรับ Qubit เดี่ยว

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

ใน Qiskit การสร้าง Circuit ที่มี $X$ Gate มีลักษณะดังนี้:

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

$Z$ Gate: เพิ่ม "เฟส" ให้กับสถานะ (ตัวคูณนำหน้า ซึ่งในกรณีของ Z eigenstates $|0\rangle$ และ $|1\rangle$ จะเป็น 1 หรือ -1 ตามลำดับ) Gate สำหรับ Qubit เดี่ยว

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

ใน Qiskit การสร้าง Circuit ที่มี $Z$ Gate มีลักษณะดังนี้:

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

ทฤษฎี

มาวางรูปแบบ protocol สำหรับ quantum teleportation โดยใช้คณิตศาสตร์ จากนั้นในส่วนถัดไป เราจะนำการตั้งค่านี้มาสร้างโดยใช้คอมพิวเตอร์ควอนตัม

Alice และ Bob entangle Qubit ของพวกเขา: ในตอนแรก Qubit ของ Alice และ Qubit ของ Bob แต่ละตัวแยกกันอยู่ในสถานะ $|0\rangle$ (สมมติฐานที่ดีและการกำหนดค่าเริ่มต้นที่ถูกต้องสำหรับคอมพิวเตอร์ควอนตัม IBM®) เราสามารถเขียนสิ่งนี้เป็น $|0\rangle_B|0\rangle_A$ หรือเพียง $|00\rangle$ มาคำนวณว่าเกิดอะไรขึ้นเมื่อ Alice และ Bob กระทำด้วย Hadamard Gate บน Qubit ของ Alice และจากนั้น CNOT Gate โดยมี Qubit ของ Alice เป็น control และของ Bob เป็น target:

$$\begin{aligned} CNOT(A,B)H_A |0\rangle_B|0\rangle_A &= CNOT(A,B)|0\rangle_B\frac{1}{\sqrt{2}}\left(|0\rangle_A+|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(CNOT(A,B)|0\rangle_B|0\rangle_A+CNOT(A,B)|0\rangle_B|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right) \end{aligned}$$

สังเกตว่าตอนนี้ Qubit ของ Alice และ Bob entangled กัน แม้ว่าธรรมชาติยังไม่ได้กำหนดว่า Qubit ทั้งคู่อยู่ในสถานะ $|0\rangle$ หรือ $|1\rangle$ แต่ทราบว่า Qubit ของพวกเขาอยู่ในสถานะเดียวกัน

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

Q ถูกนำเข้า: สถานะลับถูกเตรียมบน Qubit Q:

$$|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q$$

ณ จุดนี้ Q อยู่ติดกับ Qubit ของ Alice (A) เพียงแค่นั้น ไม่มี entanglement ดังนั้นสถานะควอนตัมของสาม Qubit รวมกันสามารถเขียนเป็น:

$$|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).$$

เป้าหมายคือการย้ายข้อมูลบน Q จากตำแหน่งของ Alice ไปยังตำแหน่งของ Bob ณ จุดนี้ เราไม่ได้อ้างสิทธิ์หรือความต้องการใดๆ เกี่ยวกับความลับหรือความเร็วของการถ่ายโอนข้อมูล เราแค่สำรวจว่าข้อมูลสามารถเคลื่อนจาก Alice ไปยัง Bob ได้อย่างไร

เนื่องจากข้อมูลเริ่มต้นบน Q เราจะสมมติว่า Q ถูกกำหนดหมายเลข Qubit ต่ำที่สุด ดังนั้นสัญลักษณ์ little endian ทำให้ Q เป็น Qubit ทางขวาสุดในคณิตศาสตร์ด้านล่าง

Alice entangle Qubit A และ Q: ตอนนี้ Alice ดำเนินการด้วย CNOT Gate โดยมี Qubit ของตัวเองเป็น control และ Q เป็น target จากนั้นนำ Hadamard Gate ไปใช้กับ Q มาคำนวณสถานะสาม Qubit หลังจากการดำเนินการนั้น:

$$\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}$$

เนื่องจาก A และ Q อยู่ในตำแหน่งเดียวกัน มาจัดกลุ่มเทอมด้านบนตามผลลัพธ์การวัดบน Qubit A และ Q:

$$\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}$$

ทดสอบความเข้าใจ

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

จากนิพจน์ด้านบนสำหรับสถานะของสาม Qubit ทั้งหมด ความน่าจะเป็นที่การวัด Qubit A และ Q จะได้ $|0\rangle_A|0\rangle_Q$ คือเท่าใด?

คำตอบ:

25% เพื่อเห็นสิ่งนี้ จำว่าสถานะของ Bob ต้องถูก normalize ดังนั้น $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

ตอนนี้ Alice สามารถวัด Qubit A และ Q เธอไม่สามารถควบคุมผลลัพธ์ของการวัดนั้นได้ เนื่องจากการวัดควอนตัมมีความน่าจะเป็น ดังนั้นเมื่อเธอวัด จะมีผลลัพธ์ที่เป็นไปได้ 4 แบบ และทั้ง 4 แบบมีความน่าจะเป็นเท่ากัน: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q,$ และ $|1\rangle_A|1\rangle_Q$ สังเกตว่าแต่ละผลลัพธ์มีผลต่าง Qubit ของ Bob แตกต่างกัน ตัวอย่างเช่น ถ้า Alice พบว่า Qubit ของเธออยู่ใน $|0\rangle_A|0\rangle_Q,$ นั่นได้คอลแลปส์สถานะสาม Qubit ทั้งหมดไปยัง $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q$ ผลลัพธ์การวัดอื่นๆ ของ Alice ให้สถานะต่างกันสำหรับ Bob สถานะเหล่านี้ถูกรวบรวมในตารางด้านล่าง

ผลลัพธ์ของ Alice	สถานะของ Bob	คำสั่งถึง Bob	ผลลัพธ์
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	ไม่มี	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ แล้ว $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$

สำหรับผลลัพธ์การวัดที่เป็นไปได้ทั้งหมดบน Qubit ของ Alice Qubit ของ Bob จะอยู่ในสถานะที่คล้ายกับสถานะลับที่เดิมอยู่บน Q ในกรณีที่ Alice วัด $|0\rangle_C|0\rangle_A$ (แถวแรกของตาราง) Qubit ของ Bob อยู่ในสถานะลับพอดี! ในกรณีอื่นๆ มีบางอย่างผิดปกติเกี่ยวกับสถานะ สัมประสิทธิ์ ($\alpha$) สลับกัน หรือมีเครื่องหมาย "-" ที่ควรเป็น "+" หรือทั้งสองอย่าง เพื่อปรับ Qubit ของ Bob ให้เท่ากับสถานะลับพอดี Alice ต้องโทรหา Bob (ใช้วิธีการสื่อสารแบบคลาสสิก) และบอก Bob ให้ทำการดำเนินการเพิ่มเติมบน Qubit ของเขา ตามที่ระบุในตาราง ตัวอย่างเช่น ในแถวที่สาม สัมประสิทธิ์ถูกสลับ ถ้า Alice โทรหา Bob และบอกให้เขานำ $X$ gate ไปใช้กับ Qubit ของเขา มันจะเปลี่ยน $|0\rangle$ เป็น $|1\rangle$ และในทางกลับกัน และสถานะลับก็ออกมา

ตอนนี้ควรชัดเจนแล้วว่าทำไมเราจึงไม่สามารถใช้การตั้งค่านี้ส่งข้อมูลเร็วกว่าแสงได้ เราอาจโชคดีและวัด $|0\rangle_A|0\rangle_Q,$ หมายความว่า Bob มีสถานะลับพอดีทันที แต่ Bob ไม่รู้จนกว่าเราจะโทรหาเขาและบอกว่า "เราวัด $|0\rangle_A|0\rangle_Q$ ดังนั้นคุณไม่ต้องทำอะไร"

ในการทดลองทางความคิด Qubit มักแยกออกทางกายภาพและนำไปยังสถานที่ใหม่ คอมพิวเตอร์ควอนตัม IBM® ใช้ solid-state Qubit บนชิปที่ไม่สามารถแยกออกได้ ดังนั้นแทนที่จะย้าย Alice และ Bob ไปยังตำแหน่งต่างกัน เราจะแยกข้อมูลบนชิปเองโดยใช้สิ่งที่เรียกว่า "swap gate" เพื่อย้ายข้อมูลจาก Qubit หนึ่งไปยังอีก Qubit

การทดลองที่ 1: Teleportation พื้นฐาน

IBM Quantum แนะนำให้จัดการปัญหาการประมวลผลเชิงควอนตัมโดยใช้กรอบการทำงานที่เราเรียกว่า "Qiskit patterns" ประกอบด้วยขั้นตอนดังต่อไปนี้:

• ขั้นตอนที่ 1: แมปปัญหาของคุณไปยัง Circuit ควอนตัม
• ขั้นตอนที่ 2: ปรับแต่ง Circuit สำหรับการรันบน hardware ควอนตัมจริง
• ขั้นตอนที่ 3: รันงานบนคอมพิวเตอร์ควอนตัม IBM โดยใช้ Runtime Primitives
• ขั้นตอนที่ 4: ประมวลผลผลลัพธ์

ขั้นตอนที่ 1: แมปปัญหาของคุณไปยัง Circuit ควอนตัม

คณิตศาสตร์ทั้งหมดที่เราทำด้านบนเป็นการอธิบายขั้นตอนที่ 1 ตอนนี้เราจะนำไปใช้งาน สร้าง Circuit ควอนตัมโดยใช้ Qiskit! เราเริ่มสร้าง Circuit ควอนตัมที่มีสาม Qubit และ entangle Qubit สองตัวของ Alice และ Bob เราจะให้ Qubit เหล่านี้เป็น Qubit 1 และ 2 และสงวน Qubit 0 ไว้สำหรับสถานะลับ

# Step 1: Map your problem to a quantum circuit

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np

# Define registers
secret = QuantumRegister(1, "Q")
Alice = QuantumRegister(1, "A")
Bob = QuantumRegister(1, "B")

cr = ClassicalRegister(3, "c")

qc = QuantumCircuit(secret, Alice, Bob, cr)

# We entangle Alice's and Bob's qubits as in our work above. We apply a Hadamard gate and then a CNOT gate.
# Note that the second argument in the CNOT gate is the target.
qc.h(Alice)
qc.cx(Alice, Bob)

# Inserting a barrier changes nothing about the logic. It just allows us to force gates to be positioned in "layers".
qc.barrier()

# Now we will use random variables to create the secret state. Don't worry about the "u" gate and the details.
np.random.seed(42)  # fixing seed for repeatability
theta = np.random.uniform(0.0, 1.0) * np.pi  # from 0 to pi
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q
qc.u(theta, varphi, 0.0, secret)
qc.barrier()

# Now entangle Q and Alice's qubits as in the discussion above.
qc.cx(secret, Alice)
qc.h(secret)
qc.barrier()

# Now Alice measures her qubits, and stores the outcomes in the "classical registers" cr[]
qc.measure(Alice, cr[1])
qc.measure(secret, cr[0])

# Now we insert some conditional logic. If Alice measures Q in a "1" we need a Z gate, and if Alice measures A in a "1" we need an X gate (see the table).
with qc.if_test((cr[1], 1)):
    qc.x(Bob)
with qc.if_test((cr[0], 1)):
    qc.z(Bob)

qc.draw(output="mpl")

นั่นคือทั้งหมดที่เราต้องทำเพื่อ teleport สถานะของ Alice ไปยัง Bob อย่างไรก็ตาม จำไว้ว่าเมื่อเราวัดสถานะควอนตัม $\alpha_0 |0\rangle+\alpha_1|1\rangle$ เราจะพบ $|0\rangle$ หรือ $|1\rangle$ ดังนั้นในตอนท้ายของทั้งหมดนี้ Bob มีสถานะลับของ Alice อย่างแน่นอน แต่เราไม่สามารถยืนยันสิ่งนี้ได้ง่ายๆ ด้วยการวัด เพื่อให้การวัดบอกเราว่าทำสิ่งนี้ถูกต้อง เราต้องทำเทคนิคหนึ่ง เรามีตัวดำเนินการที่มีชื่อว่า "U" สำหรับ "unitary" ที่เราใช้เตรียมสถานะลับของ Alice เราสามารถนำ inverse ของ U ไปใช้ตอนท้ายของ Circuit ถ้า U แมปสถานะ $|0\rangle$ ของ Alice ไปยัง $\alpha_0 |0\rangle+\alpha_1|1\rangle$ inverse ของ U จะแมป $\alpha_0 |0\rangle+\alpha_1|1\rangle$ ของ Bob กลับไปยัง $|0\rangle$ ดังนั้นส่วนสุดท้ายนี้จะไม่จำเป็นหากเป้าหมายเพียงแค่ย้ายข้อมูลควอนตัม สิ่งนี้ทำเพื่อให้เราตรวจสอบตัวเองเท่านั้น

# Add the inverse of U and measure Bob's qubit.
qc.barrier()

qc.u(theta, varphi, 0.0, Bob).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(Bob, cr[2])  # add measurement gate

qc.draw(output="mpl")

ดังนั้นถ้าเราทำสิ่งนี้ถูกต้อง การวัดของเราบน Qubit ของ Bob ควรได้สถานะ $|0\rangle$ แน่นอนว่าการวัดเหล่านี้มีความน่าจะเป็น ดังนั้นหากมีแม้แต่โอกาสเล็กน้อยที่จะวัด Qubit ของ Bob ให้อยู่ในสถานะ $|1\rangle$ การวัดครั้งเดียวก็อาจได้ $|1\rangle$ เราต้องการทำการวัดหลายครั้งจริงๆ เพื่อให้แน่ใจว่าความน่าจะเป็นของ $|0\rangle$ สูงมาก

ขั้นตอนที่ 2: ปรับแต่งปัญหาสำหรับการรันเชิงควอนตัม

ขั้นตอนนี้นำการดำเนินการที่เราต้องการทำและแสดงออกมาในรูปของฟังก์ชันการทำงานของคอมพิวเตอร์ควอนตัมเฉพาะ และยังแมปปัญหาของเราบน layout ของคอมพิวเตอร์ควอนตัม

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

ด้านล่างมีโค้ดสำหรับบันทึก credentials ในการใช้งานครั้งแรก ตรวจสอบให้แน่ใจว่าลบข้อมูลนี้ออกจาก notebook หลังจากบันทึกลงใน environment แล้ว เพื่อไม่ให้ 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_sherbrooke

เราเปิดใช้งาน logic บนการวัดอย่างชัดเจน

from qiskit.circuit import IfElseOp

backend.target.add_instruction(IfElseOp, name="if_else")

ตอนนี้เราต้อง "transpile" Circuit ควอนตัม ซึ่งเกี่ยวข้องกับหลายขั้นตอนย่อยและเป็นหัวข้อที่น่าสนใจ เพื่อยกตัวอย่างขั้นตอนย่อย: คอมพิวเตอร์ควอนตัมไม่ใช่ทุกตัวที่สามารถใช้งาน logical gate ทั้งหมดใน Qiskit โดยตรง เราต้องเขียน Gate จาก Circuit ของเราในรูปของ Gate ที่คอมพิวเตอร์ควอนตัมสามารถใช้งานได้ เราสามารถดำเนินกระบวนการนั้นและกระบวนการอื่นๆ โดยใช้ preset pass manager การตั้ง optimization = 3 (ระดับสูงสุดของการปรับแต่ง) ช่วยให้มั่นใจว่าการแมปจาก Circuit ควอนตัมนามธรรมไปยังคำสั่งที่ให้กับคอมพิวเตอร์ควอนตัมมีประสิทธิภาพมากที่สุดเท่าที่การประมวลผลล่วงหน้าของเราจะทำได้

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

"Sampler" คือ primitive ที่ออกแบบมาเพื่อสุ่มตัวอย่างสถานะที่เป็นไปได้จาก Circuit ควอนตัม และรวบรวมสถิติว่าสถานะใดอาจถูกวัดและด้วยความน่าจะเป็นเท่าใด เราโหลด Qiskit Runtime Sampler ที่นี่:

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

sampler = Sampler(mode=backend)

ไม่ใช่การคำนวณทั้งหมดบนคอมพิวเตอร์ควอนตัมที่สามารถจำลองได้อย่างสมเหตุสมผลบนคอมพิวเตอร์แบบคลาสสิก teleportation ง่ายๆ นี้สามารถทำได้แน่นอน แต่ไม่น่าแปลกใจเลยที่เราสามารถบันทึกข้อมูลในที่หนึ่งหรืออีกที่หนึ่งได้แบบคลาสสิก เราแนะนำอย่างยิ่งให้ดำเนินการคำนวณเหล่านี้โดยใช้คอมพิวเตอร์ควอนตัม IBM จริง แต่ในกรณีที่คุณใช้งานฟรีรายเดือนหมดแล้ว หรือถ้าบางอย่างต้องเสร็จในชั้นเรียนและรอคิวไม่ได้ โมดูลนี้สามารถทำให้เสร็จได้โดยใช้ simulator เพียงรันเซลล์ด้านล่างและ 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: รัน

ใช้ Sampler รันงานของคุณ โดยมี Circuit เป็น argument

job = sampler.run([qc_isa])
# job = sampler_sim.run([qc_isa])
res = job.result()
counts = res[0].data.c.get_counts()

ขั้นตอนที่ 4: การประมวลผลหลังและการวิเคราะห์

มาพล็อตผลลัพธ์และตีความ

# This required 5 s to run on a Heron r2 processor on 10-28-24
from qiskit.visualization import plot_histogram

plot_histogram(counts)

ทดสอบความเข้าใจ

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

สถานะใดด้านบนบ่งชี้ว่า teleportation สำเร็จ และคุณรู้ได้อย่างไร?

คำตอบ:

สถานะ $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ ทั้งหมดสอดคล้องกับ teleportation ที่สำเร็จ เนื่องจากเราเพิ่ม Gate เพื่อยกเลิกการเตรียมสถานะลับเริ่มต้น ถ้าสถานะลับถูก teleport ไปยัง Qubit ของ Bob สำเร็จ Gate เพิ่มเติมนั้นควรคืน Qubit ของ Bob กลับไปยังสถานะ $|0\rangle$ ดังนั้นสถานะใดก็ตามด้านบนที่มี Qubit ของ Bob (Qubit 0 ซึ่งวัดเป็นส่วนประกอบที่ 0 ของ classical register และดังนั้นสูงสุด/ทางขวาสุด) อยู่ในสถานะ $|0\rangle$ บ่งชี้ความสำเร็จ

พล็อตนี้แสดงผลลัพธ์การวัดทั้งหมดสำหรับสาม Qubit บนการทดลอง 5,000 ครั้งหรือ "shots" เราชี้ให้เห็นก่อนหน้านี้ว่า Alice จะวัดสถานะที่เป็นไปได้ทั้งหมดสำหรับ Qubit A และ Q ด้วยความน่าจะเป็นเท่ากัน เรากำหนด Qubit 0-2 ใน Circuit ให้กับ Q, A และ B ตามลำดับ ในสัญลักษณ์ little-endian Qubit ของ Bob คือทางซ้ายสุด/ต่ำสุด ดังนั้นแท่งสี่ตัวทางซ้ายตรงกับ Qubit ของ Bob อยู่ใน $|0\rangle$ และ Qubit สองตัวอื่นอยู่ในการรวมกันที่เป็นไปได้ทั้งหมดด้วยความน่าจะเป็นประมาณเท่ากัน สังเกตว่าเกือบทั้งหมด (โดยปกติ ~95%) ของการวัดให้ Qubit ของ Bob อยู่ในสถานะ $|0\rangle$ หมายความว่าการตั้งค่าของเราสำเร็จ! มี shots ไม่กี่ตัว (~5%) ที่ให้ Qubit ของ Bob อยู่ในสถานะ $|1\rangle$ สิ่งนั้นไม่ควรเป็นไปได้ตามตรรกะ อย่างไรก็ตาม คอมพิวเตอร์ควอนตัมสมัยใหม่ทั้งหมดประสบกับ noise และข้อผิดพลาดในระดับที่มากกว่าคอมพิวเตอร์แบบคลาสสิกอย่างมาก และ quantum error correction ยังเป็นสาขาที่กำลังพัฒนา

การทดลองที่ 2: Teleportation ข้ามตัวประมวลผล

อย่างมีเหตุผล ส่วนที่น่าสนใจที่สุดของ quantum teleportation คือสถานะควอนตัมสามารถ teleport ได้ในระยะทางไกลทันที (แม้ว่าการสื่อสารแบบคลาสสิกของ Gate เพิ่มเติมจะไม่ทันที) ดังที่กล่าวไว้แล้ว เราไม่สามารถแตก Qubit ออกจากตัวประมวลผลและย้ายพวกมันไปรอบๆ ได้ แต่เราสามารถย้ายข้อมูลจาก Qubit หนึ่งไปยังอีก Qubit จนกว่า Qubit ที่เกี่ยวข้องกับ teleportation จะอยู่คนละด้านของตัวประมวลผล มาทำซ้ำขั้นตอนที่เราทำด้านบน แต่ตอนนี้เราจะสร้าง Circuit ที่ใหญ่กว่าพร้อม Qubit เพียงพอที่จะข้ามตัวประมวลผล

ขั้นตอนที่ 1: แมปปัญหาของคุณไปยัง Circuit ควอนตัม

คราวนี้ Qubit ที่ตรงกับ Alice และ Bob จะเปลี่ยนไป ดังนั้นเราจะไม่ตั้งชื่อ Qubit เดี่ยวว่า "A" และอีกตัวว่า "B" แต่เราจะตั้งหมายเลข Qubit และใช้ตัวแปรเพื่อแสดงตำแหน่งปัจจุบันของข้อมูลบน Qubit ที่เป็นของ Alice และ Bob ขั้นตอนอื่นทั้งหมดยกเว้น swap gate เหมือนกับที่อธิบายก่อนหน้า

# Step 1: Map

# Define registers
qr = QuantumRegister(13, "q")

qc = QuantumCircuit(qr, cr)

# Define registers
secret = QuantumRegister(1, "Q")
ebitsa = QuantumRegister(6, "A")
ebitsb = QuantumRegister(6, "B")
# q = ClassicalRegister(1, "q meas")
# a = ClassicalRegister(1, "a")
# b = ClassicalRegister(1, "b")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)

# We'll start Alice in the middle of the circuit, then move information outward in both directions.
Alice = 5
Bob = 0
qc.h(ebitsa[Alice])
qc.cx(ebitsa[Alice], ebitsb[Bob])

# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits, until the information is on distant qubits.

for n in range(Alice):
    qc.swap(ebitsb[Bob], ebitsb[Bob + 1])
    qc.swap(ebitsa[Alice], ebitsa[Alice - 1])
    Alice = Alice - 1
    Bob = Bob + 1

qc.barrier()

# Create a random state for Alice (qubit zero)
np.random.seed(42)  # fixing seed for repeatability
# theta = np.random.uniform(0.0, 1.0) * np.pi    #from 0 to pi
theta = 0.3
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

qc.u(theta, varphi, 0.0, secret)

# Entangle Alice's two qubits
qc.cx(secret, ebitsa[Alice])
qc.h(secret)

qc.barrier()

# Make measurements of Alice's qubits and store the results in the classical register.
qc.measure(ebitsa[Alice], cr[1])
qc.measure(secret, cr[0])

# Send instructions to Bob's qubits based on the outcome of Alice's measurements.
with qc.if_test((cr[1], 1)):
    qc.x(ebitsb[Bob])
with qc.if_test((cr[0], 1)):
    qc.z(ebitsb[Bob])

qc.barrier()

# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.
qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(ebitsb[Bob], cr[2])  # add measurement gate

qc.draw("mpl")

คุณสามารถเห็นในแผนภาพ Circuit ว่าขั้นตอนตามตรรกะเหมือนกัน ความแตกต่างเพียงอย่างเดียวคือเราใช้ swap gate เพื่อนำสถานะ Qubit ของ Alice จาก Qubit 6 ($A_5$) ขึ้นไปยัง Qubit 1 ($A_0$) ข้างๆ Q และเราใช้ swap gate เพื่อนำสถานะเริ่มต้นของ Bob จาก Qubit 7 ($B_0$) ลงไปยัง Qubit 12 ($B_5$) สังเกตว่าสถานะบน Qubit 12 ไม่เกี่ยวข้องกับสถานะลับของ Q จนกว่าจะมีการวัดบน Qubit 0 และ 1 ที่ห่างไกล และสถานะบน Qubit 12 ไม่เท่ากับสถานะลับจนกว่า $X$ และ $Z$ gate เงื่อนไขจะถูกนำไปใช้

ขั้นตอนที่ 2: ปรับแต่ง Circuit ของคุณ

โดยปกติ เมื่อเราใช้ pass manager เพื่อ transpile และปรับแต่ง Circuit ของเรา สมเหตุสมผลที่จะตั้ง optimization_level = 3 เพราะเราต้องการให้ Circuit มีประสิทธิภาพมากที่สุดเท่าที่จะเป็นไปได้ ในกรณีนี้ ไม่มีเหตุผลทางการคำนวณสำหรับเราที่จะถ่ายโอนสถานะจาก Qubit 6 และ 7 ไปยัง Qubit 1 และ 12 นั่นเป็นแค่สิ่งที่เราทำเพื่อแสดง teleportation ข้ามระยะทาง ถ้าเราขอให้ pass manager ปรับแต่ง Circuit ของเรา มันจะรู้ว่าไม่มีเหตุผลตามตรรกะสำหรับ swap gate เหล่านี้ และจะลบพวกมันออกแล้วทำการดำเนินการ Gate บน Qubit ที่อยู่ติดกัน ดังนั้นสำหรับกรณีพิเศษนี้ เราใช้ optimization_level = 0

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pmzero = generate_preset_pass_manager(target=target, optimization_level=0)

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

เราสามารถแสดงภาพว่า Qubit เหล่านี้อยู่ที่ไหนบนตัวประมวลผลควอนตัมโดยใช้ฟังก์ชัน plot_circuit_layout

ขั้นตอนที่ 3: รัน

ดังที่แนะนำ เราแนะนำให้รันบนคอมพิวเตอร์ควอนตัม IBM จริง หากการใช้งานฟรีรายเดือนของคุณถึงขีดจำกัดแล้ว ลอง uncomment เซลล์ simulator เพื่อรันบน simulator

# This required 5 s to run on a Heron r2 processor on 10-28-24
job = sampler.run([qc_isa_zero])
# job = sampler_sim.run([qc_isa_zero])
counts = job.result()[0].data.c.get_counts()

from qiskit.visualization import plot_histogram

plot_histogram(counts)

ขั้นตอนที่ 4: การประมวลผลหลังแบบคลาสสิก

อีกครั้งเราเห็นว่าความน่าจะเป็นสำหรับผลลัพธ์ที่เป็นไปได้ของ Qubit ของ Alice ค่อนข้างสม่ำเสมอ มีความชอบอย่างแข็งแกร่งในการหา Qubit ของ Bob ใน $|0\rangle$ หลังจากกลับรหัสลับ หมายความว่ามีความน่าจะเป็นสูงที่เรา teleport สถานะลับข้ามตัวประมวลผลจาก Q ไปยัง Bob (Qubit 0 ถึง 12) อย่างถูกต้อง อย่างไรก็ตาม สังเกตว่าตอนนี้มีโอกาสสูงขึ้นประมาณที่จะ ไม่ วัด $|0\rangle$ สำหรับ Bob นี่เป็นบทเรียนสำคัญในการประมวลผลเชิงควอนตัม: ยิ่งคุณมี Gate มากเท่าไหร่ โดยเฉพาะ Gate หลาย Qubit เช่น swap gate ก็ยิ่งเจอ noise และข้อผิดพลาดมากขึ้น

คำถาม

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

แนวคิดสำคัญ

• Qubit สามารถ entangled กันได้ ซึ่งหมายความว่าการวัด Qubit ตัวหนึ่งส่งผลต่อหรือแม้แต่กำหนดสถานะของ Qubit อีกตัว
• Entanglement ต่างจาก classical correlations ตัวอย่างเช่น Qubit A และ B อาจอยู่ในซูเปอร์โพสิชันของสถานะเช่น $\alpha_0|00\rangle+\alpha_1|11\rangle$ สถานะของ A หรือ B อาจยังไม่ถูกกำหนดโดยธรรมชาติ และ A และ B ยังคงรับประกันว่าอยู่ในสถานะเดียวกัน
• ผ่านการรวมกันของ entanglement และการวัด เราสามารถถ่ายโอนสถานะ (ที่สามารถเก็บข้อมูล) จาก Qubit หนึ่งไปยังอีก Qubit การถ่ายโอนนี้สามารถทำได้แม้ในระยะทางไกล และนี่เรียกว่า quantum teleportation
• Quantum teleportation อาศัยการวัดเชิงควอนตัม ซึ่งมีความน่าจะเป็น ดังนั้นการสื่อสารแบบคลาสสิกอาจจำเป็นเพื่อปรับแต่งสถานะที่ teleport แล้ว สิ่งนี้ป้องกัน quantum teleportation จากการย้ายข้อมูลเร็วกว่าแสง Quantum teleportation ไม่ละเมิด relativity หรือ causality
• คอมพิวเตอร์ควอนตัมสมัยใหม่มีความอ่อนแอต่อ noise และข้อผิดพลาดมากกว่าคอมพิวเตอร์แบบคลาสสิก คาดว่าจะมีข้อผิดพลาดสองสามเปอร์เซ็นต์
• ยิ่งคุณเพิ่ม Gate ตามลำดับมากขึ้น (โดยเฉพาะ Gate 2 Qubit) ก็ยิ่งมีข้อผิดพลาดและ noise มากขึ้น

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

1. จ/ท Quantum teleportation สามารถใช้ส่งข้อมูลเร็วกว่าแสงได้
2. จ/ท หลักฐานสมัยใหม่แสดงว่าการ collapse ของสถานะควอนตัมเผยแพร่เร็วกว่าแสง
3. จ/ท ใน Qiskit Qubit เรียงลำดับในสถานะโดยมี Qubit ที่มีหมายเลขต่ำที่สุดทางขวา ดังใน $|q_3,q_2,q_1, q_0\rangle$

คำถาม MC

1. Qubit A และ B entangled กัน แล้วแยกออกด้วยระยะทาง $d$ ขนาดใหญ่ Qubit A ถูกวัด คำกล่าวใดถูกต้องเกี่ยวกับความเร็วที่สถานะของ Qubit B ได้รับผลกระทบ?

• a. Qubit B ได้รับผลกระทบทันที ภายในขีดจำกัดการทดลอง ในการทดลองที่ดำเนินการจนถึงปัจจุบัน
• b. Qubit B ได้รับผลกระทบหลังจากเวลา $d/c$ หมายความว่าสถานะควอนตัม "collapse" ที่ความเร็วประมาณแสง ภายในขีดจำกัดการทดลอง
• c. Qubit B ได้รับผลกระทบเฉพาะหลังจากการสื่อสารแบบคลาสสิกเกิดขึ้น หมายความว่าเกิดขึ้นในเวลาที่นานกว่า $d/c$
• d. ไม่มีข้อใดข้างต้น

2. จำไว้ว่าความน่าจะเป็นในการวัดเกี่ยวข้องกับแอมพลิจูดในสถานะควอนตัม ตัวอย่างเช่น ถ้า Qubit เริ่มต้นในสถานะ $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ ความน่าจะเป็นของการวัดสถานะ $|0\rangle$ คือ $|\alpha_0|^2$ ไม่ใช่ทุกชุดการวัดที่จะตรงกับความน่าจะเป็นเหล่านี้อย่างแม่นยำ เนื่องจากการสุ่มตัวอย่างที่จำกัด (เช่นเดียวกับการโยนเหรียญอาจได้หัวสองครั้งติดกัน) ฮิสโตแกรมการวัดด้านล่างอาจตรงกับสถานะควอนตัมใดต่อไปนี้? เลือกตัวเลือกที่ดีที่สุด

• a. $|0\rangle$
• b. $\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$
• d. $\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle$
• e. $\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle$

3. สถานะใดต่อไปนี้แสดง Qubit A และ B ที่ entangled กัน? เลือกทั้งหมดที่ถูกต้อง

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)$
• e. $|0\rangle_B|0\rangle_A$

4. ในโมดูลนี้ เราเตรียมสถานะ entangled: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$ แต่มีสถานะ entangled อื่นๆ มากมายที่สามารถใช้สำหรับ protocol ที่คล้ายกัน สถานะใดด้านล่างที่อาจให้ฮิสโตแกรมการวัด 2 Qubit เช่นนี้? เลือกตัวเลือกที่ดีที่สุด

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A$
• e. $|0\rangle_B|0\rangle_A$

คำถามสำหรับถกเถียง

1. อธิบาย quantum teleportation protocol ตั้งแต่ต้นจนจบให้ partner/กลุ่มของคุณฟัง ดูว่าพวกเขามีอะไรเพิ่มเติมหรือมีคำถามหรือไม่

2. มีอะไรที่เป็นเอกลักษณ์เกี่ยวกับสถานะที่ entangled เริ่มต้นระหว่าง Alice และ Bob หรือไม่: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ ถ้ามี อะไรที่เป็นเอกลักษณ์? ถ้าไม่มี สถานะ entangled อื่นๆ ที่เราสามารถใช้มีอะไรบ้าง?