דלג לתוכן הראשי

טלפורטציה קוונטית

עבור מודול 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 שלך.

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

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime
# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

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

מבוא ורקע​

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

ביטים קלאסיים יכולים להיות במצבים 0 או 1. Qubit יכולים להיות במצבים קוונטיים המסומנים ∣0⟩|0\rangle ו-∣1⟩|1\rangle וגם בצירופים לינאריים של מצבים אלה, הנקראים "סופרפוזיציות", כמו ∣ψ⟩=α0∣0⟩+α1∣1⟩|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle, עם α0,α1∈C,\alpha_0,\alpha_1 \in \mathbb{C}, ו-∣α0∣2+∣α1∣2=1.|\alpha_0|^2+|\alpha_1|^2 = 1. למרות שהמצבים יכולים להתקיים בסופרפוזיציה זו, מדידה של המצב "תקרוס" אותו למצב ∣0⟩|0\rangle או ∣1⟩|1\rangle. הפרמטרים aa ו-bb קשורים להסתברות של כל תוצאת מדידה לפי

P0=∣α0∣2P_0 = |\alpha_0|^2 P1=∣α1∣2P_1 = |\alpha_1|^2

ומכאן האילוץ ש-∣α0∣2+∣α1∣2=1.|\alpha_0|^2+|\alpha_1|^2 = 1.

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

∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A

או

∣0⟩1∣0⟩0|0\rangle_1|0\rangle_0

שמתקצר לפעמים פשוט ל

∣00⟩|00\rangle

שים לב ש-Qubit עם המספר הנמוך ביותר (או האות) נמצא הכי ימינה. זוהי מוסכמה הנקראת סימון "little-endian", המשמשת בכל Qiskit. אם המצב הדו-Qubit של החברים הוא ∣00⟩,|00\rangle, והם מודדים את המצב של ה-Qubit שלהם בהתאמה, כל אחד ימצא 0. באופן דומה אם ה-Qubit היו במצב ∣11⟩,|11\rangle, כל אחת מהמדידות שלהם תניב 1. זה לא שונה מהמקרה הקלאסי. עם זאת, בחישוב קוונטי, אנחנו יכולים לשלב זאת עם סופרפוזיציה כדי לקבל מצבים כמו

12(∣00⟩+∣11⟩)\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)

במצב כזה, האם ה-Qubit של אליס ובוב נמצאים במצב 0 או 1 עדיין לא ידוע, עדיין לא נקבע על ידי הטבע, ובכל זאת אנחנו יודעים שהם ימדדו את אותו המצב עבור ה-Qubit שלהם. לדוגמה, אם בוב מודד את ה-Qubit שלו ומוצא שהוא במצב ∣0⟩,|0\rangle, הדרך היחידה לזה לקרות היא שהמדידה קרסה את המצב הדו-Qubit לאחד משני המצבים האפשריים, ספציפית ל-∣00⟩.|00\rangle. זה משאיר את ה-Qubit של אליס גם במצב ∣0⟩|0\rangle.

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

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

כדי לממש זאת, נצטרך לדעת כמה פעולות קוונטיות או "Gates".

אופרטורים קוונטיים (Gates)​

אתה מוזמן לדלג על חלק זה אם אתה כבר מכיר את ה-Gates הקוונטיים. אם אתה רוצה להבין את ה-Gates האלה טוב יותר, בדוק את יסודות המידע הקוונטי, במיוחד שתי השיעורים הראשונים, ב-IBM Quantum Learning.

לפרוטוקול טלפורטציה זה נשתמש בעיקר בשני סוגים של Gates קוונטיים: Gate ה-Hadamard וה-Gate CNOT. כמה אחרים ימלאו תפקיד פחות משמעותי: ה-Gate XX, Gate ZZ, ו-Gate SWAP.

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

המצבים שכבר הצגנו נבחרו (חלקית על ידי מוסכמה וחלקית על ידי אילוצים) לקבל צורות וקטוריות:

∣0⟩=(10)|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix} ∣1⟩=(01)|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}

בדרך זו, מצב שרירותי ∣ψ⟩=a∣0⟩+b∣1⟩|\psi\rangle = a|0\rangle+b|1\rangle ניתן לכתיבה כ

∣ψ⟩=(ab)|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}

יש בחירה כיצד להרחיב את הסימון למצבים של Qubit מרובים, אבל הבחירה למטה היא די סטנדרטית:

