สำรวจความไม่แน่นอน

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

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

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

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

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

# 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

---

บทนำ

คุณคงเคยได้ยินเรื่องหลักความไม่แน่นอนมาบ้าง แม้แต่นอกห้องเรียนฟิสิกส์ คำอธิบายทั่วไปที่มักได้ยินคือ "การที่เราสังเกตสิ่งใดก็ตาม ก็ส่งผลต่อมันอยู่ดี" ซึ่งก็เป็นความจริงอยู่ แต่ในเชิงฟิสิกส์ ความไม่แน่นอนหมายความว่ามีตัวแปรทางกายภาพที่วัดได้บางคู่ที่มีความไม่เข้ากัน ทำให้ไม่สามารถรู้ค่าทั้งสองได้อย่างแม่นยำในเวลาเดียวกัน หลายคนรู้จักคู่ตัวแปรที่ไม่เข้ากันนี้ครั้งแรกในรูปของ $x$ และ $p_x$ คือตำแหน่งบนแกน $x$ และโมเมนตัมเชิงเส้นตามทิศทางนั้น ตามลำดับ สำหรับตัวแปรเหล่านั้น ข้อจำกัดความไม่แน่นอนเขียนได้ว่า $\Delta x \Delta p_x \geq \frac{\hbar}{2}.$ ที่นี่ $\Delta x$ เรียกว่า "ความไม่แน่นอนใน $x$" ซึ่งมีนิยามเดียวกับส่วนเบี่ยงเบนมาตรฐานในสถิติ และสามารถนิยามได้ว่า $\Delta x = \sqrt{\langle x^2 \rangle - \langle x \rangle^2}.$ $\Delta p_x$ นิยามในแบบเดียวกัน ในที่นี้ เราจะไม่อนุมานความสัมพันธ์ความไม่แน่นอนนี้ แต่จะชี้ให้เห็นว่ามันสอดคล้องกับความเข้าใจของเราเกี่ยวกับคลื่นคลาสสิก กล่าวคือ คลื่นที่มีความถี่ $f$ และความยาวคลื่น $\lambda$ ที่แน่นอนเพียงหนึ่งเดียวจะดำเนินต่อไปเป็นอนันต์ในรูปของไซนัสอยด์สมบูรณ์ ในเชิงควอนตัม นี่จะสอดคล้องกับการรู้โมเมนตัมได้อย่างสมบูรณ์ตามสมมติฐานของ de Broglie: $\lambda = h/p$ แต่เพื่อจะรู้ $where$ ว่าอนุภาคที่มีลักษณะเหมือนคลื่นอยู่ที่ไหน คลื่นที่อธิบายมันต้องแคบลงอย่างมากในอวกาศ เช่น เป็น Gaussian แคบมาก เราทราบว่าสามารถแสดงฟังก์ชันต่อเนื่องใด ๆ รวมถึงฟังก์ชันคลื่นที่แคบเช่นนั้น ในรูปอนุกรม Fourier ของฟังก์ชันไซนัสที่มีความยาวคลื่นต่างกัน แต่เมื่อฟังก์ชันคลื่นแคบลงมากขึ้น (และตำแหน่งรู้ดีขึ้น) เราต้องการพจน์มากขึ้นในอนุกรม Fourier หมายความว่ามีความยาวคลื่นหลายค่าผสมกัน (และในเชิงควอนตัม มีค่าโมเมนตัมหลายค่า)

พูดง่าย ๆ คือ สถานะที่มีโมเมนตัมชัดเจน (ไซนัสอยด์สมบูรณ์ในอวกาศ) จะมีความไม่แน่นอนของตำแหน่งสูงมาก ส่วนสถานะที่มีตำแหน่งชัดเจน (เช่น การแจกแจงเดลต้าของ Dirac) จะมีความไม่แน่นอนของโมเมนตัมสูงมาก

ยังมีตัวแปรอื่น ๆ ที่แสดงความไม่เข้ากันแบบนี้ด้วย ตัวอย่างเช่น สปินของอนุภาคอาจมีการฉายที่ชัดเจนบนแกนหนึ่ง แต่เราจะไม่รู้อะไรเลยเกี่ยวกับการฉายบนแกนตั้งฉาก ตัวอย่างเช่น สถานะ $|0\rangle \sim |\uparrow\rangle$ (สำหรับ Qubit หรืออนุภาคสปิน-1/2) มีการฉายที่ชัดเจนบนแกน $z$ (เท่ากับ 1 ในบริบทของ Qubit และเท่ากับ $\hbar/2$ ในบริบทของอนุภาคสปิน-1/2) แต่สถานะนี้สามารถเขียนเป็นการซ้อนทับของสองสถานะที่ต่างก็มีการฉายที่ชัดเจนบนแกน $x$: $|0\rangle = \frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ หรือเขียนแบบเทียบเท่าได้ว่า $\begin{pmatrix} 1 \\ 0\end{pmatrix} = \frac{1}{\sqrt{2}}\left[\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1\end{pmatrix}+\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ -1\end{pmatrix}\right].$ $|+\rangle_x$ มีการฉายที่ชัดเจนบน $x$ เช่นเดียวกับ $|-\rangle_x$ ดังนั้นถ้าเรากำหนดการฉายของสถานะบนแกน $x$ เราจะไม่รู้การฉายบนแกน $z$ และถ้าเรากำหนดการฉายบนแกน $z$ เราก็จะไม่รู้การฉายบน $x$ มีความแตกต่างเล็กน้อยเมื่อพูดถึงบริบทของสปินและ Qubit แต่โดยทั่วไปแล้ว eigenstates ของเมทริกซ์ Pauli มีความสัมพันธ์ที่น่าสนใจที่เราสามารถสำรวจได้ ตลอดบทเรียนนี้ เราจะทดสอบสัญชาตญาณของเราเกี่ยวกับความไม่แน่นอนในตัวแปรที่ไม่เข้ากันเหล่านี้ และตรวจสอบว่าความสัมพันธ์ความไม่แน่นอนยังคงอยู่บนคอมพิวเตอร์ควอนตัมของ IBM®

