เหรียญควอนตัม — โมดูลเกี่ยวกับซูเปอร์โพซิชันและการอินเตอร์เฟียร์

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

• 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 47 วินาที นี่เป็นการประมาณเท่านั้น การใช้งานจริงของคุณอาจแตกต่างกัน

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

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

---

บทนำ

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

ในบางแง่ การวัดสถานะซูเปอร์โพซิชันเหมือนกับการโยนเหรียญ: ไม่มีทางรู้ล่วงหน้าว่ามันจะลงด้านใด ความไม่แน่นอนพื้นฐานนี้เป็นแง่มุมที่น่าอึดอัดของกลศาสตร์ควอนตัมที่แม้แต่ Einstein ก็มีปัญหากับมัน เขาพูดอย่างโด่งดังว่า "พระเจ้าไม่ทอยลูกเต๋า" เกี่ยวกับความสุ่มนี้ แต่อย่างที่เราจะเห็น พระเจ้าที่แท้จริงทอยลูกเต๋า — และโยนเหรียญด้วย

เราจะคิดเกี่ยวกับการโยนเหรียญคลาสสิกเป็นการเปรียบเทียบกับการวัดสถานะซูเปอร์โพซิชัน และ — โดยเล่นกับ "เหรียญควอนตัม" โดยใช้ Qiskit และ Qubit บนโปรเซสเซอร์ควอนตัม IBM® — เราจะพบข้อจำกัดของการเปรียบเทียบนั้นอย่างรวดเร็ว

เหรียญคลาสสิก

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

$$S(coin) = \frac{1}{2}|up\rangle + \frac{1}{2}|down\rangle$$

ที่นี่ สองพจน์แทนผลลัพธ์ที่เป็นไปได้สองอย่างของการโยน และสัมประสิทธิ์ของพวกมันแทนความน่าจะเป็นของผลลัพธ์แต่ละอย่าง โปรดสังเกตว่าโดยทั่วไป "$|\rangle$" (เรียกว่า "ket") ใช้แทนสถานะควอนตัม แต่ที่นี่ เรากำลังพูดถึง สถานะความน่าจะเป็นแบบคลาสสิก ดู บทเรียนที่ 1: ระบบเดี่ยว ในคอร์ส Basics of Quantum Information เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับวิธีที่เราแสดงข้อมูลแบบคลาสสิกและควอนตัม

หากเราโยนเหรียญ 1000 ครั้งและบันทึกจำนวนหัวขึ้นและหัวลง เราจะได้บางอย่างแบบนี้:

# import necessary packages:
import numpy as np
import matplotlib.pyplot as plt
import random

nflips = 1000
fliplist = [random.randint(0, 1) for f in range(nflips)]

# bar plots using get_gaussian_probs function
plt.hist(fliplist)
plt.show()

เหรียญควอนตัม

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

ดังนั้น เนื่องจาก Qubit อยู่ในซูเปอร์โพซิชันที่เท่ากันของ 0 และ 1 เมื่อเราวัด Qubit จะมีโอกาส 50% ที่เราวัดได้ $|0\rangle$ โอกาส 50% ที่เราวัดได้ $|1\rangle$ เราเขียนสถานะนี้แตกต่างจากกรณีความน่าจะเป็นแบบคลาสสิกเล็กน้อย ด้วยเหตุผลที่จะชัดเจนในภายหลัง:

$$|\psi\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle$$

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

แม้จะมีความแตกต่างเหล่านี้ ผลลัพธ์ของการวัดสถานะนี้โดยพื้นฐานแล้วเหมือนกับการโยนเหรียญ

from qiskit import QuantumCircuit

qcoin = QuantumCircuit(1)
qcoin.h(0)
qcoin.measure_all()

qcoin.draw("mpl")

ดังนั้น ในผล การใช้ Hadamard gate เป็นอนาล็อกของการโยนเหรียญ และเช่นเดียวกับที่เราโยนเหรียญ 1000 ครั้งเพื่อดูสถิติของเหรียญที่ลงหัวขึ้นหรือลง เราสามารถทำสิ่งที่คล้ายกันบน Qiskit กับ "เหรียญควอนตัม" ของเรา เราสามารถใช้ Qiskit primitive ที่เรียกว่า Sampler ซึ่งจะทำซ้ำ Circuit หลายครั้งเพื่อสุ่มตัวอย่างสถิติของสถานะที่ได้

ขั้นแรก เราโหลด Qiskit Runtime service และ primitives จากนั้นเราเลือก Backend ที่จะรัน Circuit

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

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

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