∣00⟩=(1000),∣01⟩=(0100),∣10⟩=(0010),∣11⟩=(0001).|00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix},|01\rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, |10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\0\end{pmatrix},|11\rangle = \begin{pmatrix}0 \\ 0 \\ 0 \\ 1\end{pmatrix}.

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

Gate H Hadamard: יוצר מצב סופרפוזיציה. Gate של Qubit יחיד.

H∣0⟩=12(∣0⟩+∣1⟩),H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right), H∣1⟩=12(∣0⟩−∣1⟩)H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right) H=12(111−1)H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}

Circuit עם Gate Hadamard נבנה כך:

from qiskit import QuantumCircuit

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

Output of the previous code cell

Gate CNOT Controlled-NOT: Gate זה משתמש בשני Qubit: שליטה ומטרה. בודק את המצב של Qubit השליטה שאינו משתנה. אבל אם Qubit השליטה נמצא במצב ∣1⟩|1\rangle, ה-Gate משנה את המצב של Qubit המטרה; אם המצב של Qubit השליטה הוא ∣0⟩|0\rangle לא נעשה שינוי כלל. בסימון שלמטה, נניח ש-Qubit AA (הימני ביותר) הוא השליטה, ו-Qubit BB (השמאלי ביותר) הוא המטרה. למטה, הסימון המשמש הוא CNOT(qcontrol,qtarget)∣BA⟩.CNOT(q_{control},q_{target})|BA\rangle.

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

לפעמים אתה תראה CNOT כתוב עם הסדר של השליטה והמטרה פשוט מרומז. אבל אין עמימות כזו בקוד או בדיאגרמות Circuit.

CNOT=(1000000100100100)CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}

Gate CNOT נראה קצת שונה ב-Circuit, מכיוון שהוא דורש שני Qubit. כך הוא מממש:

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

Output of the previous code cell

בדוק את ההבנה שלך​

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

לרוב ה-Gates יש אותה צורת מטריצה ב-Qiskit כמו בכל מקום אחר. אבל Gate ה-CNOT פועל על שני Qubit, וכך פתאום סדר הוקטור של Qubit הופך לבעיה. טקסטים שמסדרים Qubit ∣q0,q1,...⟩|q_0,q_1,...\rangle יראו צורת מטריצה שונה עבור ה-Gates CNOT שלהם. אמת על ידי כפל מטריצות מפורש ש-Gate ה-CNOT שלמעלה מבצע את הפעולה הנכונה על המצב ∣01⟩.|01\rangle.

תשובה:

CNOT∣01⟩=(1000000100100100)(0100)=(0001)=∣11⟩CNOT|01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = |11\rangle

Gate XX: שקול לפעולת NOT. Gate של Qubit יחיד.

X∣0⟩=∣1⟩,X∣1⟩=∣0⟩X|0\rangle = |1\rangle,\\X|1\rangle=|0\rangle X=(0110)X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}

ב-Qiskit, יצירת Circuit עם Gate XX נראית כך:

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

Output of the previous code cell

Gate ZZ: מוסיף "פאזה" למצב (פקטור קדמי, שבמקרים של eigenstates Z ∣0⟩|0\rangle ו-∣1⟩|1\rangle הוא 1 או -1, בהתאמה). Gate של Qubit יחיד.

Z∣0⟩=∣0⟩,Z∣1⟩=−∣1⟩Z|0\rangle = |0\rangle,\\Z|1\rangle=-|1\rangle Z=(100−1)Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}

ב-Qiskit, יצירת Circuit עם Gate ZZ נראית כך:

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

Output of the previous code cell

תיאוריה​

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

אליס ובוב מסבכים את ה-Qubit שלהם: בתחילה, ה-Qubit של אליס וה-Qubit של בוב נמצאים כל אחד בנפרד במצב ∣0⟩|0\rangle (הנחה טובה וגם האתחול הנכון עבור מחשבי IBM® Quantum). נוכל לכתוב זאת כ-∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A או פשוט כ-∣00⟩|00\rangle. בואו נחשב מה קורה כאשר אליס ובוב פועלים עם Gate Hadamard על ה-Qubit של אליס, ואחר כך Gate CNOT עם ה-Qubit של אליס כשליטה ושל בוב כמטרה:

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