การตรวจสอบสัญชาตญาณเบื้องต้น

ในการทดลองแรกนี้และตลอดโมดูล เราจะใช้กรอบการทำงานสำหรับการคำนวณควอนตัมที่เรียกว่า "Qiskit patterns" ซึ่งแบ่งกระบวนการทำงานออกเป็นขั้นตอนดังนี้:

• ขั้นตอนที่ 1: แปลง input ในรูปแบบคลาสสิกให้เป็นปัญหาควอนตัม

• ขั้นตอนที่ 2: ปรับปัญหาให้เหมาะสมสำหรับการประมวลผลบนควอนตัม

• ขั้นตอนที่ 3: รันโดยใช้ IBM Quantum primitives

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

โดยทั่วไปเราจะทำตามขั้นตอนเหล่านี้ แม้ว่าจะไม่ได้ระบุชื่อขั้นตอนเสมอไป

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

โค้ดด้านล่างมีส่วนสำหรับบันทึกข้อมูลประจำตัวในการใช้งานครั้งแรก ตรวจสอบให้แน่ใจว่าได้ลบข้อมูลนี้ออกจาก notebook หลังจากบันทึกไว้ในสภาพแวดล้อมของคุณแล้ว เพื่อป้องกันการแชร์ข้อมูลประจำตัวโดยไม่ตั้งใจเมื่อแชร์ notebook ดู Set up your IBM Cloud account และ Initialize the service in an untrusted environment สำหรับคำแนะนำเพิ่มเติม

from numpy import pi

# Load IBM Quantum Compute 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 (
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

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

ibm_sherbrooke

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

# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)
from qiskit_aer.primitives import SamplerV2, EstimatorV2
from qiskit_aer.noise import NoiseModel

# Generate the noise model from the backend properties
noise_model = NoiseModel.from_backend(backend)

noisy_sampler = SamplerV2(options={"backend_options": {"noise_model": noise_model}})
noisy_estimator = EstimatorV2(options={"backend_options": {"noise_model": noise_model}})

คุณน่าจะจำได้ว่า eigenstate ของตัวดำเนินการ Z หนึ่งตัว ไม่ใช่ eigenstate ของตัวดำเนินการ X อีกตัว เราจะสังเกตเรื่องนี้ตอนนี้ โดยการวัดตามแกน $x$ และ $z$ ในทางทดลอง สำหรับการวัดตามแกน $z$ เราใช้ qc.measure() เพราะคอมพิวเตอร์ควอนตัม IBM ออกแบบมาให้วัดตามแกน $z$ แต่สำหรับการวัดตามแกน $x$ เราต้องหมุนระบบเพื่อย้ายแกน $x$ ให้ขึ้นมาอยู่ในทิศทางที่เราวัด ทำได้ด้วย Hadamard Gate และต้องทำขั้นตอนคล้ายกันสำหรับการวัดตามแกน $y$ รวบรวมขั้นตอนที่จำเป็นไว้ที่นี่เพื่อความสะดวก:

• การวัดตามแกน $z$: qc.measure()

• การวัดตามแกน $x$: qc.h() แล้ว qc.measure()

• การวัดตามแกน $y$: qc.sdg(), qc.h(), qc.sแล้ว qc.measure()

ขั้นตอนที่ 1: แปลง input คลาสสิกให้เป็นปัญหาควอนตัม

ในกรณีนี้ ขั้นตอนการแปลงก็แค่แสดงการวัดและการหมุนที่อธิบายข้างต้นใน Circuit ควอนตัม:

# Step 1: Map

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

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Add a first measurement
qc.measure(qr, cr[0])
qc.barrier()

# Change basis so that measurements made on quantum computer which normally tell us about z,
# now tell us about x.
qc.h(qr)

# Add a second measurement
qc.measure(qr, cr[1])

qc.draw("mpl")

ขั้นตอนที่ 2: ปรับปัญหาให้เหมาะสมสำหรับการประมวลผลบนควอนตัม

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

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

ขั้นตอนที่ 3: รันโดยใช้ IBM Quantum primitives

เราสามารถใช้ Sampler เพื่อเก็บสถิติของการวัดได้ เราจะสร้าง Sampler primitive ให้รันบนคอมพิวเตอร์ควอนตัมจริงโดยใช้ mode = backend มีโหมดอื่น ๆ สำหรับกระบวนการทำงานอื่น และเราจะใช้หนึ่งในนั้นด้านล่าง Sampler จะถูกเรียกใช้ผ่านเมธอด run() พร้อมกับรายการ "pubs" (Primitive Unified Blocs) แต่ละ PUB ประกอบด้วยค่าสูงสุดสามค่าที่รวมกันกำหนดหน่วยการคำนวณสำหรับ Estimator: Circuits, observables, parameters คุณยังระบุรายการ Circuit, รายการ observables และรายการ parameters ได้ด้วย สำหรับข้อมูลเพิ่มเติม อ่าน Overview of PUBs.

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

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

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()

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