# Load the Runtime primitive and session
from qiskit_ibm_runtime import (
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

# Use the least busy backend
backend = service.least_busy()
print(backend.name)

ibm_kingston

หากคุณไม่มีเวลาเหลือในบัญชีของคุณ คุณยังสามารถเลือกรันบน simulator แทน เพียง uncomment โค้ดแล้วรัน cell ด้านล่างเพื่อทำเช่นนั้น:

## Use a local simulator

# from qiskit_aer import AerSimulator

## Generate a simulator that mimics the real quantum system

# backend_sim = AerSimulator.from_backend(backend)

## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)

# from qiskit.primitives import BackendSamplerV2
# sampler_sim = BackendSamplerV2(backend = backend_sim)
# from qiskit.primitives import BackendEstimatorV2
# estimator_sim = BackendEstimatorV2(backend = backend_sim)

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

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analysis
from qiskit.visualization import plot_histogram

plot_histogram(counts)

ด้วย 1000 ตัวอย่างของ Circuit ข้างต้น เรามีบางอย่างที่ดูเหมือนกับ histogram เหรียญคลาสสิกอย่างสมบูรณ์ โดยมีความผันแปรทางสถิติบ้าง

นอกจากการสุ่มตัวอย่างสถิติของเหรียญควอนตัม เรายังสามารถใช้ Qiskit primitive อีกตัวที่เรียกว่า Estimator เพื่อวัดสิ่งที่เรียกว่า expectation value ของ observable ของสถานะ เพื่อแสดงให้เห็นว่า expectation value นี้คืออะไร มาใช้เหรียญคลาสสิกเป็นตัวอย่าง สมมติว่าคุณใช้เหรียญเล่นการพนัน: ทุกครั้งที่คุณโยนเหรียญและมันลงหัวขึ้น คุณได้หนึ่งดอลลาร์ แต่ทุกครั้งที่มันลงหัวลง คุณเสียหนึ่งดอลลาร์ ถ้าคุณต้องการรู้ว่าคาดว่าจะได้เงินเท่าไรต่อการโยนแต่ละครั้ง (expectation value ของ observable "เงิน") คุณจะคำนวณ:

$$E(money) = \frac{1}{2} (+ \text{1 dollar}) + \frac{1}{2} (- \text{1 dollar}) = \text{0 dollars}$$

เนื่องจากคุณมีโอกาสเท่ากันที่จะได้ดอลลาร์หรือเสียดอลลาร์ expectation value จึงเป็น $0

ในทำนองเดียวกัน กับสถานะควอนตัม เราสามารถคำนวณ expectation value ของ observable "Z" ซึ่ง Z คือเมทริกซ์ Pauli ที่มีค่า +1 และ -1 เชื่อมโยงกับสถานะ $|0\rangle$ และ $|1\rangle$ ตามลำดับ

$$\langle \psi|Z|\psi \rangle = \frac{1}{2} \langle 0 | Z | 0 \rangle + \frac{1}{2} \langle 1 | Z | 1 \rangle = \frac{1}{2} (+1) + \frac{1}{2}(-1) = 0$$

from qiskit.quantum_info import Pauli

qcoin = QuantumCircuit(1)
qcoin.h(0)

# for Estimator, we do not apply the measurement to the circuit

<qiskit.circuit.instructionset.InstructionSet at 0x136df1ba0>

## Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

obs = Pauli("Z")

qc_isa = pm.run(qcoin)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

## Execute

# On real hardware:
estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# On a simulator:
# job = estimator_sim.run([[qc_isa, obs_isa]])
# res=job.result()

print(res[0].data.evs)

-0.014799284701239441

เราได้ expectation value เป็น 0 ตามที่คาดไว้ นี่เป็นอีกวิธีหนึ่งในการยืนยันว่ามีความน่าจะเป็นเท่ากันในการวัด 0 และ 1 และดูเหมือนจะทำงานเหมือนการโยนเหรียญ

ณ จุดนี้ "เหรียญควอนตัม" ดูเหมือนกับเหรียญคลาสสิกทุกประการ แต่ในส่วนถัดไป เราจะทำการทดลองที่จะเผยให้เห็นความแตกต่างพื้นฐานระหว่างทั้งสอง

ควอนตัมที่เปิดเผยออกมา: การทดลองในสามมิติ

มาทำการทดลองทางความคิด: สมมติว่าคุณโยนเหรียญขึ้นไปในอากาศ และแทนที่จะให้มันตกลงพื้น คุณมีความคล่องพอที่จะปรบมือขณะที่มันผ่านระหว่างมือและหนีบเหรียญระหว่างฝ่ามือ ตอนนี้ แทนที่เหรียญจะหัวขึ้นหรือลง มันหัวซ้ายหรือขวา

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

อ่านคำถามด้านล่าง คิดคำตอบของคุณ จากนั้นคลิกสามเหลี่ยมเพื่อดูคำตอบ

ความน่าจะเป็นของแต่ละผลลัพธ์เหล่านี้คือเท่าใด หัวซ้ายหรือหัวขวา?

คำตอบ:

ความน่าจะเป็นยังคงเป็น 50-50 ไม่ควรสำคัญว่าเราเลือกมิติใดในการวัดผลลัพธ์ของการโยนเหรียญ

หวังว่าคุณตอบว่าความน่าจะเป็นของการพบหัวซ้ายหรือขวายังคงเป็น 50-50 มิติที่เลือกวัดการโยนเหรียญไม่ควรส่งผลต่อความน่าจะเป็นของผลลัพธ์

แต่สิ่งต่างๆ จะดูแตกต่างอย่างไรสำหรับเหรียญควอนตัมของเรา? มาตรวจสอบ

เราสามารถสร้างซูเปอร์โพซิชันควอนตัมในแบบเดียวกับที่เราทำครั้งที่แล้ว ด้วย Hadamard gate เพื่อวัด "หัวซ้ายหรือขวา" บนเหรียญควอนตัมของเรา เราสามารถทำสิ่งที่เราทำกับเหรียญคลาสสิก: วัดตามแกนที่แตกต่าง การวัดมาตรฐานของเราบนคอมพิวเตอร์ควอนตัมเป็นตามแกนแนวตั้ง เช่นเดียวกับการวัด "หัวขึ้นหรือลง" ปกติของเหรียญคลาสสิก แต่เราสามารถถามเหรียญควอนตัมด้วยว่ามันหัวซ้ายหรือขวา หรือเทียบเท่า ถ้ามันอยู่ในสถานะ $|+\rangle$ หรือ $|-\rangle$ ซึ่งชี้ตามแกน $x$ Sampler สุ่มตัวอย่างเฉพาะใน measurement basis Z แต่เราสามารถใช้ Estimator เพื่อให้ expectation value ของ X ค่าของ X คือ +1 และ -1 สำหรับสถานะ $|+\rangle$ หรือ $|-\rangle$ ตามลำดับ

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

อ่านคำถามด้านล่าง คิดคำตอบของคุณ จากนั้นคลิกสามเหลี่ยมเพื่อดูคำตอบ

ถ้าเหรียญควอนตัมทำงานเหมือนเหรียญคลาสสิกในกรณีนี้ เราจะมีความน่าจะเป็น 50-50 ของการวัดสถานะ $|+\rangle$ และ $|-\rangle$ Estimator จะส่งคืน expectation value ของ X เท่าใด ถ้าเป็นเช่นนั้น?

คำตอบ:

เมื่อเรานำ X ไปใช้กับสถานะ $|+\rangle$ เราได้ค่า +1 และกับสถานะ $|-\rangle$ เราได้ -1 ดังนั้นถ้าเราได้การกระจาย 50-50 เราจะได้ expectation value เป็น 0

# Step 1: map problem

qcoin_lr = QuantumCircuit(1)
qcoin_lr.h(0)

obs = Pauli("X")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_lr)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = estimator_sim.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

