מטבעות קוונטיים — מודול על סופרפוזיציה והתאבכות

במודול Qiskit in Classrooms הזה, התלמידים צריכים סביבת Python פועלת עם החבילות הבאות מותקנות:

• qiskit v2.1.0 או חדש יותר
• qiskit-ibm-runtime v0.40.1 או חדש יותר
• qiskit-aer v0.17.0 או חדש יותר
• qiskit.visualization
• numpy
• pylatexenc

להגדרת הסביבה והתקנת החבילות שלמעלה, ראו את המדריך התקנת Qiskit. כדי להריץ עבודות על מחשבים קוונטיים אמיתיים, התלמידים יצטרכו להגדיר חשבון ב-IBM Quantum® לפי השלבים במדריך הגדרת חשבון IBM Cloud שלך.

המודול הזה נבדק והשתמש ב-47 שניות של זמן QPU. זו הערכה בלבד. השימוש בפועל שלך עשוי להשתנות.

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

צפו בהדרכת המודול של ד"ר קייטי מקורמיק למטה, או לחצו כאן לצפייה ב-YouTube.

---

מבוא

במודול הזה, נחקור אחד מהעקרונות המרכזיים שבלב התיאוריה הקוונטית: סופרפוזיציה. בחוויה היומיומית שלנו, לאובייקטים תמיד יש תכונות מוגדרות. מיקומם, גודלם, צורתם, צבעם — הכל בנוגע אליהם — קבוע וודאי, גם אם אנחנו המתבוננים עדיין לא מדדנו אותם. בעולם הקוונטי, זה לא בהכרח המצב. אובייקט קוונטי יכול להיות במשהו שנקרא "סופרפוזיציה" של מספר מצבים קלאסיים מותרים. כשמודדים את הסופרפוזיציה, היא "תתמוטט" באקראיות לאחד מאותם מצבים.

במובנים מסוימים, מדידת מצב סופרפוזיציה דומה להטלת מטבע: אין שום דרך לדעת מראש לאיזה כיוון הוא ינחת. אי-הוודאות הבסיסית הזו היא היבט מטריד של מכניקת הקוונטים שאפילו לאיינשטיין היה קשה איתו. הוא אמר בפירוש, "אלוהים לא משחק בקוביות" על האקראיות הזו. אבל, כפי שנראה, אלוהים אכן משחק בקוביות — ומטיל מטבעות.

אנחנו הולכים לחשוב על הטלת מטבע קלאסית כאנלוגיה למדידת מצב סופרפוזיציה. ו — על ידי משחק עם "מטבע קוונטי" באמצעות Qiskit וQubit על מעבד קוונטי של IBM® — נגלה במהירה את מגבלות האנלוגיה הזו.

מטבע קלאסי

בואו נתחיל עם מטבע קלאסי. זורקים מטבע, והוא ינחת בין עץ-למעלה לעץ-למטה, עם סיכוי של 50$~$% לכל אחד. בעוד שעקרונית, ניתן לחשב לאיזה צד ינחת המטבע אם מישהו ידע את התנאים ההתחלתיים המדויקים של המטבע ואת הכוח/המומנט של הזריקה, בפועל, אין שום דרך לדעת מראש לאיזה צד ינחת המטבע. לכן אנחנו משתמשים בהטלת המטבע כדוגמה קנונית של מצב הסתברותי קלאסי, שבו התוצאה היא בעצם אקראית. אנחנו יכולים לכתוב את מצב המטבע לפני שינחת כדי לשקף את ההסתברות הזו של 50/50:

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

כאן, שני האיברים מייצגים את שתי התוצאות האפשריות של הזריקה, והמקדמים שלהם מייצגים את ההסתברויות של כל אחת מהתוצאות. שימו לב שבדרך כלל, ה-"$|\rangle$" (המכונה "קט") משמש לייצוג מצב קוונטי, אבל כאן, אנחנו מדברים על מצב קלאסי הסתברותי. ראו את שיעור 1: מערכות בודדות בקורס יסודות מידע קוונטי כדי ללמוד עוד על האופן שבו אנחנו מייצגים מידע קלאסי וקוונטי.