שים לב ש-Qubit של אליס ובוב מסובכים עכשיו. למרות שטבע עדיין לא קבע האם שני ה-Qubit שלהם נמצאים במצב ∣0⟩|0\rangle או ∣1⟩|1\rangle, ידוע שה-Qubit שלהם נמצאים באותו מצב. אליס ובוב נפרדים: שני החברים מעבירים את ה-Qubit שלהם למיקומים חדשים, אפשרי שרחוקים מאוד. זה מגיע עם הרבה הסתייגויות: לא טריוויאלי להעביר מידע קוונטי מבלי להפריע לו. אבל ניתן להעביר אותו, ואכן תעביר אותו במודול הזה. אבל זכור כהסתייגות שאנחנו מצפים להיתקל בשגיאות כלשהן כאשר אנחנו מעבירים מידע קוונטי הרבה.

Q מוצג: המצב הסודי מוכן על Qubit Q:

∣ψ⟩Q=α0∣0⟩Q+α1∣1⟩Q|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q

בנקודה זו Q פשוט סמוך ל-Qubit של אליס (A). לא הייתה הסתבכות, כך שניתן לכתוב את המצב הקוונטי של שלושת ה-Qubit יחד כ:

∣ψ⟩AB∣ψ⟩Q=12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)(α0∣0⟩Q+α1∣1⟩Q).|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).

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

אליס מסבכת Qubit A ו-Q: אליס עכשיו פועלת עם Gate CNOT עם ה-Qubit שלה כשליטה ו-Q כמטרה, ואחר כך מחילה Gate Hadamard על Q. בואו נחשב את המצב שלושת-ה-Qubit אחרי אותה פעולה:

HQCNOT(A,Q)∣ψ⟩AB∣ψ⟩Q=HQCNOT(A,Q)12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)(α0∣0⟩Q+α1∣1⟩Q)=HQCNOT(A,Q)12((α0∣0⟩B∣0⟩A∣0⟩Q+α1∣0⟩B∣0⟩A∣1⟩Q)+(α0∣1⟩B∣1⟩A∣0⟩Q+α1∣1⟩B∣1⟩A∣1⟩Q))=HQ12(α0∣0⟩B∣0⟩A∣0⟩Q+α1∣0⟩B∣1⟩A∣1⟩Q+α0∣1⟩B∣1⟩A∣0⟩Q+α1∣1⟩B∣0⟩A∣1⟩Q)=12(α0∣0⟩B∣0⟩A∣0⟩Q+α0∣0⟩B∣0⟩A∣1⟩Q+α1∣0⟩B∣1⟩A∣0⟩Q−α1∣0⟩B∣1⟩A∣1⟩Q)+12(α0∣1⟩B∣1⟩A∣0⟩Q+α0∣1⟩B∣1⟩A∣1⟩Q+α1∣1⟩B∣0⟩A∣0⟩Q−α1∣1⟩B∣0⟩A∣1⟩Q)\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}

מכיוון ש-A ו-Q נמצאים באותו מיקום, בואו נקבץ את האיברים שלמעלה לפי תוצאות המדידות על Qubit A ו-Q:

∣ψ⟩=12((α0∣0⟩B+α1∣1⟩B)∣0⟩A∣0⟩Q+(α0∣0⟩B−α1∣1⟩B)∣0⟩A∣1⟩Q+(α1∣0⟩B+α0∣1⟩B)∣1⟩A∣0⟩Q+(−α1∣0⟩B+α0∣1⟩B)∣1⟩A∣1⟩Q)\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}

בדוק את ההבנה שלך​

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

בהתחשב בביטוי שלמעלה עבור המצבים של שלושת ה-Qubit, מה ההסתברות שמדידה של Qubit A ו-Q תניב ∣0⟩A∣0⟩Q?|0\rangle_A|0\rangle_Q?

תשובה:

25%. לראות זאת, נזכור שהמצב של בוב חייב להיות מנורמל, כך ש ∣A⟨0∣Q⟨0∣12∣0⟩A∣0⟩Q(α0∣0⟩B+α1∣1⟩B)∣2=14∣(α0∣0⟩B+α1∣1⟩B)∣2=14 |_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}