# Run the job on the Aer simulator with noise model from real backend

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

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

นี่เป็นกรณีการประมวลผลหลังที่เรียบง่ายมาก เราแค่แสดงผลจำนวนนับเป็นภาพ

โปรดทราบว่า Qiskit เรียงลำดับ Qubit, การวัด และสิ่งอื่น ๆ โดยวางรายการที่มีหมายเลขต่ำสุดไว้ท้าย/ทางขวา ซึ่งเรียกว่าระบบ "little-endian" หมายความว่าคอลัมน์ที่มีป้ายกำกับว่า "10" ด้านล่างหมายถึงจำนวนนับที่การวัดครั้งแรกได้ "0" และการวัดครั้งที่สองได้ "1"

# Step 4: Post-process

from qiskit.visualization import plot_histogram

plot_histogram(counts)

ถ้าการนิยามนี้ไม่ถูกใจคุณ คุณสามารถใช้ marginal_counts เพื่อแสดงผลของแต่ละการวัดแยกกันได้:

from qiskit.result import marginal_counts

plot_histogram(
    marginal_counts(counts, indices=[0]), title="Counts after first measurement"
)

plot_histogram(
    marginal_counts(counts, indices=[1]), title="Counts after second measurement"
)

ค่าเริ่มต้นใน Qiskit จะอยู่ในสถานะ $|0\rangle$ จึงไม่น่าแปลกใจที่การวัดครั้งแรกแทบทั้งหมดได้ผลเป็น $|0\rangle$ อย่างไรก็ตาม สังเกตว่าการวัดครั้งที่สอง (ที่ให้ข้อมูลเกี่ยวกับการฉายของสถานะบน $x$) แทบจะแบ่งครึ่งเท่ากัน ดูเหมือนว่าสถานะที่ให้ผลการวัดตามแกน $z$ ที่คาดเดาได้มาก จะให้ผลการวัดตามแกน $x$ ที่คาดเดาได้น้อยมาก มาสำรวจเรื่องนี้กัน

จะเกิดอะไรขึ้นถ้าเปลี่ยนลำดับการวัด เราอาจเริ่มด้วยการใช้ Hadamard Gate เพื่อหาสถิติความน่าจะเป็นของ $|0\rangle$ ที่ถูกวัดใน $|\pm\rangle_x$ แล้วสำหรับการวัดครั้งที่สอง เราจะเปลี่ยนกลับมาที่ฐาน $z$ โดยใช้ Hadamard Gate ตัวที่สอง

# Step 1:

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Change basis to measure along x.
qc.h(qr)
qc.measure(qr, cr[0])
qc.barrier()

# Change our basis back to z and make a second measurement
qc.h(qr)
qc.measure(qr, cr[1])

qc.draw("mpl")

# Step 2: Transpile the circuit for running on a quantum computer

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

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

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()
counts = res[0].data.c.get_counts()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_sampler.run([qc_isa])
# res=job.result()
# counts=res[0].data.c.get_counts()

# Step 4: Post-process
from qiskit.visualization import plot_histogram

plot_histogram(counts)

ในที่นี้ ดูเหมือนว่าเราจะมีความไม่แน่นอนมากยิ่งกว่าเดิม! ก่อนหน้านี้อย่างน้อยเรารู้ว่าผลลัพธ์ของการวัดครั้งแรกจะเป็นอะไร แต่ตอนนี้ได้การกระจายที่ค่อนข้างสม่ำเสมอทั่วทุกสถานะที่เป็นไปได้ ไม่ยากที่จะเห็นว่าทำไมถึงเกิดขึ้นเช่นนี้ เราเริ่มจากสถานะ $|0\rangle$ ซึ่งเป็นการผสม 50-50 ของ $|+\rangle_x$ และ $|-\rangle_x$ ตาม $|0\rangle=\frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ จึงควรมีความน่าจะเป็นเท่ากันในการได้สถานะ + หรือ - (แมปเป็น 0 และ 1 ในแผนภูมิ) สำหรับการวัดครั้งแรก การวัดตามแกน $x$ ทำให้สถานะยุบตัวลงเป็น eigenstate $|+\rangle_x$ หรือ eigenstate $|-\rangle_x$ แต่ละสถานะเหล่านั้นเป็นการผสม 50-50 ของ $|0\rangle$ และ $|1\rangle$ ตาม $|+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ $|-\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$ ดังนั้นเมื่อระบบอยู่ใน eigenstate ของ $x$ แล้ว การวัดตามแกน $z$ จะได้ทั้ง $|0\rangle$ และ $|1\rangle$ ด้วยความน่าจะเป็นเกือบเท่ากัน ตัวอย่างแรกแสดงให้เราเห็นว่าสถานะบางสถานะจะให้ผลลัพธ์ที่คาดเดาได้มากสำหรับการวัดบางอย่าง แต่คาดเดาไม่ได้สำหรับการวัดอื่น ตัวอย่างปัจจุบันแสดงให้เห็นว่าเราสามารถทำได้แย่กว่านั้น มีสถานะที่ให้ผลลัพธ์ที่คาดเดาไม่ได้สำหรับการวัดทั้งสอง แม้ว่าสิ่งที่เราทำจะเป็นแค่การสลับลำดับการวัด มาศึกษาว่าปริมาณหนึ่ง ๆ มีความแน่นอนหรือไม่แน่นอนแค่ไหนสำหรับสถานะที่กำหนด

การคำนวณความไม่แน่นอน