אם היינו מטילים מטבע 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 וה-Primitives, ואז בוחרים Backend שעליו להריץ את ה-Circuit.

יש קוד למטה לשמירת האישורים שלך בשימוש הראשון. הקפידו למחוק את המידע הזה מהמחברת לאחר שמירתו לסביבה שלכם, כדי שהאישורים שלכם לא יישתפו בטעות כשתשתפו את המחברת. ראו הגדרת חשבון 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

אם נגמר לך הזמן הזמין בחשבון שלך, תוכל גם לבחור להריץ זאת על סימולטור במקום. פשוט בטל את ה-comment על הקוד והרץ את התא למטה:

## 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 שלמעלה, יש לנו משהו שנראה בעצם זהה להיסטוגרם של המטבע הקלאסי, למעט תנודות סטטיסטיות מסוימות.

בנוסף לדגימת הסטטיסטיקה של המטבע הקוונטי, אנחנו יכולים גם להשתמש ב-Qiskit Primitive אחר שנקרא Estimator כדי למדוד את מה שנקרא ערך הציפייה של אובזרבבל של המצב. כדי להמחיש מה הוא ערך הציפייה הזה, בואו נשתמש במטבע הקלאסי כדוגמה. נניח שאתה משתמש במטבע כדי להמר: בכל פעם שאתה מטיל את המטבע והוא נוחת "עץ-למעלה," אתה מרוויח דולר אחד. אבל בכל פעם שהוא נוחת "עץ-למטה," אתה מפסיד דולר אחד. אם אתה רוצה לדעת כמה כסף אתה מצפה לקבל בכל הטלה (ערך הציפייה של האובזרבבל "כסף"), אז תחשב:

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

מכיוון שיש לך סיכוי שווה לזכות בדולר כמו להפסיד דולר, ערך הציפייה הוא $0.

באופן דומה, עם מצב קוונטי, אנחנו יכולים לחשב את ערך הציפייה של האובזרבבל "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

אנחנו מקבלים ערך ציפייה של 0, כצפוי (היפה). זוהי דרך נוספת לאשר שאכן יש הסתברות שווה למדידת 0 או 1, ונראה שהתנהגות זו דומה להטלת מטבע.

בשלב זה, ה"מטבע הקוונטי" נראה בדיוק כמו המטבע הקלאסי. אבל בחלק הבא, נעשה כמה ניסויים שיחשפו את ההבדלים הבסיסיים בין השניים.

הקוונטי מתגלה: ניסוי בשלושה ממדים

בואו נעשה ניסוי מחשבתי: נניח שאתה זורק מטבע באוויר, ובמקום לתת לו ליפול לקרקע, יש לך את התיאום לכף ידיים כשהוא עובר ביניהן ולמחוץ את המטבע בין כפות ידיך. עכשיו, במקום שהמטבע יהיה עם הפנים למעלה או למטה, הוא עם הפנים שמאלה או ימינה.

בדוק את הבנתך

קרא את השאלה/ות למטה, חשוב על תשובתך, ואז לחץ על המשולש כדי לגלות את הפתרון.

מה ההסתברות לכל אחד מהתוצאות האלה, פנים שמאלה או פנים ימינה?

תשובה:

ההסתברות עדיין תהיה 50-50. לא אמורה להיות חשיבות לאיזה ממד אנחנו בוחרים למדוד את תוצאת הטלת המטבע.

בתקווה, ענית שההסתברות למצוא פנים שמאלה או ימינה עדיין היא 50-50. הממד שלאורכו מודדים את הטלת המטבע לא אמור להשפיע על ההסתברות של התוצאות.

אבל איך הדברים ייראו שונה עבור המטבע הקוונטי שלנו? בואו נבדוק.