עכשיו, אליס יכולה למדוד Qubit A ו-Q. היא לא יכולה לשלוט בתוצאת המדידה, מאחר שמדידות קוונטיות הן הסתברותיות. לכן כשהיא מודדת, יש 4 תוצאות אפשריות וכולן שקולות: ∣0⟩A∣0⟩Q,|0\rangle_A|0\rangle_Q, ∣0⟩A∣1⟩Q,|0\rangle_A|1\rangle_Q, ∣1⟩A∣0⟩Q,|1\rangle_A|0\rangle_Q, ו-∣1⟩A∣1⟩Q.|1\rangle_A|1\rangle_Q. שים לב שלכל תוצאה יש השלכות שונות על ה-Qubit של בוב. לדוגמה, אם אליס מוצאת את ה-Qubit שלה במצב ∣0⟩A∣0⟩Q,|0\rangle_A|0\rangle_Q, זה קרס את המצב הקוונטי השלם של 3-Qubit ל-(α0∣0⟩B+α1∣1⟩B)∣0⟩A∣0⟩Q.(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q. תוצאות מדידה אחרות עבור אליס מניבות מצבים שונים עבור בוב. אלה מרוכזים יחד בטבלה למטה.

תוצאת אליסמצב בובהוראה לבובתוצאה
∣0⟩A∣0⟩Q \vert 0\rangle_A \vert 0\rangle_Qα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_Bללאα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
∣0⟩A∣1⟩Q \vert 0\rangle_A \vert 1\rangle_Qα0∣0⟩B−α1∣1⟩B\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_BZZα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
∣1⟩A∣0⟩Q \vert 1\rangle_A \vert 0\rangle_Qα1∣0⟩B+α0∣1⟩B\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_BXXα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
∣1⟩A∣1⟩Q \vert 1\rangle_A \vert 1\rangle_Q−α1∣0⟩B+α0∣1⟩B-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_BXX ואז ZZα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
עבור כל תוצאות המדידה האפשריות על ה-Qubit של אליס, ה-Qubit של בוב נותר במצב הדומה במידת מה למצב הסודי שהיה במקור על Q. במקרה שבו אליס מודדת $0\rangle_C0\rangle_A(השורההראשונהבטבלה),ה−Qubitשלבובנותרבדיוקבמצבהסודי!בשארהמקרים,ישמשהולאבסדרעםהמצב.המקדמים( (השורה הראשונה בטבלה), ה-Qubit של בוב נותר בדיוק במצב הסודי! בשאר המקרים, יש משהו לא בסדר עם המצב. המקדמים (\alpha)מוחלפים,אושישסימן"−"במקוםשצריךלהיות"+",אושניהם.כדילשנותאתה−Qubitשלבובכךשיהיהשווהבדיוקלמצבהסודי,אליסחייבתלהתקשרלבוב(להשתמשבאמצעיתקשורתקלאסיכלשהו)ולהגידלבובלבצעפעולותנוספותעלה−Qubitשלו,כמפורטבטבלה.לדוגמה,בשורההשלישיתהמקדמיםמוחלפים.אםאליסמתקשרתלבובואומרתלולהחילGate) מוחלפים, או שיש סימן "-" במקום שצריך להיות "+" , או שניהם. כדי לשנות את ה-Qubit של בוב כך שיהיה שווה בדיוק למצב הסודי, אליס חייבת להתקשר לבוב (להשתמש באמצעי תקשורת קלאסי כלשהו) ולהגיד לבוב לבצע פעולות נוספות על ה-Qubit שלו, כמפורט בטבלה. לדוגמה, בשורה השלישית המקדמים מוחלפים. אם אליס מתקשרת לבוב ואומרת לו להחיל Gate Xעלה−Qubitשלו,זהמשנהעל ה-Qubit שלו, זה משנה0\rangleל− ל-

עכשיו צריך להיות ברור מדוע אנחנו לא יכולים להשתמש בהגדרה זו לשליחת מידע מהר יותר מאור. אולי נהיה מזל ונמדוד ∣0⟩A∣0⟩Q,|0\rangle_A|0\rangle_Q, כלומר לבוב יש בדיוק את המצב הסודי, מיד. אבל בוב לא יודע זאת עד שנתקשר אליו ונגיד לו "מדדנו ∣0⟩A∣0⟩Q|0\rangle_A|0\rangle_Q, אז אתה לא צריך לעשות כלום."

בניסוי המחשבתי, ה-Qubit לעתים קרובות מופרדים פיזית ומועברים למיקום חדש. מחשבי IBM® Quantum משתמשים ב-Qubit במצב מוצק על שבב שלא ניתן להפריד. לכן במקום להעביר את אליס ובוב למיקומים שונים, נפריד את המידע על השבב עצמו על ידי שימוש ב-"swap gates" כך שנקרא להם כדי להעביר את המידע מ-Qubit אחד לאחר.

ניסוי 1: טלפורטציה בסיסית​

IBM Quantum ממליצה להתמודד עם בעיות מחשוב קוונטי באמצעות מסגרת שאנחנו קוראים לה "Qiskit patterns". היא מורכבת מהשלבים הבאים.

  • שלב 1: מיפוי הבעיה שלך ל-Circuit קוונטי
  • שלב 2: אופטימיזציה של ה-Circuit שלך להרצה על חומרה קוונטית אמיתית
  • שלב 3: הרצת המשימה שלך על מחשבים קוונטיים של IBM באמצעות Runtime Primitives
  • שלב 4: עיבוד לאחר של התוצאות

שלב 1: מיפוי הבעיה שלך ל-Circuit קוונטי​

כל המתמטיקה שעשינו למעלה הייתה מתאר את שלב 1. עכשיו נממש אותו, ונבנה את ה-Circuit הקוונטי שלנו באמצעות Qiskit! נתחיל ביצירת Circuit קוונטי עם שלושה Qubits, ונסבך את שני ה-Qubits של אליס ובוב. ניקח אותם כ-Qubits 1 ו-2, ונשמור את Qubit 0 למצב הסודי.

# Step 1: Map your problem to a quantum circuit

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

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

cr = ClassicalRegister(3, "c")

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

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

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

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

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

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

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

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

qc.draw(output="mpl")

Output of the previous code cell

זה כל מה שצריך לעשות כדי לטלפרט את המצב של אליס אל בוב. אבל זכרו שכשאנחנו מודדים מצב קוונטי α0∣0⟩+α1∣1⟩\alpha_0 |0\rangle+\alpha_1|1\rangle אנחנו מקבלים ∣0⟩|0\rangle או ∣1⟩.|1\rangle. אז בסוף כל זה, לבוב יש בוודאות את המצב הסודי של אליס, אבל אנחנו לא יכולים לאמת זאת בקלות עם מדידה. כדי שמדידה תגיד לנו שעשינו זאת נכון, אנחנו צריכים לעשות טריק. היה לנו אופרטור שסימנו "U" עבור "unitary" שבו השתמשנו להכנת המצב הסודי של אליס. אנחנו יכולים להחיל את ההופכי של U בסוף ה-Circuit שלנו. אם U מיפה את המצב ∣0⟩|0\rangle של אליס ל-α0∣0⟩+α1∣1⟩\alpha_0 |0\rangle+\alpha_1|1\rangle, אז ההופכי של U ימפה את α0∣0⟩+α1∣1⟩\alpha_0 |0\rangle+\alpha_1|1\rangle של בוב חזרה ל-∣0⟩.|0\rangle. אז החלק האחרון הזה לא בהכרח ייעשה אם המטרה הייתה פשוט להעביר מידע קוונטי. זה נעשה רק כדי שנוכל לבדוק את עצמנו.

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

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

qc.draw(output="mpl")

Output of the previous code cell

אז אם עשינו זאת נכון, המדידה שלנו על ה-Qubit של בוב אמורה לתת מצב ∣0⟩|0\rangle. כמובן, המדידות האלה הן הסתברותיות. אז אם יש אפילו סיכוי קטן למדוד את ה-Qubit של בוב במצב ∣1⟩|1\rangle, אז מדידה בודדת יכולה לתת ∣1⟩.|1\rangle. היינו רוצים לעשות הרבה מדידות כדי להיות בטוחים שההסתברות של ∣0⟩|0\rangle גבוהה למדי.

שלב 2: אופטימיזציה של הבעיה להרצה קוונטית​

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

נתחיל בטעינת מספר חבילות הנדרשות לתקשורת עם מחשבים קוונטיים של IBM. אנחנו גם חייבים לבחור Backend שעליו נריץ. אנחנו יכולים לבחור את ה-Backend הכי פחות עמוס, או לבחור Backend ספציפי שהמאפיינים שלו ידועים לנו.

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

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)
ibm_sherbrooke

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