เราสามารถวัดค่านี้เชิงปริมาณได้โดยใช้ความไม่แน่นอน หรือความแปรปรวน "ความไม่แน่นอน" มักนิยามให้เป็นรากที่สองของ "ความแปรปรวน" ของการกระจาย กล่าวคือ ความไม่แน่นอนสำหรับ observable $S$ บางตัว แทนด้วย $\Delta S$ และให้ค่าดังนี้

$$\begin{aligned} (\Delta S)^2 & \equiv \langle (S - \langle S \rangle)^2 \rangle\\ (\Delta S)^2 & = \langle S^2 - 2 S \langle S \rangle +\langle S \rangle^2 \rangle\\ (\Delta S)^2 & = \langle S^2 \rangle - \langle S \rangle^2 \end{aligned}$$

สำหรับกรณีของเมทริกซ์ Pauli ที่ $S^2 = I$ จะได้ว่า

$$(\Delta S)^2 = 1 - \langle S \rangle^2$$

มาประยุกต์ใช้กับตัวอย่างที่เป็นรูปธรรม เริ่มด้วยสถานะ $|\psi\rangle = |+\rangle_y = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ i \end{pmatrix}$, และหาความไม่แน่นอนของ observable $X$ ในสถานะนั้น

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

คำนวณความไม่แน่นอนของ $X$ ในสถานะ $|+\rangle_y = |+i\rangle$ ด้วยมือ

คำตอบ

$$\Delta X =\sqrt{\langle+i| X^2 |+i\rangle - \langle+i| X |+i\rangle^2}$$

In the given state, this yields:

$$\begin{aligned} \Delta X & =\sqrt{\frac{1}{\sqrt{2}}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ i\end{pmatrix} - \left(\frac{1}{\sqrt{2}}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ i\end{pmatrix}\right)^2}\\ \Delta X & =\sqrt{\frac{1}{2}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}1 & 0 \\ 0 & 1\end{pmatrix} \begin{pmatrix}1 \\ i\end{pmatrix} - \left(\frac{1}{2}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}i \\ 1\end{pmatrix}\right)^2}\\ \Delta X & =\sqrt{\frac{1}{2}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}1 \\ i\end{pmatrix} - \left(\frac{1}{2}(0))\right)^2}\\ \Delta X & =\sqrt{\frac{1}{2}(2)} = 1 \end{aligned}$$

เราสามารถสร้างสถานะเริ่มต้นแบบใดก็ได้โดยใช้ qc.initialize() โปรดสังเกตว่าไวยากรณ์สำหรับหน่วยจินตภาพในที่นี้คือ $1j$

# Step 1: Map the problem into a quantum circuit

from qiskit.quantum_info import SparsePauliOp
import numpy as np

obs = SparsePauliOp("X")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
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 = noisy_estimator.run([[qc_isa,obs_isa]])
# res=job.result()

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

print(res[0].data.evs)

-0.02408454165642664

ตามสมการข้างต้นของเรา $(\Delta X)^2 = 1 - \langle X \rangle^2 = 1-(0.0015...)^2 \rightarrow \Delta X = 0.999...$ มาใช้สถานะเดิมนั้นต่อไป แต่คราวนี้หาค่าคาดหวังของ $Z$ กัน:

# Step 1: Map the problem into a quantum circuit

obs = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state to |+>_y
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
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(pubs)
res = job.result()

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

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

print(res[0].data.evs)

0.04958271968581247

เราสามารถทำการคำนวณแบบเดียวกับก่อนหน้านี้ได้ แต่จะเห็นว่าความแปรปรวนนั้นใกล้เคียงกับ 1.0 อีกครั้ง เราสามารถสรุปได้ว่า $\Delta X \Delta Z \approx 1.0$ ซึ่งถูกต้องโดยประมาณสำหรับสถานะที่เราเลือก แต่เราจะทำได้ดีกว่านี้ไหม หรือแย่กว่านี้?

จำได้ไหมว่ามีความสัมพันธ์ความไม่แน่นอนระหว่างตำแหน่งตามทิศทางหนึ่ง $x,$ กับโมเมนตัมตามทิศทางเดียวกัน $p_x.$ สำหรับตัวแปรเหล่านั้น รูปแบบที่คุ้นเคยที่สุดน่าจะเป็น $\Delta x \Delta p_x \geq \hbar/2$ ถ้านี่คือทั้งหมดที่เราจำได้ เราอาจถูกล่อใจให้คิดว่า $\Delta X$ และ $\Delta Z$ ก็อาจมีขีดจำกัดพื้นฐานของความไม่แน่นอนแบบนี้เช่นกัน บางทีผลคูณ $\Delta X \Delta Z$ อาจไม่มีทางลดลงถึงศูนย์ได้เลย? มาลองสถานะอื่นดูว่าจะเป็นแบบนี้หรือไม่ ครั้งนี้เราจะใช้ $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ มาดูกันว่าจะเกิดอะไรขึ้น โปรดสังเกตว่าในโค้ดด้านล่าง estimator สามารถรับชุดของ circuit และ observable สองชุดในการส่งงานเดียวกันได้

# Step 1: Map the problem into a quantum circuit

obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Z")

# Define registers

qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1] / np.sqrt(2))

# Step 2: Transpile the circuit

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

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

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]
    job = estimator.run(pubs)
    res = job.result()
batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])
# res=job.result()

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

print("The expectation value of the first observable is: ", res[0].data.evs)
print("The expectation value of the second observable is: ", res[1].data.evs)

The expectation value of the first observable is:  1.0011036174126302
The expectation value of the second observable is:  0.0029429797670141016