אנחנו יכולים ליצור את הסופרפוזיציה הקוונטית שלנו באותו אופן שעשינו בפעם הקודמת, עם Hadamard Gate. כדי למדוד "פנים שמאלה או ימינה" על המטבע הקוונטי שלנו, אנחנו יכולים לעשות מה שעשינו עם המטבע הקלאסי: למדוד לאורך ציר שונה. המדידות הסטנדרטיות שלנו על המחשב הקוונטי הן לאורך הציר האנכי, ממש כמו מדידת "פנים למעלה או למטה" הרגילה של המטבע הקלאסי. אבל אנחנו גם יכולים לשאול את המטבע הקוונטי שלנו אם הוא פנים שמאלה או ימינה, או בשקילות, אם הוא נמצא במצבים $|+\rangle$ או $|-\rangle$, שמצביעים לאורך ציר ה-$x$. Sampler רק דוגם בבסיס המדידה Z, אבל אנחנו יכולים להשתמש ב-Estimator כדי לקבל את ערך ההצפייה של X. הערכים של X הם +1 ו-1- עבור המצבים $|+\rangle$ או $|-\rangle$, בהתאמה.

בדוק את הבנתך

קרא את השאלה למטה, חשוב על תשובתך, ואז לחץ על המשולש כדי לגלות את הפתרון.

אם המטבע הקוונטי היה מתנהג כמו המטבע הקלאסי במקרה זה, היינו מקבלים הסתברות 50-50 למדידת המצב ב-$|+\rangle$ ו-$|-\rangle$. איזה ערך הצפייה של X היינו מצפים ש-Estimator יחזיר, אם זה היה המצב?

תשובה:

כשאנחנו מפעילים X על המצב $|+\rangle$, אנחנו מקבלים את הערך +1, ועל המצב $|-\rangle$ אנחנו מקבלים 1-. כך שאם היה לנו התפלגות 50-50, היינו מקבלים ערך הצפייה של 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

ערך ההצפייה של X עבור מצב זה הוא 1. לכן, אין הסתברות 50-50 למדידת $|+\rangle$ ו-$|-\rangle$.

בדוק את הבנתך

קרא את השאלה/ות למטה, חשוב על תשובתך, ואז לחץ על המשולש כדי לגלות את הפתרון.

מה ערך ההצפייה הזה אומר לנו על המצב $|\psi\rangle$? מהן ההסתברויות למדידת $|+\rangle$ ו-$|-\rangle$ בבסיס X הזה?

תשובה:

מאחר שערך ההצפייה זהה לערך של 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$ של שני המקדמים — אנחנו בדרך כלל מפעילים פאזה גלובלית של $-\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$ הוא דיסטריביוטיבי, כך שאנחנו יכולים להפעיל אותו על כל אחד מהאברים בנפרד.

תשובה:

$$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 השני ביטל את הראשון, וחזרנו למצב 0 שממנו התחלנו! זה מפני שה-Hadamard הופך גם את המצב $|0\rangle$ וגם את $|1\rangle$ למצבים דומים, אבל עם פאזות הפוכות. לאחר ה-Hadamard השני, אנחנו רואים שהאברים $|0\rangle$ מתערבים קונסטרוקטיבית, אבל האברים $|1\rangle$ מתערבים הרסנית ומתבטלים.

בואו נחקור עוד: אנחנו יכולים לשנות את הפאזה באמצעות Gate "PHASE". אז עכשיו בואו נפעיל 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.

נסה בעצמך:

ערוך את תא הקוד למטה כדי לשנות את הפאזה כך שה-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)

אנלוגיה נוספת (טובה יותר) למטבע באמצעות ה-Gate $\sqrt{\text{NOT}}$

עד עכשיו למדנו שמעשה הטלת מטבע הוא די שונה מיצירת מצב סופרפוזיציה. האם יש אנלוגיה טובה יותר למטבע שיכולה ללכוד יותר מתופעות הסופרפוזיציה? כן. בהחלט כן.

אנחנו הולכים לעשות ניסוי מחשבתי נוסף עם מטבע. דמיין את המטבע שוכב על השולחן, פנים למעלה. כדי לגרום לו להיות פנים למטה, אנחנו יכולים פשוט להפוך אותו. זה השקיל החישובי של Gate "NOT".