0.9985207100591716

expectation value ของ X สำหรับสถานะนี้คือ 1 ดังนั้น จึงไม่ใช่ความน่าจะเป็น 50-50 ของการวัด $|+\rangle$ และ $|-\rangle$

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

อ่านคำถามด้านล่าง คิดคำตอบของคุณ จากนั้นคลิกสามเหลี่ยมเพื่อดูคำตอบ

expectation value นี้บอกอะไรเราเกี่ยวกับสถานะ $|\psi\rangle$? ความน่าจะเป็นของการวัด $|+\rangle$ และ $|-\rangle$ ใน X basis คืออะไร?

คำตอบ:

เนื่องจาก expectation value เท่ากับค่าของ X สำหรับสถานะ $|+\rangle$ หมายความว่าเรามีความน่าจะเป็น 100% ของการวัดสถานะ $|+\rangle$ เมื่อเราวัดตาม X

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

เฟสควอนตัม

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

$$S(coin) = c_1|up\rangle + c_2|down\rangle$$

สัมประสิทธิ์แต่ละตัวเป็นจำนวนจริงบวกที่แทนความน่าจะเป็นของการวัดสถานะใดสถานะหนึ่ง ในสถานะควอนตัม

$$|\psi\rangle = c_1 |0\rangle + c_2 |1\rangle$$

สัมประสิทธิ์เป็นจำนวนเชิงซ้อน ดังนั้นพวกมันมีส่วนจริงและส่วนจินตภาพ สัมประสิทธิ์แต่ละตัว $c_i$ สามารถแสดงเป็นเวกเตอร์สองมิติบนระนาบเชิงซ้อน โดยมีขนาด $|c_i|$ และมุม $\phi_i$ ที่มันทำกับแกนจริง:

$$c_i = |c_i| e^{i \phi_i}.$$

เราเรียก $\phi_i$ ว่าเฟส เฟสบอกเราว่าสองพจน์ในสถานะควอนตัมจะ อินเตอร์เฟียร์ กันอย่างไร หรือพวกมันจะบวกหรือหักล้างกันเหมือนคลื่นอย่างไร ถ้าคลื่นสองคลื่นอยู่ในเฟสเดียวกัน ดังนั้นยอดคลื่นและร่องคลื่นของพวกมันตรงกัน แล้วพวกมันจะรวมกันเป็นคลื่นที่สูงเป็นสองเท่า เราเรียกสิ่งนี้ว่าการอินเตอร์เฟียร์แบบสร้างสรรค์ ถ้าพวกมันไม่อยู่ในเฟสเดียวกัน หมายความว่ายอดคลื่นจากคลื่นหนึ่งตรงกับร่องคลื่นจากอีกคลื่นหนึ่ง และในทางกลับกัน พวกมันอินเตอร์เฟียร์แบบทำลายล้างและหักล้างกันอย่างสมบูรณ์

เช่นเดียวกับคลื่น สถานะควอนตัมก็สามารถบวกกันแบบสร้างสรรค์หรือทำลายล้างได้ มันอาจยากกว่าที่จะเห็นเพราะมักจะไม่ได้พูดถึงคลื่นจริงในพื้นที่ทางกายภาพ ในกรณีของ Qubit ของเรา การอินเตอร์เฟียร์เกิดขึ้นในพื้นที่ข้อมูลนามธรรมของ Qubit นอกจากนี้โปรดสังเกตว่าเนื่องจากเฉพาะ เฟสสัมพัทธ์ ระหว่างคลื่นสองคลื่นเท่านั้นที่สำคัญต่อวิธีที่พวกมันจะอินเตอร์เฟียร์ — นั่นคือ ความต่างของเฟส $\Delta \phi = \phi_2 - \phi_1$ ของสัมประสิทธิ์ทั้งสอง — เราโดยทั่วไปใช้ global phase $-\phi_1$ กับสถานะทั้งหมด ดังนั้น $c_1$ เป็นจำนวนจริงล้วน และ เฟสสัมพัทธ์ ถูกบันทึกทั้งหมดใน $c_2$

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

qcoin_0 = QuantumCircuit(1)
qcoin_0.h(0)
qcoin_0.h(0)
qcoin_0.measure_all()

qcoin_0.draw("mpl")

ตอนนี้ ก่อนที่เราจะใช้ Sampler เพื่อวัดสถานะที่ได้ มาคิดว่า Qubit นี้จะถูกแปลงโดย Gate แต่ละตัวอย่างไร มันเริ่มต้น เช่นเดียวกับปกติ ใน $|0\rangle$ จากนั้น Hadamard แรกแปลงสถานะเป็นซูเปอร์โพซิชัน ตามที่เราเคยเห็นแล้ว:

$$H|0\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle.$$

ในกรณีนี้ สัมประสิทธิ์ทั้งสองเป็นจำนวนจริงบวกอย่างสมบูรณ์ หมายความว่าเฟสคือ $\phi=0$

Hadamard ที่สองจะถูกนำไปใช้กับแต่ละส่วนของสถานะซูเปอร์โพซิชันแยกกัน เรารู้แล้วว่า Hadamard แปลงสถานะ $|0\rangle$ อย่างไร แต่แล้ว $|1\rangle$ ล่ะ?

$$H|1\rangle = \frac{1}{\sqrt{2}} |0\rangle - \frac{1}{\sqrt{2}} |1\rangle$$

นี่ก็เป็นซูเปอร์โพซิชันที่เท่ากันของ 0 และ 1 คล้ายกับการโยนเหรียญ แต่สัมประสิทธิ์ด้านหน้า $|1\rangle$ ของสถานะนี้มีเฟส $\phi = \pi$ เพื่อให้เครื่องหมายลบ

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

อ่านคำถามด้านล่าง คิดคำตอบของคุณ จากนั้นคลิกสามเหลี่ยมเพื่อดูคำตอบ

คำนวณสถานะที่ได้หลังจากใช้ Hadamard ที่สอง นั่นคือ คำนวณ: $H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle)$ โปรดสังเกตว่า $H$ เป็น distributive ดังนั้นเราสามารถนำไปใช้กับแต่ละพจน์แยกกัน

คำตอบ:

$$H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle) = \frac{1}{\sqrt{2}} H|0\rangle + \frac{1}{\sqrt{2}} H|1\rangle = \frac{1}{2} [(|0\rangle + |1\rangle) + (|0\rangle - |1\rangle)] = |0\rangle$$