from qiskit.circuit import IfElseOp

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

עכשיו אנחנו חייבים "לטרנספל" את ה-Circuit הקוונטי. זה כולל הרבה תת-שלבים ומדובר בנושא מרתק. רק כדי לתת דוגמה לתת-שלב: לא כל המחשבים הקוונטיים יכולים ליישם ישירות את כל ה-Gates הלוגיים ב-Qiskit. אנחנו חייבים לכתוב את ה-Gates מה-Circuit שלנו במונחים של Gates שהמחשב הקוונטי יכול לממש. אנחנו יכולים לבצע תהליך זה, ואחרים, באמצעות pass manager מוגדר מראש. הגדרת optimization = 3 (רמת האופטימיזציה הגבוהה ביותר) מבטיחה שהמיפוי מה-Circuit הקוונטי המופשט שלנו לפקודות הניתנות למחשב הקוונטי יהיה יעיל ככל שעיבוד מוקדם יכול להשיג.

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

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

Sampler הוא primitive שנועד לדגום מצבים אפשריים הנובעים מ-Circuit קוונטי, ולאסוף סטטיסטיקות על אילו מצבים עשויים להימדד ובאיזו הסתברות. אנחנו מייבאים כאן את Qiskit Runtime Sampler:

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

sampler = Sampler(mode=backend)

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

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