נניח שאנחנו רוצים לבנות פעולה שאם מופעלת פעמיים, תהיה שקולה ל-Gate NOT. כלומר, אנחנו רוצים "שורש ריבועי של NOT," או $\sqrt{\text{NOT}}$. אנחנו יכולים לעשות זאת על ידי התחשבות בכיצד Gate NOT מיושם פיזית על המטבע: זהו סתם סיבוב של 180 מעלות סביב, למשל, ציר ה-x. אז, אם היינו מסובבים את המטבע רק 90 מעלות סביב ציר ה-x, זה יהיה שקול ל-Gate $\sqrt{\text{NOT}}$.

דמיין שלאחר הפעלת Gate $\sqrt{\text{NOT}}$, אנחנו רוצים לשאול אם המטבע הוא פנים למעלה או פנים למטה. הוא לא — הוא עומד על הקצה שלו ביחס לציר האנכי. אבל עכשיו, בואו נגדיר מחדש את ה"מדידה" שלנו על המטבע כך: ראשית, קיפול המטבע לאורך ציר המדידה (על ידי מחיצה שלו עם ידך כך שהוא שוכב שטוח), ושנית, בדיקה אם הוא פנים למעלה או למטה.

אם נבצע "מדידה" זו על המטבע שעומד על קצהו, אז המטבע "יתמוטט" לפנים למעלה ולפנים למטה עם הסתברות שווה. כמו הטלת מטבע, באופן עקרוני, ניתן לנבא את הכיוון שהמטבע ייפול בהתבסס על התנאים ההתחלתיים של המטבע ואיך בדיוק הכוח של ידנו מופעל על המטבע כדי "לקפל" אותו. אבל בפועל, אמורה להיות קשה לנבא איזה צד יתרומם, אז זה בעצם אקראי.

אנחנו יכולים למדוד את המטבע הזה לאורך שלושה צירים שונים: $x$, $y$, ו-$z$. אנחנו רואים שקצה המטבע מצביע לאורך $x$ ו-$z$, כך שהמדידה בכיוונים אלה דורשת "קיפול" המטבע — לכן, לאורך הצירים האלה, תהיה אקראיות עם הסתברות 50:50 למדידת פנים למעלה ולמטה. אבל לאורך ציר ה-$y$, הוא כבר שטוח, עם פניו מכוונות לכיוון ה-y. אנחנו יכולים לקרוא לזה "פנים קדימה."

כך, בעוד שמדידות x ו-z הניבו תוצאות אקראיות, מדידת y תניב תמיד את אותה תוצאה! אם אתה זוכר את ניסוי "הטלת מטבע קוונטי" מהסעיף הקודם, זה מזכיר את האופן שבו המטבע הקוונטי התנהג. הוא נמדד כ-0 או 1 עם הסתברות 50/50 בכיוון z, אבל תמיד $|+\rangle$ ולא $|-\rangle$ לאורך X. זה מרמז שאולי מטבע שוכב בשקט, על קצהו, הוא דרך טובה יותר להמחיש מצב סופרפוזיציה של Qubit מאשר מטבע שמסתובב בפראות באוויר.

בואו נשתמש ב-Qiskit כדי לראות אם ה"מטבע הקוונטי" שלנו מתנהג באותה צורה כמו המטבע הקלאסי כשמופעל Gate $\sqrt{\text{NOT}}$. נפעיל $\sqrt{\text{NOT}}$ על Qubit שמתחיל ב-$|0\rangle$, ואז נשתמש ב-Estimator לבדיקת ערך ההצפייה של שלושת האובייקטים הנצפים, 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]]

ערכי ההצפייה הם 0, 1-, ו-0 עבור X, Y ו-Z, בהתאמה.

בדוק את הבנתך

קרא את השאלה למטה, חשוב על תשובתך, ואז לחץ על המשולש כדי לגלות את הפתרון.

בהתחשב בערכי ההצפייה, מהן ההסתברויות למדידת המטבע הקוונטי כפנים למעלה/למטה (או שמאלה/ימינה או קדימה/אחורה) עבור כל אחד מ-3 צירי המדידה?

תשובה:

יש הסתברות 50/50 למדידת כל מצב לאורך X ו-Z, והמצב תמיד נמדד בכיוון ה-y השלילי לאורך Y.