ตอนนี้มาตรวจสอบการทำนายของเราด้วย Sampler

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_0)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

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

มาสำรวจต่อ: เราสามารถเปลี่ยนเฟสโดยใช้ "PHASE" gate ดังนั้นตอนนี้มาใช้ Hadamard เพื่อสร้างซูเปอร์โพซิชัน ใช้การเลื่อนเฟส $\pi$ เรเดียน แล้วใช้ Hadamard ที่สอง:

qcoin_pi = QuantumCircuit(1)
qcoin_pi.h(0)
qcoin_pi.p(np.pi, 0)
qcoin_pi.h(0)
qcoin_pi.measure_all()

qcoin_pi.draw("mpl")

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_pi)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

และตอนนี้ Qubit ถูกวัดให้อยู่ในสถานะ 1 แทนที่ 0

ดังนั้น แม้แต่จากการทดลองไม่กี่ครั้งที่เรียบง่ายเหล่านี้ คุณก็สามารถเห็นความแตกต่างอย่างมากที่เฟสนี้สามารถสร้างได้กับ Circuit ควอนตัม มันสามารถละเอียดอ่อนและยากที่จะเห็นในตอนแรก ในการทดลองแรกของเรา ที่เราเพียงโยนเหรียญควอนตัมด้วย Hadamard gate และวัดผลลัพธ์ของการโยน ไม่ได้เผยให้เห็นผลกระทบของเฟสอะไรเลย มันเป็นเพียงเมื่อเราขุดลึกขึ้นเราจึงค้นพบความแตกต่างที่เฟสสามารถสร้างได้ มันสามารถทำให้ Gate ควอนตัมเดียวกันมีผลกระทบตรงข้ามต่อ Qubit อย่างแท้จริง

ลองด้วยตัวเอง:

แก้ไข code cell ด้านล่างเพื่อเปลี่ยนเฟสให้ Hadamard ที่สองสร้างสถานะซูเปอร์โพซิชันที่มีความน่าจะเป็น 25% และ 75% ของการพบสถานะใน $|0\rangle$ และ $|1\rangle$ ตามลำดับ ยืนยันคำตอบของคุณด้วยคณิตศาสตร์

qcoin_phase = QuantumCircuit(1)
qcoin_phase.h(0)
# replace "x" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)
# qcoin_phase.rz(x, 0)
qcoin_phase.h(0)
qcoin_phase.measure_all()

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_phase)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

การเปรียบเทียบเหรียญที่ดีกว่า (และถูกต้องกว่า) โดยใช้ $\sqrt{\text{NOT}}$ gate

ถึงตอนนี้เราได้เรียนรู้ว่าการโยนเหรียญแตกต่างอย่างมากจากการสร้างสถานะซูเปอร์โพซิชัน มีการเปรียบเทียบกับเหรียญที่ดีกว่าที่เราสามารถสร้างได้ซึ่งจับปรากฏการณ์ซูเปอร์โพซิชันได้มากกว่าไหม? ใช่ มีอยู่

เราจะทำการทดลองทางความคิดอีกครั้งด้วยเหรียญ จินตนาการว่าเหรียญวางอยู่บนโต๊ะ หัวขึ้น เพื่อทำให้มันหัวลง เราสามารถพลิกมันง่ายๆ นี่คือการเทียบเท่าเชิงคำนวณของ "NOT" gate

สมมติว่าเราต้องการสร้างการดำเนินการที่ถ้าใช้สองครั้ง จะเทียบเท่ากับ NOT gate นั่นคือ เราต้องการ "รากที่สองของ NOT" หรือ $\sqrt{\text{NOT}}$ เราสามารถทำสิ่งนี้ได้โดยพิจารณาว่า NOT gate ถูก implement ทางกายภาพบนเหรียญอย่างไร: มันเป็นเพียงการหมุน 180 องศารอบแกน x ตัวอย่างเช่น ดังนั้นถ้าเราหมุนเหรียญเพียง 90 องศารอบแกน x มันจะเทียบเท่ากับ $\sqrt{\text{NOT}}$ gate

จินตนาการว่าหลังจากใช้ $\sqrt{\text{NOT}}$ gate เราต้องการถามว่าเหรียญอยู่หัวขึ้นหรือลง มันไม่ใช่ทั้งสอง — มันยืนอยู่บนขอบสัมพันธ์กับแกนแนวตั้ง แต่ตอนนี้ มาสร้าง "การวัด" ของเหรียญใหม่ให้เป็น ขั้นแรก การ collapse เหรียญตามแกนการวัด (โดยกดมันด้วยมือเพื่อให้นอนราบ) และประการที่สอง ตรวจสอบว่ามันหัวขึ้นหรือลง