ค่าคาดหวังของ $X$ ควรใกล้เคียงกับ 1.0 แต่ไม่ควรเกิน 1.0 ไม่ต้องกังวลถ้ามันเกิน 1.0 ไปเล็กน้อยมาก ๆ สาเหตุอาจมาจากปัจจัยอย่างสัญญาณรบกวนและ/หรือความผิดพลาดในการอ่านค่า (readout error) แม้ว่านี่จะเป็นหัวข้อที่สำคัญมาก แต่ตอนนี้เราจะข้ามไปก่อน

เราได้ค่าคาดหวังของ $X$ ที่ใกล้เคียงกับ 1.0 มาก (ซึ่งสอดคล้องกับความแปรปรวนที่ต่ำมากสำหรับ $X$) สิ่งนี้ทำให้ผลคูณของความแปรปรวนทั้งสองค่านั้นต่ำมาก:

$$\Delta X \Delta Z = \sqrt{1-(0.9853)^2} \times \sqrt{1-(-0.00195)^2} = 0.171.$$

แม้ว่าค่านี้จะไม่ได้เป็นศูนย์พอดี แต่ค่านี้ก็เล็กลงเมื่อเทียบกับค่าไอเกนของตัวดำเนินการ Pauli ($\pm 1$) คุณอาจจำได้ว่าความสัมพันธ์ความไม่แน่นอนระหว่างตำแหน่งเชิงเส้นและโมเมนตัมสามารถเขียนได้แตกต่างออกไป โดยใช้ความสัมพันธ์การสลับที่ (commutation) ระหว่างตัวดำเนินการ $x$ และ $p_x$ อย่างชัดเจน:

$$\Delta x \Delta p_x \geq \frac{1}{2}|\langle [x,p_x] \rangle|$$

where

$$[x,p_x] = xp_x-p_xx$$

คือ commutator ของ $x$ และ $p_x$

นี่คือรูปแบบที่สามารถขยายไปสู่ตัวดำเนินการ Pauli ได้ง่ายที่สุด โดยทั่วไปแล้ว สำหรับตัวดำเนินการสองตัว $A$ และ $B$,

$$\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$$

และในกรณีของเมทริกซ์ Pauli $X$ และ $Z$ เราต้องใช้ $[X,Z]$ เพื่อคำนวณ

$$\Delta X \Delta Z \geq \frac{1}{2}|\langle [X,Z] \rangle|.$$

เราจะแสดงให้เห็นตรงนี้ และปล่อยให้การคำนวณที่คล้ายกันเป็นแบบฝึกหัดสำหรับผู้อ่าน:

$$[X,Z] = XZ-ZX = \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix}\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}-\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}\begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix}$$ $$[X,Z] = \begin{pmatrix}0 & -1 \\ 1 & 0\end{pmatrix}-\begin{pmatrix}0 & 1 \\ -1 & 0\end{pmatrix} = 2\begin{pmatrix}0 & -1 \\ 1 & 0\end{pmatrix}$$

นี่เป็นคำตอบที่ยอมรับได้อย่างสมบูรณ์ แต่ด้วยอีกขั้นตอนหนึ่ง เราจะเห็นว่า

$$[X,Z] = -2i\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}=-2iY$$

ความสัมพันธ์ความไม่แน่นอนของเราจึงกลายเป็น

$$\Delta X \Delta Z \geq |\langle Y \rangle|.$$

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

หา $[X,Y]$ และ $[Y,Z]$ ใช้ผลที่ได้เพื่อเขียนความสัมพันธ์ความไม่แน่นอนระหว่าง $X$ & $Y$ และ $Y$ & $Z$

คำตอบ

$$[X,Y] = XY-YX = \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix}\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}-\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} = 2 \begin{pmatrix}i & 0 \\ 0 & -i\end{pmatrix}=2iZ$$$$[Y,Z] = YZ-ZY = \begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}-\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix} = 2 \begin{pmatrix}0 & i \\ i & 0\end{pmatrix}=2iX$$

รวมกับความสัมพันธ์ความไม่แน่นอนทั่วไป จะได้

$$\Delta X \Delta Y \geq |\langle Z \rangle|,$$$$\Delta Y \Delta Z \geq |\langle X \rangle|.$$

ตรวจสอบความสอดคล้อง

ก่อนจะดำเนินต่อ มาตรวจสอบว่าสอดคล้องกับผลที่ได้ก่อนหน้า เราใช้สถานะ $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}$. และพบว่า $\Delta X \Delta Z = 0.171$. ตอนนี้เราทราบว่าผลคูณนี้ควรมากกว่าหรือเท่ากับ

$$|\langle Y \rangle|=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \end{pmatrix}\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}$$ $$|\langle Y \rangle| = \frac{1}{2}\begin{pmatrix} 1 & 1 \end{pmatrix}\begin{pmatrix} -i \\ i \end{pmatrix} = \frac{1}{2}(-i+i) = 0.$$

ดังนั้น $\Delta X \Delta Z = 0.171 \geq |\langle Y \rangle|=0$ แน่นอน ใช้คำถามด้านล่างเพื่อสร้างสัญชาตญาณสำหรับผลลัพธ์เหล่านี้:

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

ตอบรายการต่อไปนี้ร่วมกันเป็นชุด:

(a) คุณคาดว่าสถานะใดจะมีความไม่แน่นอนศูนย์ใน $X$?

(b) คุณคาดว่าสถานะใดจะมีความไม่แน่นอนศูนย์ใน $Z$?

(c) ในสถานะใดที่คุณจะได้ค่าคาดหวัง $\langle Y \rangle$ เป็นศูนย์?