זה אותה תוצאה שקיבלנו עם ניסוי המחשבה שלנו בהפעלת סיבוב של 90 מעלות "$\sqrt{\text{NOT}}$" על המטבע הקלאסי. למעשה, יש אנלוגיה מדויקת בין המטבע למצב ה-Qubit כעת. אנחנו יכולים לדמות את מצב ה-Qubit כווקטור שמצביע בכיוון של הצד ה"פנים" של מטבע, ניצב לפני שטח המטבע. כך, פנים למעלה, או המצב $|0\rangle$ על מטבע קוונטי, שקול לווקטור שמצביע ישר למעלה; פנים למטה, או $|1\rangle$, מצביע ישר למטה. כל סופרפוזיציה שווה של $|0\rangle$ ו-$|1\rangle$ מצביעה אופקית. הפאזה של המצב קובעת את הכיוון האופקי המדויק — הכיוון שהיא מצביעה לאורך קו המשווה שווה לכיוון שהמקדם $c_2$ מצביע במישור המרוכב.

עכשיו, כל Gate שראינו במחברת זו ניתן לדמות כסיבוב (או סדרת סיבובים) של המטבע/ווקטור.

• NOT: 180 מעלות סביב ציר ה-x

• $\sqrt{\text{NOT}}$: 90 מעלות סביב ציר ה-x

• PHASE: סיבוב של $\phi$ סביב ציר ה-z

• Hadamard: זה קצת יותר מסובך. בתחילה דמינו אותו להטלת מטבע, שגורמת למטבע להסתובב ללא שליטה באוויר. אבל ה-Hadamard הוא למעשה סיבוב מבוקר ודטרמיניסטי של המטבע, כמו ה-Gate-ים האחרים. ה-Hadamard מבוצע על ידי סיבוב של 90 מעלות סביב ציר ה-y, ואז 180 מעלות סביב ציר ה-x.

אז, אין שום דבר אקראי במצב סופרפוזיציה קוונטי או בכל אחת מהפעולות הסטנדרטיות שאנחנו מבצעים על ה-Qubit. כל פעולה היא דטרמיניסטית וניתנת להיפוך. הרגע היחיד שבו אקראיות נכנסת לתמונה הוא כשאנחנו מחליטים למדוד את המצב הקוונטי.

מצב ה-Qubit כווקטור בלוך

הווקטור הזה שמצביע בכיוון ה"פנים" של המטבע ידוע בשם "ווקטור בלוך". רשמית, ניתן לייצג מצב Qubit שרירותי (מבודד) על ידי ווקטור שנמצא על פני כדור עם רדיוס 1 עם קואורדינטות $(r, \theta, \phi)$. כתוב במונחי קואורדינטות אלה, מצב ה-Qubit הוא:

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

עכשיו בואו נבדוק עם Qiskit כיצד ווקטור בלוך משתנה כשאנחנו מפעילים 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 במצב סופרפוזיציה. הוא כמו מטבע שוכב בשקט במרחב תלת-ממדי. למעשה, מטבע שחופשי להסתובב ב-3 ממדים הוא אנלוגיה קרובה מאוד לדרך מסוימת לדמות את המצב הקוונטי של Qubit, הנקראת ווקטור בלוך. Gate-ים קוונטיים מסובבים את המטבע/ווקטור בלוך זה באופן דטרמיניסטי וניתן להיפוך. רק כשאנחנו מודדים את ה-Qubit מוצגת כל אקראיות. השווינו את תהליך המדידה הזה למחיצת המטבע כך שהוא שוכב שטוח בכיוון ציר המדידה.

האם מצב קוונטי נמצא בסופרפוזיציה הוא ממש רק בעיני המתבונן. כפי שכנראה נתקלת בו קודם, אנחנו חופשיים לבחור את מערכת הקואורדינטות שלנו — $x$, $y$, ו-$z$ יכולים להצביע לאורך כל שלושה כיוונים אורתוגונליים. כך, אם יש לנו סופרפוזיציה של 0 ו-1 במערכת קואורדינטות אחת, אנחנו יכולים להגדיר מערכת קואורדינטות חדשה — או בשקילות, "בסיס מדידה" חדש — שבה המצב מצביע לחלוטין בכיוון $+z$, ולכן אינו במצב סופרפוזיציה. כך, כשאנחנו אומרים ש-Qubit נמצא בסופרפוזיציה, עלינו גם לענות על השאלה, "סופרפוזיציה של מה?"