ถ้าเราทำ "การวัด" นี้กับเหรียญที่ยืนอยู่บนขอบ เหรียญจะ "collapse" เป็นหัวขึ้นและหัวลงด้วยความน่าจะเป็นเท่ากัน เช่นเดียวกับการโยนเหรียญ ในหลักการ ทิศทางที่เหรียญล้มสามารถทำนายได้จากเงื่อนไขเริ่มต้นของเหรียญและวิธีที่แรงของมือถูกใช้กับเหรียญเพื่อ "collapse" มัน แต่ในทางปฏิบัติ มันควรยากที่จะทำนายว่าด้านใดจะขึ้น ดังนั้นมันโดยพื้นฐานแล้วสุ่ม

เราสามารถวัดเหรียญนี้ตามสามแกนต่างๆ: $x$, $y$ และ $z$ เราเห็นว่าขอบเหรียญชี้ตาม $x$ และ $z$ ดังนั้นการวัดในทิศทางเหล่านั้นต้องการ "collapse" เหรียญ — ดังนั้นตามแกนเหล่านั้น จะมีความสุ่มด้วยความน่าจะเป็น 50:50 ของการวัดหัวขึ้นและลง แต่ตามแกน $y$ มันแบนอยู่แล้ว โดยหน้าของมันหันไปทิศ -y เราสามารถเรียกสิ่งนั้นว่า "หัวข้างหน้า"

ดังนั้น ในขณะที่การวัด x และ z ให้ผลลัพธ์สุ่ม การวัด y จะให้ผลลัพธ์เดิมเสมอ! ถ้าคุณนึกถึงการทดลอง "การโยนเหรียญควอนตัม" จากส่วนก่อนหน้า นี่คล้ายกับวิธีที่เหรียญควอนตัมทำงาน มันถูกวัดให้เป็น 0 หรือ 1 ด้วยความน่าจะเป็น 50/50 ในทิศทาง z แต่เสมอ $|+\rangle$ และไม่เคย $|-\rangle$ ตาม X สิ่งนี้แนะนำว่าบางทีเหรียญที่นั่งนิ่งอยู่บนขอบเป็นวิธีที่ดีกว่าในการมองเห็นสถานะซูเปอร์โพซิชันของ Qubit มากกว่าเหรียญที่กำลังโยนอยู่ในอากาศอย่างไม่มีการควบคุม

มาใช้ Qiskit เพื่อดูว่า "เหรียญควอนตัม" ของเราทำงานในแบบเดียวกับเหรียญคลาสสิกเมื่อใช้ $\sqrt{\text{NOT}}$ gate หรือไม่ เราจะใช้ $\sqrt{\text{NOT}}$ กับ Qubit ที่เริ่มต้นใน $|0\rangle$ จากนั้นใช้ Estimator เพื่อตรวจสอบ expectation value ของ observables ทั้งสาม X, Y และ Z

qcoin_sx = QuantumCircuit(1)
qcoin_sx.sx(0)

qcoin_sx.draw("mpl")

obs1 = Pauli("X")
obs2 = Pauli("Y")
obs3 = Pauli("Z")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_sx)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
job = estimator.run(pubs)
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
# job = estimator_sim.run(pubs)
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

[[-0.01234492]
 [-1.00388865]
 [ 0.00740695]]

expectation values คือ 0, -1 และ 0 สำหรับ X, Y และ Z ตามลำดับ

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

อ่านคำถามด้านล่าง คิดคำตอบของคุณ จากนั้นคลิกสามเหลี่ยมเพื่อดูคำตอบ

จาก expectation values ความน่าจะเป็นของการวัดเหรียญควอนตัมให้เป็นหัวขึ้น/ลง (หรือซ้าย/ขวา หรือหน้า/หลัง) สำหรับแกนการวัดทั้ง 3 แกนคือเท่าใด?

คำตอบ:

มีความน่าจะเป็น 50/50 ของการวัดสถานะใดๆ ตาม X และ Z และสถานะจะถูกวัดในทิศทาง -y ตาม Y เสมอ

นี่คือผลลัพธ์เดียวกันที่เราได้จากการทดลองทางความคิดของเราในการใช้การหมุน 90 องศา "$\sqrt{\text{NOT}}$" บนเหรียญคลาสสิก อันที่จริง มีการเปรียบเทียบที่แม่นยำระหว่างเหรียญและสถานะ Qubit ตอนนี้ เราสามารถมองเห็น state ของ Qubit เป็นเวกเตอร์ที่ชี้ในทิศทางของหัวเหรียญ ตั้งฉากกับพื้นผิวของเหรียญ ดังนั้น หัวขึ้น หรือสถานะ $|0\rangle$ บนเหรียญควอนตัม เทียบเท่ากับเวกเตอร์ที่ชี้ตรงขึ้น หัวลง หรือ $|1\rangle$ ชี้ตรงลง ซูเปอร์โพซิชันที่เท่ากันของ $|0\rangle$ และ $|1\rangle$ ชี้ในแนวนอน เฟสของสถานะกำหนดทิศทางแนวนอนที่แน่นอน — ทิศทางที่มันชี้ตามเส้นศูนย์สูตรเท่ากับทิศทางที่สัมประสิทธิ์ $c_2$ ชี้ในระนาบเชิงซ้อน