שלב 3: הרצה​

השתמש ב-Sampler כדי להריץ את המשימה שלך, עם ה-Circuit כארגומנט.

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

שלב 4: עיבוד לאחר וניתוח​

בואו נשרטט את התוצאות ונפרש אותן.

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

plot_histogram(counts)

Output of the previous code cell

בדוק את ההבנה שלך​

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

אילו מהמצבים למעלה מצביעים על טלפורטציה מוצלחת, וכיצד ניתן לדעת?

תשובה:

המצבים ∣000⟩,|000\rangle, ∣001⟩,|001\rangle, ∣010⟩,|010\rangle, ∣011⟩|011\rangle כולם תואמים לטלפורטציה מוצלחת. זאת מכיוון שהוספנו Gate כדי לבטל את ההכנה הראשונית של המצב הסודי. אם המצב הסודי טולפרט בהצלחה ל-Qubit של בוב, ה-Gate הנוסף הזה אמור להחזיר את ה-Qubit של בוב למצב ∣0⟩|0\rangle. אז כל מצב למעלה שבו ה-Qubit של בוב (Qubit 0, שנמדד גם לרכיב ה-0 של הרישום הקלאסי, ולכן הגבוה/ימני ביותר) נמצא במצב ∣0⟩|0\rangle מצביע על הצלחה.

גרף זה מציג את כל תוצאות המדידה עבור שלושת ה-Qubits, על פני 5,000 ניסיונות או "shots". ציינו קודם שאליס תמדוד את כל המצבים האפשריים עבור Qubits A ו-Q בהסתברות שווה. הקצינו Qubits 0-2 ב-Circuit ל-Q, A, ו-B, בסדר הזה. בסימון little-endian, ה-Qubit של בוב הוא השמאלי/הנמוך ביותר. אז ארבעת העמודות משמאל תואמות ל-Qubit של בוב במצב ∣0⟩|0\rangle, ולשני ה-Qubits האחרים שנמצאים בכל הצירופים האפשריים עם הסתברות פחות או יותר שווה. שים לב שכמעט כל (בדרך כלל ~95%) המדידות נותנות את ה-Qubit של בוב במצב ∣0⟩|0\rangle, כלומר ההגדרה שלנו הצליחה! יש מספר קטן של shots (~5%) שנתנו את ה-Qubit של בוב במצב ∣1⟩|1\rangle. זה לא אמור להיות אפשרי מבחינה לוגית. עם זאת, כל המחשבים הקוונטיים המודרניים סובלים מרעש ושגיאות בהיקף גדול בהרבה ממחשבים קלאסיים. ותיקון שגיאות קוונטיות הוא עדיין תחום מתפתח.

ניסוי 2: טלפורטציה לרוחב מעבד​

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

שלב 1: מיפוי הבעיה שלך ל-Circuit קוונטי​

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

# Step 1: Map

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

qc = QuantumCircuit(qr, cr)

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

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

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

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

qc.barrier()

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

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

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

qc.barrier()

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

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

qc.barrier()

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

qc.draw("mpl")

Output of the previous code cell