(d) คำตอบของคำถามข้างต้นสอดคล้องกับกรณี $\Delta X \Delta Z \geq |\langle Y \rangle|$ หรือไม่?

(e) เขียนโค้ดเพื่อตรวจสอบนี้อย่างชัดเจนโดยใช้ Estimator

คำตอบ

(a) เราอาจคาดว่า eigenstates ของตัวดำเนินการ $X$ จะให้ความไม่แน่นอนเป็นศูนย์ใน $X$ จริง ๆ โดยใช้ $|\psi\rangle = |+\rangle_x$, เราได้ $\Delta X = \sqrt{1-\langle X \rangle^2} = \sqrt{1-1^2} = 0.$

(b) เราอาจคาดว่า eigenstates ของตัวดำเนินการ $Z$ จะให้ความไม่แน่นอนเป็นศูนย์ใน $Z$ จริง ๆ โดยใช้ $|\psi\rangle = |1\rangle$, เราได้ $\Delta Z = \sqrt{1-\langle Z \rangle^2} = \sqrt{1-(-1)^2} = 0.$

(c) เราคาดว่าจะพบ $\langle Y \rangle=0$ สำหรับสถานะใด ๆ ที่เมื่อวัดแล้วให้การฉายบวกบนแกน $y$ บ่อยพอ ๆ กับการฉายลบ ซึ่งรวมถึง eigenstates ของ $X$ และ $Z$

(d) ใช่ คาดว่าผลคูณของความไม่แน่นอน $\Delta X \Delta Z$ จะมีค่าน้อยมากสำหรับ eigenstates ของ $X$ หรือ $Z$: $\Delta X \Delta Z \approx 0$ สิ่งนี้สามารถเป็นจริงได้เพราะเราจะคาดว่า $\langle Y \rangle=0$ สำหรับสถานะเดียวกันนั้นด้วย ดังนั้นความสัมพันธ์ความไม่แน่นอนจึงสามารถเป็นจริงได้