ตอนนี้ ทุก Gate ที่เราเห็นใน notebook นี้สามารถมองเห็นได้เป็นการหมุน (หรือชุดของการหมุน) ของเหรียญ/เวกเตอร์

• NOT: 180 องศารอบแกน x

• $\sqrt{\text{NOT}}$: 90 องศารอบแกน x

• PHASE: การหมุน $\phi$ รอบแกน z

• Hadamard: อันนี้ยากกว่าเล็กน้อย ตอนแรกเราเปรียบมันกับการโยนเหรียญ ทำให้เหรียญหมุนอย่างไม่มีการควบคุมในอากาศ แต่ Hadamard จริงๆ แล้วเป็นการหมุนที่มีการควบคุมและแน่นอนของเหรียญ เช่นเดียวกับ Gate อื่นๆ Hadamard ถูก perform โดยหมุน 90 องศารอบแกน y จากนั้น 180 องศารอบแกน x

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

สถานะ Qubit เป็น Bloch vector

เวกเตอร์ที่ชี้ในทิศทางของ "หัว" ของเหรียญนี้เรียกว่า "Bloch vector" อย่างเป็นทางการ สถานะ Qubit (ที่แยกตัว) โดยพลการสามารถแสดงโดยเวกเตอร์ที่อยู่บนพื้นผิวของทรงกลมรัศมี 1 ที่มีพิกัด $(r, \theta, \phi)$ เขียนในเทอมของพิกัดเหล่านี้ สถานะ Qubit คือ:

$|\psi\rangle = \cos{\frac{\theta}{2}} |0\rangle + e^{i \phi} \sin{\frac{\theta}{2}} |1\rangle$

ตอนนี้มาตรวจสอบด้วย Qiskit ว่า Bloch vector เปลี่ยนแปลงอย่างไรเมื่อเราใช้ Gate ต่างๆ กับ Qubit ของเราเริ่มต้นจากสถานะ $|0\rangle$

NOT

from qiskit.visualization import plot_bloch_multivector

qnot = QuantumCircuit(1)
qnot.x(0)

plot_bloch_multivector(qnot)

$\sqrt{\text{NOT}}$

qsqrtnot = QuantumCircuit(1)
qsqrtnot.sx(0)

plot_bloch_multivector(qsqrtnot)

PHASE ($\phi = \pi$)

qphase = QuantumCircuit(1)
qphase.p(np.pi, 0)

plot_bloch_multivector(qphase)

Hadamard

qhadamard = QuantumCircuit(1)
qhadamard.h(0)

plot_bloch_multivector(qhadamard)

บทสรุป — สถานะซูเปอร์โพซิชัน คือ อะไรกันแน่?

เราเริ่มต้นโมดูลนี้โดยเปรียบความสุ่มของการวัดสถานะซูเปอร์โพซิชันควอนตัมกับการโยนเหรียญ เราเปรียบ "Hadamard gate" ที่สร้างซูเปอร์โพซิชันควอนตัมกับการโยนเหรียญ แต่ผ่านชุดการทดลอง เราเรียนรู้ว่ามีความแตกต่างพื้นฐานระหว่างการโยนเหรียญคลาสสิกกับซูเปอร์โพซิชันควอนตัม

เราเรียนรู้ว่าจริงๆ แล้วไม่มีอะไร "สุ่ม" เกี่ยวกับ Qubit ในสถานะซูเปอร์โพซิชัน มันเหมือนเหรียญที่นั่งนิ่งในพื้นที่สามมิติ อันที่จริง เหรียญที่สามารถหมุนได้ในสามมิติเป็นการเปรียบเทียบที่ใกล้เคียงมากกับวิธีที่ระบุในการมองเห็นสถานะควอนตัมของ Qubit ที่เรียกว่า Bloch vector Gate ควอนตัมหมุนเหรียญ/Bloch vector นี้อย่างแน่นอนและกลับได้ มีเพียงเมื่อเรา วัด Qubit ที่มีความสุ่มใดๆ เข้ามา เราเปรียบกระบวนการวัดนี้กับการกดเหรียญให้นอนราบในทิศทางของแกนการวัด