אפשר לראות בדיאגרמת ה-Circuit שהשלבים הלוגיים זהים. ההבדל היחיד הוא שהשתמשנו ב-swap Gates כדי להעביר את מצב ה-Qubit של אליס מ-Qubit 6 (A5A_5) ל-Qubit 1 (A0A_0), ממש ליד Q. ושהשתמשנו ב-swap Gates כדי להעביר את המצב ההתחלתי של בוב מ-Qubit 7 (B0B_0) ל-Qubit 12 (B5B_5). שים לב שהמצב על Qubit 12 אפילו לא קשור למצב הסודי של Q עד שמדידות נעשות על ה-Qubits המרוחקים 0 ו-1, והמצב על Qubit 12 אינו שווה למצב הסודי עד שה-Gates התנאיים XX ו-ZZ מוחלים.

שלב 2: אופטימיזציה של ה-Circuit שלך​

בדרך כלל, כשאנחנו משתמשים ב-pass manager לטרנספל ולאופטימיזציה של ה-Circuits שלנו, הגיוני להגדיר optimization_level = 3, כי אנחנו רוצים שה-Circuits שלנו יהיו יעילים ככל האפשר. במקרה זה, אין סיבה חישובית להעביר מצבים מ-Qubits 6 ו-7 ל-Qubits 1 ו-12. זה היה משהו שעשינו רק כדי להדגים טלפורטציה על מרחק. אם נבקש מה-pass manager לאופטם את ה-Circuit שלנו, הוא יבין שאין סיבה לוגית ל-swap Gates האלה, ויסיר אותם ויבצע את פעולות ה-Gate על Qubits סמוכים. אז במקרה מיוחד זה, אנחנו משתמשים ב-optimization_level = 0.

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

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

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())
105

אנחנו יכולים לדמות היכן על המעבד הקוונטי נמצאים ה-Qubits האלה באמצעות הפונקציה plot_circuit_layout.

שלב 3: הרצה​

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

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

plot_histogram(counts)

Output of the previous code cell

שלב 4: עיבוד קלאסי לאחר​

שוב אנחנו רואים שההסתברויות לתוצאות האפשריות עבור ה-Qubits של אליס הן פחות או יותר אחידות. יש העדפה ברורה למצוא את ה-Qubit של בוב ב-∣0⟩|0\rangle לאחר היפוך הקוד הסודי, כלומר יש הסתברות גבוהה שטולפרטנו בהצלחה את המצב הסודי לרוחב המעבד מ-Q לבוב (Qubits 0 עד 12). עם זאת, אנחנו מציינים שיש עכשיו סיכוי גבוה יותר לא למדוד ∣0⟩|0\rangle עבור בוב. זה שיעור חשוב במחשוב קוונטי: ככל שיש לך יותר Gates, במיוחד Gates של Qubits מרובים כמו swap Gates, כך תיתקל בעוד רעש ושגיאות.

שאלות​

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