(e) โค้ดเช่นต่อไปนี้จะตรวจสอบนี้ได้:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.ry(pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

ซึ่งผลลัพธ์จะคืนค่าคาดหวังทั้งหมด เพื่อดึงค่าคาดหวังทั้งหมดและคำนวณความไม่แน่นอน เราสามารถใช้:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

ตอบรายการต่อไปนี้ร่วมกันเป็นชุด:

(a) คุณนึกถึงสถานะที่มีค่าคาดหวัง $\langle Y \rangle$ สูงได้ไหม?

(b) คุณคาดว่าสถานะเดียวกันนั้นจะมีความไม่แน่นอนใน $X$ มากหรือน้อย?

(c) คุณคาดว่าสถานะเดียวกันนั้นจะมีความไม่แน่นอนใน $Z$ มากหรือน้อย?

(d) คำตอบของคำถามข้างต้นสอดคล้องกับกรณี $\Delta X \Delta Z \geq |\langle Y \rangle|$ หรือไม่?

(e) เขียนโค้ดเพื่อตรวจสอบนี้อย่างชัดเจนโดยใช้ Estimator

คำตอบ

(a) เราคาดว่าจะพบ $\langle Y \rangle\approx 1$ สำหรับ eigenstate ของ $Y$: $|+\rangle_y$

(b) เราอาจคาดว่า $X$ จะมีความไม่แน่นอนสูงในสถานะ $|+\rangle_y$, เนื่องจากการวัด $X$ ในสถานะนั้นจะให้ผลบวกและผลลบด้วยความถี่/ความน่าจะเป็นเท่ากัน

(c) เราอาจคาดว่า $Z$ จะมีความไม่แน่นอนสูงในสถานะ $|+\rangle_y$, เนื่องจากการวัด $Z$ ในสถานะนั้นจะให้ผลบวกและผลลบด้วยความถี่/ความน่าจะเป็นเท่ากัน

(d) ใช่ คาดว่าผลคูณของความไม่แน่นอน $\Delta X \Delta Z$ จะมีค่ามากสำหรับ eigenstates ของ $Y$ และสำหรับ $|+\rangle_y$ โดยเฉพาะ นอกจากนี้เราจะคาดว่า $\langle Y \rangle\approx 1$ สำหรับสถานะเดียวกันนั้น ดังนั้นทั้ง $\langle Y \rangle$ และ $\Delta X \Delta Z$ มีค่าค่อนข้างมากในสถานะนี้ และเป็นไปได้ที่ความสัมพันธ์ความไม่แน่นอนจะยังคงเป็นจริงได้อีกครั้ง

(e) โค้ดเช่นต่อไปนี้จะตรวจสอบนี้ได้:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.rx(-pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

ซึ่งผลลัพธ์จะคืนค่าคาดหวังทั้งหมด เพื่อดึงค่าคาดหวังทั้งหมดและคำนวณความไม่แน่นอน เราสามารถใช้:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

การทดสอบความสัมพันธ์ความไม่แน่นอน

การทดสอบข้างต้นแสดงให้เห็นความถูกต้องของความสัมพันธ์ความไม่แน่นอนสำหรับเวกเตอร์สถานะเพียงตัวเดียว $|\psi\rangle = |+\rangle_x$ เท่านั้น เพื่อให้มั่นใจว่าสอดคล้องกับการทดลองโดยทั่วไป เราควรทำการคำนวณคล้ายกันโดยใช้ Estimator สำหรับตัวเลือกเวกเตอร์สถานะหลาย ๆ แบบ มาเริ่มด้วยการหมุนเวกเตอร์สถานะให้ออกจากแกน $z$ โดยใช้ Gate RY เพื่อสร้างสถานะเริ่มต้นต่าง ๆ โดยใช้พารามิเตอร์ $\theta$

# The calculation below uses approximately 3-4 minutes of QPU time.
# Step 1: Map the problem into a quantum circuit

from qiskit.circuit import Parameter
import numpy as np

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0>
theta = Parameter("θ")
qc.ry(theta, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
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

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

สังเกตว่าเส้นโค้งสีแดง $(\Delta X \Delta Z)$ มีค่ามากกว่าเส้นโค้งสีส้ม $\langle Y \rangle$ เสมอ บางครั้งผลคูณความไม่แน่นอนลดลงและใกล้ขีดจำกัด บางครั้งก็เพิ่มขึ้นและห่างจากขีดจำกัด แต่มันปฏิบัติตามความสัมพันธ์ความไม่แน่นอนเสมอ

แน่นอนว่านี่อาจไม่ใช่การทดสอบที่ดีที่สุดสำหรับความสัมพันธ์ความไม่แน่นอน เนื่องจากขีดจำกัด $\langle Y \rangle$ อยู่ใกล้ศูนย์มากเสมอ มาใช้สถานะควอนตัมที่มีการฉายบน eigenstates ของ $Y$ มากกว่า โดยเฉพาะ เราจะยังคงหมุน $|0\rangle$ ลงจากแกน $z$ ด้วยมุมต่าง ๆ แต่คราวนี้จะหมุนสถานะที่ได้รอบ $z$ ด้วยมุมหนึ่ง เช่น $\pi/4$ และดูว่าจะเกิดอะไรขึ้น

# The calculation below uses approximately 3-4 minutes of QPU time.
from qiskit.circuit import Parameter
import numpy as np

# Step 1: Map the problem to a quantum circuit

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0> along one plane, and then along a transverse direction.
theta = Parameter("θ")
qc.ry(theta, 0)
qc.rz(pi / 4, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

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

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

ตอนนี้เราเห็นว่าขีดจำกัดของความไม่แน่นอน $(\Delta X \Delta Z)$ กำลังถูกทดสอบ! เส้นโค้งสีแดงเข้าใกล้เส้นโค้งสีส้มมากกว่าก่อนหน้ามาก จริง ๆ แล้ว ในกรณีที่ไม่มีสัญญาณรบกวน ความสัมพันธ์ความไม่แน่นอนจะเท่ากันพอดี ($(\Delta X \Delta Z) = \langle Y \rangle$) ที่จุดหนึ่ง เมื่อมีสัญญาณรบกวนและ readout error ไม่ควรแปลกใจถ้าการรันบางครั้งได้ $(\Delta X \Delta Z)$ มากกว่า $\langle Y \rangle$ เล็กน้อย นี่ไม่ใช่การละเมิดความไม่แน่นอนจริง ๆ แต่เป็นเพียงผลจากความผิดพลาดที่ไม่เป็นศูนย์

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

อธิบายว่าคุณจะผลักให้ถึงขีดจำกัดสูงสุดได้อย่างไร เพื่อให้ $\langle Y \rangle$ มีค่ามากที่สุดเท่าที่จะเป็นไปได้?

คำตอบ

โค้ดปัจจุบันมีบรรทัดที่หมุนสถานะเริ่มต้น $|0\rangle$ ลงจากแกน $z$ ด้วยมุมพารามิเตอร์ $\theta$ และยังหมุนสถานะเวกเตอร์นั้นรอบแกน $z$ ด้วยมุม $\pi/4$ ซึ่งหมุนสถานะเวกเตอร์ไปบางส่วนในทิศทางของแกน $y$

qc.ry(theta,0)

qc.rz(pi/4,0)

เราสามารถเปลี่ยนการหมุนรอบ $z$ จาก $\pi/4$ เป็น $\pi/2$ เพื่อหมุนไปจนถึง eigenstate ของ $Y$ อย่างสมบูรณ์:

qc.ry(theta,0)

qc.rz(pi/2,0)

ไม่ต้องเปลี่ยนแปลงอะไรอีก

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

คำตอบ

เราจะใช้โค้ดจากตัวอย่างข้างต้นทุกประการ โดยแทน

qc.rz(pi/2,0)

แทน

qc.rz(pi/4,0).

ผลลัพธ์ควรมีลักษณะเหมือนด้านล่าง และใช่ หลักความไม่แน่นอนควรยังคงถูกต้อง

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

คำตอบ

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

xs=res[0].data.evs[0]
ys=res[0].data.evs[1]
zs=abs(res[0].data.evs[2])
import math
delx = []
dely = []
prodxy=[]
for i in range(len(xs)):
    delx.append((1-xs[i]*xs[i])**0.5)
    dely.append((1-ys[i]*ys[i])**0.5)
    prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)

และเราสามารถพล็อต

import matplotlib.pyplot as plt
plt.plot(params, delx, label=r'$\Delta$ X')
plt.plot(params, dely, label=r'$\langle$ Y $\rangle$')
plt.plot(params, zs, label=r'$\Delta$ Z')
plt.plot(params, prodxy, label=r'$\Delta$X $\Delta$Z')
plt.xlabel(r'$\theta$')
plt.ylabel('Expectation/Uncertainty Values')
plt.legend()
plt.show()

ความท้าทาย: เขียนโค้ดเพื่อสแกนผ่านค่า $\phi$ หลาย ๆ ค่า เช่นเดียวกับที่เราสแกนผ่านค่า $\theta$ และสร้างพล็อต 3 มิติที่แสดงว่าความสัมพันธ์ความไม่แน่นอนไม่เคยถูกละเมิด เลือก observables ใดก็ได้ที่คุณต้องการ

คำถาม

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

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

• มีความสัมพันธ์ความไม่แน่นอนระหว่างชุดของตัวแปรทางกายภาพหลายชุด รวมถึงตำแหน่งและโมเมนตัมเชิงเส้น และส่วนประกอบของสปิน

• เมทริกซ์ Pauli ไม่สับเปลี่ยน นี่คือการสะท้อนทางคณิตศาสตร์ของความจริงที่ว่าไม่สามารถรู้/กำหนดส่วนประกอบทั้งหมดของสปินพร้อมกันได้

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

• สูตรทั่วไปสำหรับความไม่แน่นอนของตัวดำเนินการสองตัว $A$ และ $B$ คือ $\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$

• eigenstate $|a\rangle$ ของตัวดำเนินการ $A$ บางตัว ให้ความไม่แน่นอนเป็นศูนย์ใน observable ทางกายภาพที่เกี่ยวข้องกับตัวดำเนินการนั้น แม้แต่ในเชิงทดลอง $\Delta A \approx 0.$

• eigenstate $|a\rangle$ ของตัวดำเนินการ $A$ บางตัว จะให้ความไม่แน่นอนมากขึ้นสำหรับตัวดำเนินการ $B$ ที่ไม่สับเปลี่ยนกับ $A$

• ผลการทดลองโดยใช้คอมพิวเตอร์ควอนตัมจริงยืนยันสัญชาตญาณที่เราได้จากการแทนค่าเมทริกซ์ของตัวดำเนินการทางกายภาพ

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

1. จริง/เท็จ สามารถวัด $X$ และ $Y$ พร้อมกันได้ แต่ไม่ใช่ $Z$

2. จริง/เท็จ สามารถวัด $X$ และ $Z$ พร้อมกันได้ แต่ไม่ใช่ $Y$

3. จริง/เท็จ ตัวดำเนินการตำแหน่งเชิงเส้นและโมเมนตัมเชิงเส้นไม่สับเปลี่ยน

4. จริง/เท็จ คอมพิวเตอร์ควอนตัม IBM วัดตาม $Z$ โดยค่าเริ่มต้น ดังนั้นต้องหมุนเพื่อวัดตามทิศทางอื่น

5. จริง/เท็จ โดยผลแล้ว Circuit ด้านล่างเท่ากับการวัด $Z$ แล้ววัด $X$

คำถามแบบเลือกตอบ:

1. แผนภาพด้านล่างแสดงให้เห็นความสัมพันธ์ความไม่แน่นอนข้อใดต่อไปนี้?

   • a. $\Delta X \Delta Y \geq |\langle Z \rangle|$

   • b. $\Delta Y \Delta Z \geq |\langle X \rangle|$

   • c. $\Delta Z \Delta X \geq |\langle Y \rangle|$

   • d. ไม่มีข้อใดถูกต้อง

2. ลำดับมาตรฐานในการวัดตามแกน $x$ คือข้อใดต่อไปนี้?

   • a. เฉพาะ qc.measure()

   • b. qc.h() แล้ว qc.measure()

   • c. qc.h(), qc.h() แล้ว qc.measure()

   • d. qc.h(), qc.s, qc.h()แล้ว qc.measure()

   • e. qc.sdg(), qc.h(), qc.s แล้ว qc.measure()

   • f. qc.sdg(), qc.h(), qc.s, qc.h() แล้ว qc.measure()

3. สถานะใดต่อไปนี้ให้ค่าคาดหวังสูงสุด $\langle X \rangle$?

   • a. $|+\rangle_x$

   • b. $|-\rangle_x$

   • c. $|+\rangle_y$ หรือเรียกว่า $|+i\rangle$

   • d. $|-\rangle_y$ หรือเรียกว่า $|-i\rangle$

   • e. $|0\rangle$ หรือเรียกว่า $|\uparrow\rangle$

   • f. $|1\rangle$ หรือเรียกว่า $|\downarrow\rangle$

4. สถานะใดต่อไปนี้ให้ความไม่แน่นอนสูงสุด $\Delta X$?

   • a. $|+\rangle_x$

   • b. $|+\rangle_y$ หรือเรียกว่า $|+i\rangle$

   • c. $|0\rangle$ หรือเรียกว่า $|\uparrow\rangle$

   • d. a และ b เท่ากัน

   • e. b และ c เท่ากัน

   • f. a, b และ c เท่ากัน

คำถามสำหรับอภิปราย:

1. แนวคิดเรื่องความไม่แน่นอนนี้ขัดแย้งกับมโนทัศน์ของสปินในรูปของลูกศรเวกเตอร์ในปริภูมิคาร์ทีเซียนไหม? แล้วบน Bloch sphere ล่ะ?

2. สมมติว่าคุณวางอุปกรณ์วัดตามทิศทางกึ่งกลางระหว่างแกน $x$ และ $y$ จะเกิดอะไรขึ้น? คุณสามารถวัดตามทิศทางนั้นได้ไหม? สิ่งนี้เกี่ยวข้องกับความไม่แน่นอนใน $X$ และ $Y$ อย่างไร?

3. คุณต้องการทำการทดลองเพิ่มเติมอะไรบ้างเพื่อโน้มน้าวตัวเองเกี่ยวกับผลลัพธ์ที่ได้ที่นี่?