ว่าสถานะควอนตัมอยู่ในซูเปอร์โพซิชันหรือไม่นั้นเป็นเรื่องที่ขึ้นอยู่กับมุมมองของผู้สังเกต ดังที่คุณอาจเคยพบมาก่อน เราสามารถเลือกระบบพิกัดของเราได้อย่างอิสระ — $x$, $y$ และ $z$ สามารถชี้ตามทิศทางตั้งฉากสามทิศทางใดก็ได้ ดังนั้น ถ้าเรามีซูเปอร์โพซิชันของ 0 และ 1 ในระบบพิกัดหนึ่ง เราสามารถกำหนดระบบพิกัดใหม่ — หรือเทียบเท่า "measurement basis" ใหม่ — ที่สถานะชี้ตรงตามทิศทาง $+z$ ดังนั้นจึงไม่อยู่ในสถานะซูเปอร์โพซิชัน ดังนั้นเมื่อเราพูดว่า Qubit อยู่ในซูเปอร์โพซิชัน เราต้องตอบคำถามด้วยว่า "ซูเปอร์โพซิชันของ อะไร?"

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

เราจะอภิปรายปัญหาของสิ่งที่เป็น "ธรรมชาติที่แท้จริง" ของสถานะควอนตัม ว่าปรากฏการณ์ควอนตัมของการพัวพันสามารถช่วยให้เราอธิบายสิ่งนี้ได้อย่างไร ในโมดูล Bell's Inequality

คำถาม

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

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

• ในขณะที่การวัด Qubit ในซูเปอร์โพซิชันเป็นแบบน่าจะเป็น เหมือนการโยนเหรียญ แต่สถานะซูเปอร์โพซิชันเองทำงานแตกต่างจากการโยนเหรียญ
• ความแตกต่างสำคัญระหว่างการกระจายความน่าจะเป็นแบบคลาสสิกและซูเปอร์โพซิชันคือซูเปอร์โพซิชันมี coherence ของเฟส ซึ่งช่วยให้มันอินเตอร์เฟียร์แบบสร้างสรรค์หรือทำลายล้าง
• สถานะของ Qubit เดี่ยวที่แยกตัวสามารถมองเห็นได้เป็นจุดบนสิ่งที่เรียกว่า "Bloch sphere" ที่ amplitudes สัมพัทธ์ขององค์ประกอบ $|0\rangle$ และ $|1\rangle$ กำหนดมุมเชิงขั้ว $\theta$ และเฟสสัมพัทธ์ระหว่างสององค์ประกอบกำหนดมุมแอซิมัท $\phi$
• Single-qubit quantum gate ทั้งหมดสามารถมองได้เป็นการหมุนของเวกเตอร์บนทรงกลมนี้

คำถาม T/F:

1. T/F ซูเปอร์โพซิชันควอนตัมโดยพื้นฐานแล้วเหมือนกับเหตุการณ์ความน่าจะเป็นในฟิสิกส์คลาสสิก เช่น การโยนเหรียญ

2. T/F ความยาวของ Bloch vector ที่อธิบายสถานะของ Qubit เดี่ยวที่แยกตัวเป็น 1 เสมอ

3. T/F Single-qubit quantum gate ไม่เปลี่ยนความยาวของ Bloch vector

คำถาม MC:

1. เลือก Bloch vector ที่ถูกต้องที่แสดงสถานะ $|\Psi\rangle = \sqrt{\frac{1}{3}}|0\rangle + e^{i \pi / 4} \sqrt{\frac{2}{3}}|1\rangle$:

2. Bloch sphere อธิบายสิ่งต่อไปนี้ของ Qubit: (เลือกทั้งหมดที่ใช้ได้)

   a. amplitude

   b. การพัวพันกับ Qubit อื่น

   c. เฟส

   d. สี

   e. ความน่าจะเป็นของผลลัพธ์การวัด

คำถามอภิปราย:

1. ทำไมสถานะของ Qubit จึงสามารถมองเห็นได้บน Bloch sphere แต่การกระจายความน่าจะเป็นของการโยนเหรียญไม่สามารถ?

2. ทำไมเหรียญที่โยนอยู่ในอากาศจึงไม่ใช่การเปรียบเทียบที่ดีที่สุดกับสถานะซูเปอร์โพซิชันควอนตัม? แง่มุมใดของซูเปอร์โพซิชันที่ไม่ถูกบันทึกในการเปรียบเทียบนี้?

โจทย์ challenge:

1. ใช้ Qiskit เพื่อสร้าง Circuit ที่แปลงสถานะ $|0\rangle$ เป็นสถานะ $\frac{\sqrt{3}}{2}|0\rangle + \frac{1}{2}e^{i \frac{5\pi}{6}}|1\rangle$