אולי תעזוב את המודול הזה עם הרושם שרק הסרנו את כל המסתורין ממכניקת הקוונטים. אחרי הכל, אחד מהיבטיו ה"מוזרים" לכאורה, מצב הסופרפוזיציה של Qubit, הוא ממש פשוט כמו ווקטור תלת-ממדי. אבל שים לב שהמטבע הוא עדיין רק אנלוגיה, ואפילו ווקטור בלוך הוא רק כלי ויזואליזציה לחישוב הסתברויות של תוצאות מדידה. אנחנו לא יכולים לומר מה מצב קוונטי באמת עושה לפני שנמדד. כי לבדוק זאת דורש מדידה!

נדון בסוגיה הזאת של מה היא "הטבע האמיתי" של מצב קוונטי, וכיצד תופעת ההסתבכות הקוונטית יכולה לעזור לנו לפענח זאת, במודול אי-השוויון של בל.

שאלות

מנחים יכולים לבקש גרסאות של המחברות האלה עם מפתחות תשובות והנחיות לגבי מיקום בתכניות לימודים נפוצות על ידי מילוי סקר קצר זה בנוגע לאופן שבו המחברות משמשות.

מושגים מרכזיים:

• אמנם מדידת Qubit בסופרפוזיציה היא פרובביליסטית, כמו הטלת מטבע, אבל מצב הסופרפוזיציה עצמו מתנהג שונה ממטבע מתהפך.
• הבדל מרכזי בין התפלגות הסתברות קלאסית לסופרפוזיציה הוא שלסופרפוזיציה יש קוהרנטיות פאזה, המאפשרת לה להתערב קונסטרוקטיבית או הרסנית.
• ניתן לדמות את מצב Qubit בודד ומבודד כנקודה על "כדור בלוך" המכונה כך, שבו האמפליטודות היחסיות של הרכיבים $|0\rangle$ ו-$|1\rangle$ קובעות את הזווית הפולרית $\theta$ והפאזות היחסיות בין שני הרכיבים קובעות את הזווית האצימוטלית $\phi$.
• ניתן לראות את כל Gate-ים הקוונטיים של Qubit יחיד כסיבובים של הווקטור על כדור זה.

שאלות נכון/לא נכון:

1. נכון/לא נכון: סופרפוזיציה קוונטית היא בעצם אותו דבר כמו אירוע פרובביליסטי בפיזיקה קלאסית, כמו הטלת מטבע.

2. נכון/לא נכון: אורך ווקטור בלוך המתאר את מצב Qubit בודד מבודד הוא תמיד 1.

3. נכון/לא נכון: Gate-ים קוונטיים של Qubit יחיד אינם משנים את אורך ווקטור בלוך.

שאלות רב-ברירה:

1. בחר את ווקטור בלוך הנכון המייצג את המצב $|\Psi\rangle = \sqrt{\frac{1}{3}}|0\rangle + e^{i \pi / 4} \sqrt{\frac{2}{3}}|1\rangle$:

2. כדור בלוך מתאר של Qubit: (בחר את כל שמתאים)

   א. אמפליטודה

   ב. הסתבכות עם Qubit-ים אחרים

   ג. פאזה

   ד. צבע

   ה. הסתברות של תוצאות מדידה

שאלות לדיון:

1. למה ניתן לדמות את מצב Qubit על כדור בלוך, אבל לא ניתן לדמות את התפלגות ההסתברות של הטלת מטבע?

2. למה מטבע שמתהפך באוויר אינו האנלוגיה הטובה ביותר למצב סופרפוזיציה קוונטית? איזה היבט של סופרפוזיציות לא נלכד באנלוגיה זו?

בעיות אתגר:

1. השתמש ב-Qiskit כדי ליצור Circuit שמשנה את המצב $|0\rangle$ למצב $\frac{\sqrt{3}}{2}|0\rangle + \frac{1}{2}e^{i \frac{5\pi}{6}}|1\rangle$