מושגי מפתח​

  • ניתן לסבך Qubits, כלומר מדידה של Qubit אחד משפיעה או אפילו קובעת את המצב של Qubit אחר.
  • סיבוך שונה מקורלציות קלאסיות; לדוגמה, Qubits A ו-B יכולים להיות בסופרפוזיציה של מצבים כמו α0∣00⟩+α1∣11⟩.\alpha_0|00\rangle+\alpha_1|11\rangle. המצב של A או B עשוי להיות לא מוגדר על ידי הטבע, ובכל זאת A ו-B יכולים עדיין להיות מובטחים להיות באותו מצב.
  • באמצעות שילוב של סיבוכים ומדידות, אנחנו יכולים להעביר מצב (שיכול לאחסן מידע) מ-Qubit אחד לאחר. העברה זו יכולה אפילו להיעשות על מרחקים גדולים, וזה נקרא טלפורטציה קוונטית.
  • טלפורטציה קוונטית מסתמכת על מדידות קוונטיות, שהן הסתברותיות. לפיכך, תקשורת קלאסית עשויה להיות נדרשת כדי לכוונן את המצבים המטולפרטים. זה מונע מטלפורטציה קוונטית להעביר מידע מהר יותר מהאור. טלפורטציה קוונטית אינה מפרה את תורת היחסות או הסיבתיות.
  • מחשבים קוונטיים מודרניים רגישים יותר לרעש ושגיאות ממחשבים קלאסיים. צפו לאחוז שגיאה של כמה אחוזים.
  • ככל שתוסיף יותר Gates ברצף (במיוחד Gates של 2 Qubits) כך תוכל לצפות לעוד שגיאות ורעש.

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

  1. נ/ל ניתן להשתמש בטלפורטציה קוונטית כדי לשלוח מידע מהר יותר מהאור.
  2. נ/ל עדויות מודרניות מצביעות על כך שהתמוטטות מצב קוונטי מתפשטת מהר יותר מהאור.
  3. נ/ל ב-Qiskit, Qubits מסודרים במצבים עם ה-Qubit הממוספר הנמוך ביותר מימין, כמו ב-∣q3,q2,q1,q0⟩|q_3,q_2,q_1, q_0\rangle

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

  1. Qubits A ו-B מסובכים, ואז מופרדים במרחק גדול dd. Qubit A נמדד. איזו הצהרה נכונה לגבי המהירות שבה מצב ה-Qubit B מושפע?
  • א. Qubit B מושפע באופן מיידי, בתוך סבילות ניסויית, בניסויים שנערכו עד כה.
  • ב. Qubit B מושפע לאחר זמן d/cd/c, כלומר המצב הקוונטי "מתמוטט" בערך במהירות האור, בתוך סבילות ניסויית.
  • ג. Qubit B מושפע רק לאחר שהתרחשה תקשורת קלאסית, כלומר זה קורה בזמן ארוך יותר מ-d/cd/c.
  • ד. אף אחת מהנ"ל
  1. זכור שהסתברות המדידה קשורה לאמפליטודות במצבים קוונטיים. לדוגמה, אם Qubit נמצא בתחילה במצב α0∣0⟩+α1∣1⟩,\alpha_0|0\rangle+\alpha_1 |1\rangle, ההסתברות למדוד את המצב ∣0⟩|0\rangle היא ∣α0∣2.|\alpha_0|^2. לא כל קבוצות המדידות יתאימו בדיוק להסתברויות אלה, עקב דגימה סופית (בדיוק כפי שהטלת מטבע עשויה לתת דש פעמיים ברצף). ההיסטוגרמת מדידה למטה יכולה להתאים לאיזה מהמצבים הקוונטיים הבאים? בחר את התשובה הטובה ביותר.

entangled_teleportation_fig

  • א. ∣0⟩|0\rangle
  • ב. 12(∣0⟩−∣1⟩)\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)
  • ג. 12(∣0⟩+∣1⟩)\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)
  • ד. 45∣0⟩+35∣1⟩\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle
  • ה. 35∣0⟩+45∣1⟩\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle
  1. אילו מהמצבים הבאים מראים את Qubits A ו-B מסובכים? בחר את כל שמתאים.
  • א. 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)
  • ב. 45∣0⟩B∣0⟩A+35∣1⟩B∣1⟩A\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A
  • ג. 12(∣0⟩B∣1⟩A−∣1⟩B∣0⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)
  • ד. 12(∣0⟩B∣0⟩A+∣1⟩B∣0⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)
  • ה. ∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A
  1. במודול זה, הכנו מצב מסובך: 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A).\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right). אבל יש הרבה מצבים מסובכים אחרים שניתן להשתמש בהם לפרוטוקול דומה. איזה מהמצבים למטה יכול לתת היסטוגרמת מדידה של 2 Qubits כמו הבאה? בחר את התשובה הטובה ביותר.

entangled_teleportation_fig_0110

  • א. 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)
  • ב. 45∣0⟩B∣0⟩A+35∣1⟩B∣1⟩A\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A
  • ג. 12(∣0⟩B∣1⟩A−∣1⟩B∣0⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)
  • ד. 45∣0⟩B∣1⟩A+35∣1⟩B∣0⟩A\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A
  • ה. ∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A

שאלות לדיון​

  1. תאר את פרוטוקול הטלפורטציה הקוונטית, מתחילתו ועד סופו, לשותף/קבוצה שלך. בדוק אם יש להם מה להוסיף, או אם יש להם שאלות.
מקור: IBM Quantum docs — עודכן בתאריך 17 באפר׳ 2026
גרסה באנגלית ב-doQumentation — עודכן בתאריך 17 באפר׳ 2026
תרגום זה מבוסס על הגרסה האנגלית מתאריך משוער 26 במרץ 2026
בעיה באתר או בתרגום?בעיה בתוכן? ערוך ב-IBM Quantum docs