רעש ושגיאות

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

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

סיבות

רעש ושגיאות קלאסיים

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

רעש תרמי:

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

נזק והתדרדרות תרמיים:

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

אפקטים הנגרמים מקרינה (אירועי הפרעה בודדים, SEUs):

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

הפרעה אלקטרומגנטית:

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

הפרעה הדדית (crosstalk) בין מוליכי חיבור:

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

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

רעש ושגיאות קוונטיים

במחשוב קוונטי, רעש ושגיאות נדונים לעיתים קרובות יחד, אבל חשוב להכיר בהבדל. רעש קוונטי מתייחס להפרעה הפיזית הבסיסית שמשפיעה על qubits ועל מערכות קוונטיות. הוא כולל את כל הצורות של אינטראקציות או תנודות לא רצויות מהסביבה, בקרות לא מושלמות, או פגמי חומרה שגורמים למצב הקוונטי לסטות מהאידיאל. שגיאות קוונטיות הן הסטיות או הפגמים הספציפיים במידע הקוונטי שנובעים מהרעש הקוונטי. שגיאות קוונטיות הן ההתבטאויות הניתנות למדידה או התפעוליות של הרעש, ושגיאות כוללות bit-flips, phase-flips, ריסון אמפליטודה, ועוד. גם רעש וגם שגיאות יכולים להתרחש באופן רציף. לדוגמה, השדה המשמש בשער קוונטי יכול לסטות ב-0.1%, ב-0.15%, או בכל שבר אחר. זה יכול לגרום לפאזה על qubit שגויה, גם היא בכל כמות רציפה. אבל תראו שבפועל, ובמיוחד בתיקון שגיאות, נהוג להתייחס לשגיאות כאילו הן דיסקרטיות: קיבוץ האפקטים המצטברים ל-bit flip דיסקרטי בודד או לסיבוב פאזה יחיד. זה שימושי לתיקון שגיאות ולאפיונן, אבל זה לא אומר שהאפקט של הרעש על qubit הוא אך ורק קבוצה דיסקרטית של שגיאות.

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

Thermal:

שני מצבי הבסיס החישוביים $|0\rangle$ ו-$|1\rangle$ של qubit מופרדים על ידי כמות אנרגיה קטנה מאוד. הערך המדויק תלוי, כמובן, בחומרה הקוונטית. עבור qubits במצב מוצק (transmon בתדר קבוע) כמו אלה שמשמשים את IBM Quantum®, פער האנרגיה בין המצבים האלה הוא בסדר גודל של $10^{-24}$ J, או כמה מיקרו-אלקטרון וולט. אפשר לקשר את סולם האנרגיה הזה לתדר דרך $E=hf$ או לטמפרטורה מאפיינת. מכיוון שהטמפרטורה קשורה לאנרגיה הקינטית הממוצעת של חלקיקים בדגימה, אנחנו יכולים להשתמש בקבוע בולצמן כדי לקבל הערכה של הטמפרטורה שבה לחלקיקים ממוצעים תהיה מספיק אנרגיה כדי לגרום למעבר:

$$E\approx k_BT \rightarrow T~E/k_B \approx 10^{-24}\text{ J } \times 1.381 \times 10^{−23}\text{ J/K}\approx 100 \text{mK}.$$

כדי להפחית את הסיכוי שאינטראקציות תרמיות יגרמו למעברים ממצב בסיס חישובי אחד של qubit לאחר, יש לשמור על טמפרטורת ה-qubits הרבה מתחת ל-100 mK, ורצוי קרוב יותר ל-15-25 mK. כל עלייה משמעותית בטמפרטורה מעל הסף הזה תגרום לתפוסת מצב אקראית לחלוטין ולאובדן מוחלט של מידע קוונטי.

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

crosstalk והפרעה:

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

בארכיטקטורות qubit-ים על-מוליכים כמו אלה שמשמשות את IBM®, crosstalk יכול לנבוע מאותות בקרה במיקרוגל שדולפים ל-qubits שכנים, מצימוד לא מכוון בין מהודי קריאה (readout resonators), או מ-crosstalk שטף בין לולאות qubit.

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

פעולות שער לא מושלמות:

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

רעש מובנה קוונטית:

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

ברמה הקוונטית, אות המדידה נישא על ידי שדה מיקרוגל קוהרנטי עם מספר ממוצע סופי של פוטונים. בשל הטבע הקוונטי של שדות אלקטרומגנטיים, הרכיבים הקוואדרטיים (quadratures) של השדה מציגים תנודות מהותיות. התנודות האלה בלתי תלויות בפגמים טכניים ומתעוררות אפילו עבור מצב קוהרנטי אידיאלי. הגדלת מספר הפוטונים הממוצע $N$ מגדילה את אות המדידה, אבל רמת הרעש היסודית נשארת סופית, כך שההבחנה בין תוצאות משתפרת רק כמו $\sqrt{N}$​.

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

אי-ודאות זו לא שגיאה:

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

$|\psi\rangle = \frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle.$

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

לכן יש אי-ודאות בידע שלנו על המצב הקוונטי, המבוסס על כל מספר סופי של מדידות. ככל שאנחנו חוזרים על המדידות, הידע שלנו על המצב הקוונטי לפני המדידה משתפר, אבל הוא אף פעם לא מושלם. אפשר לומר בשפה יומיומית שתמיד יש איזו "שגיאה" בסיסית בכל תוצאת מדידה קוונטית. אבל זה שימוש שונה במונח "שגיאה", וזה מתואר טוב יותר כאי-ודאות סטטיסטית. התהליך של הגדלת הידע על מצב קוונטי באמצעות הרבה מדידות נקרא tomography של מצב קוונטי. עם זאת, tomography של מצב קוונטי לא מוגבל למדידות לאורך Z; הוא מתייחס בדרך כלל למדידות לאורך צירים אורתוגונליים (כמו X, Y ו-Z) לקביעת אמפליטודות ופאזה יחסית. למידע נוסף על התהליך הזה, ראו את הקטע הזה בקורס של John Watrous על ההצגה הכללית של מידע קוונטי, או ליישום מעשי, ראו את שיעור הטלפורטציה הזה מתוך הקורס מחשוב קוונטי בקנה מידה שימושי.

צפייה בשגיאות ובהצטברותן

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

בואו נתחיל עם שגיאות הרפיה אנרגטית (energy relaxation).

שגיאות הרפיה אנרגטית ($T_1$)

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

$$p = e^{-t/T_1}$$

כאן, הזמן $T_1$ הוא זמן מאפיין שנקבע ניסויית ושונה לכל qubit, ואף יכול להשתנות מעט עם הזמן. מחשבים קוונטיים של IBM® עוברים benchmarking באופן קבוע, כך שזמני $T_1$ שתמצאו רשומים עבור qubits במחשבים קוונטיים של IBM אמורים להיות מדויקים ועדכניים. ערך גדול של $T_1$ אומר שה-qubit נשאר במצב שהכנתם זמן רב יותר (בממוצע). ערכי $T_1$ טיפוסיים שונים בין ארכיטקטורות; ל-qubits במחשבים קוונטיים של IBM יש לעיתים קרובות זמני $T_1$ בסדר גודל של 200-300 $\mu s$, ואתם יכולים לבדוק את הערכים העדכניים בדף Compute resources.

הזמן המאפיין $T_2$ מודד משהו שונה: אובדן מידע הפאזה. נחזור לזה בהמשך.

כדי לצפות בשגיאות הרפיה אנרגטית, נכין qubits במצב $|1\rangle$, ואז נשאיר אותם ללא פעילות באופן מכוון לפרקי זמן ארוכים. זה החלק המלאכותי. בתהליכי עבודה קוונטיים אמיתיים, יכול להיות שיהיו לכם כמה qubits שיושבים ללא פעילות לפרקי זמן ארוכים בזמן שמתבצעים תהליכים על qubits אחרים; לכן, כמה מקרים של זמני חוסר פעילות כאלה הם לא מלאכותיים.

בואו נתחיל בייבוא כמה חבילות ובבחירת ה-backend הכי פחות עמוס.

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

_needed = {"cycler": "cycler", "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")

from qiskit_ibm_runtime import QiskitRuntimeService
import numpy as np
import matplotlib.pyplot as plt

# If your credentials are already saved locally
service = QiskitRuntimeService()

# To load an unsaved instance, uncomment the line below
# service = QiskitRuntimeService(channel = "ibm_quantum_platform", instance = "your crn here")

# To select the least-busy backend:
# backend = service.least_busy(simulator=False, operational=True)

# To specify the backend by name:
backend = service.backend("ibm_boston")

props = backend.properties()
print(backend)

<IBMBackend('ibm_boston')>

עכשיו נבחר qubit לעבוד איתו, במקרה הזה, qubit אפס. אנחנו יכולים לייבא ישירות את התכונות של ה-qubit הזה, כולל $T_1$ ו-$T_2$.

qubit_idx = 0
qubit_props = props.qubit_property(qubit_idx)

t1 = qubit_props["T1"][0]  # * 1e6  # Convert seconds to µs
t2 = qubit_props["T2"][0]  # * 1e6  # Convert seconds to µs

# print(f"Qubit {qubit_idx}: T1={t1} µs, T2={t2} µs")
print(f"Qubit {qubit_idx}: T1={t1} s, T2={t2} s")

Qubit 0: T1=0.0002737016180018049 s, T2=0.00042784777605680494 s

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

• זמן דגימה $dt$ - טיק השעון הקטן ביותר שדרכו אפשר ליישם תהליכי בקרה על המחשב הקוונטי.

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

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

בואו נבדוק את $dt$ עבור ה-backend שלנו, ונציג כמה טווחים סבירים לזמני שער.

print(f"Using backend: {backend.name}")

# Access the backend target
target = backend.target

def get_gate_times(target, gate_name):
    results = []

    if gate_name not in target:
        return results  # gate not supported

    # target[gate_name] is a dict: {(qubits): InstructionProperties}
    for qubits, props in target[gate_name].items():
        if props.duration is not None:
            results.append({"qubits": qubits, "duration_ns": props.duration * 1e9})

    return results

# Query some gates
for gate in ["cz", "x"]:
    times = get_gate_times(target, gate)

    print(f"\nGate: {gate}")
    if times:
        for entry in times[:5]:
            print(f"  Qubits {entry['qubits']}: {entry['duration_ns']:.2f} ns")
    else:
        print("  Not available on this backend")

Using backend: ibm_boston

Gate: cz
  Qubits (0, 1): 68.00 ns
  Qubits (1, 0): 68.00 ns
  Qubits (1, 2): 68.00 ns
  Qubits (2, 1): 68.00 ns
  Qubits (2, 3): 88.00 ns

Gate: x
  Qubits (0,): 32.00 ns
  Qubits (1,): 32.00 ns
  Qubits (2,): 32.00 ns
  Qubits (3,): 32.00 ns
  Qubits (4,): 32.00 ns

זמני השער האלה ישתנו מ-backend ל-backend. נקבע ידנית (hard-code) זמן שער של שני qubits שנלקח מ-ibm_boston בשווי 68 ns.

dt = backend.configuration().dt
two_q_gate_time = 68e-9
print("The sampling time is : ", dt)
print("dts per T_1 : ", t1 / dt)
print("2-qubit characteristic time : ", two_q_gate_time)
print("The sampling time intervals per two-qubit gate : ", two_q_gate_time / dt)
print("2-qubit gates per T_1 : ", t1 / two_q_gate_time)

The sampling time is :  4e-09
dts per T_1 :  68425.40450045122
2-qubit characteristic time :  6.8e-08
The sampling time intervals per two-qubit gate :  17.0
2-qubit gates per T_1 :  4025.0237941441897

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

נתחיל בשימוש ב-simulator עם מודל רעש, ואז נשווה את התוצאות לחומרה אמיתית.

from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer.primitives import EstimatorV2

pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

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

n_points = 50  # We will show 50 steps
delay_unit = 80  # The delay in units of two-qubit-time from above
shots = 100

נבנה מודל רעש עבור ה-simulator שלנו שכולל במפורש שגיאות הרפיה תרמית.

# Create noise model with thermal relaxation for delays
noise_model = NoiseModel()
error = thermal_relaxation_error(
    t1, t2, two_q_gate_time * delay_unit
)  # error model characterized by times in ns
noise_model.add_all_qubit_quantum_error(error, ["delay"])

sim = AerSimulator(noise_model=noise_model)

עכשיו נבנה את המעגלים וה-observables שלנו. אלה פשוטים באופן יוצא דופן. המעגלים יורכבו פשוט מהכנת ה-qubit ב-$|1\rangle$ ויישום עיכובים לפרקי זמן הולכים וגדלים, תוך שימוש בזמני השער המאפיינים וב-$dt$ שהוגדרו למעלה. ה-observables יהיו פשוט $Z$, כי מה שאנחנו רוצים לדעת הוא אם ה-qubit נשאר ב-$|1\rangle$ או התפורר ל-$|0\rangle$. אף שtranspilation לא תמיד נחוצה עבור simulators, אנחנו הולכים על זה ומבצעים transpile למעגלים שלנו כאן לשימוש מאוחר יותר על backend אמיתי.

observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times_sim = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        for j in range(i):
            qc.delay(delay_unit * two_q_gate_time, 0, "s")
            j = j + 1
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times_sim.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

אנחנו מריצים את ה-job שלנו באמצעות simulator.

pubs = list(zip(circuits, obs))

# Create AerSimulator with noise model as backend
simulator = AerSimulator(noise_model=noise_model)

# Create SamplerV2 from the AerSimulator backend
estimator = EstimatorV2.from_backend(simulator)

# Run the sampler on the circuit, specify shots
job = estimator.run(pubs)
result = job.result()

לבסוף, נצייר את הפלטים.

# Optional: color palette similar to 'mpl', style = 'clifford'

from cycler import cycler

plt.rcParams["axes.prop_cycle"] = cycler(
    color=[
        "#4C78A8",  # muted blue
        "#72B7B2",  # teal
        "#54A24B",  # green
        "#9C89CC",  # purple
        "#B279A2",  # mauve
    ]
)

# Everything else stays at Matplotlib defaults

# Example data: assume result is a list of objects with structure result[i].data.evs.item()
# and delay_times is already defined as a list of floats.

# Extract y-values
y_sim_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_sim_values = delay_times_sim

# Create the plot
plt.figure(figsize=(8, 5))
plt.plot(x_sim_values, y_sim_values, marker="o", linestyle="-", label="EV Data")

plt.xlabel("Idle Time (s)")
plt.ylabel("Probability of measuring |1>")
plt.title("T1 Decay")
plt.grid(True)
plt.show()

הדעיכה האקספוננציאלית נראית בבירור, ובזמן הזה, היא דועכת לפחות מ-40% סיכוי להיות ב-$|1\rangle$. שימו לב שזה עקבי בדיוק עם המודל: $p = e^{-t/t_1}$ כאשר בחרנו את $t$ המקסימלי להיות באותו סדר גודל כמו $t_1$; נזכיר שאמרנו ש-$t_1$ עשוי להתאים ל-60 שערים (או לאותו סדר גודל), וכאן $t$ מתאים ל-60 שערים. לכן

$$p \rightarrow e^{-0.25 \text{ ms}/0.267\text{ ms}} \approx 0.392$$

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

# This took 27 s on ibm_boston

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same time parameters and shots
n_points = 10
delay_unit = 400
shots = 100

# Measure Pauli Z's as your observables
observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        qc.delay(delay_unit * two_q_gate_time * i, 0, "s")
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

pubs = list(zip(circuits, obs))
estimator = EstimatorV2(mode=backend)
job = estimator.run(pubs=pubs)
result = job.result()

# To print the job id for later retrieval of data
# job_id = job.job_id()
# print(f"Job ID: {job_id}")

עכשיו נצייר את התוצאות.

fig, ax = plt.subplots()

# Convert from the expectation value of Z to the probability of a transition
y_real_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_real_values = delay_times

# Exponential decay to match theoretical model
t_smooth = np.linspace(0, x_sim_values[19], 100)  # Smooth x-range covering your data
y_decay = np.exp(-t_smooth / (t1))  # y = exp(-t/t1)
ax.plot(t_smooth, y_decay, "k--", linewidth=1, label=f"Perfect Decay (t1={t1:3f} s)")

# Add simulator values
ax.scatter(x_sim_values, y_sim_values, label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(x_real_values, y_real_values, label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Idle Time (s)")
ax.set_ylabel("Probability of measuring |1>")
ax.legend()
ax.set_title("T1 Decay")
ax.grid(True)

plt.show()

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

• עיכבנו באופן מלאכותי את המדידה לפרק זמן לא ריאלי. העיכובים האלה מתאימים לסולם הזמן של מעגלים עמוקים במיוחד שיכולים להכיל אלפי שערים של שני qubits. זה נעשה רק כדי להראות שהאפקטים של רעש תרמי קיימים. במעגלים אמיתיים שמיושמים על בעיות מהעולם האמיתי, פעולות היו מתבצעות על qubits אחרים בזמן שכמה מהם היו יושבים ללא פעילות מספיק זמן כדי ששגיאות הרפיה אנרגטית יהיו משמעותיות — אבל שגיאות אחרות היו שולטות לפני הגעה ל-$T_1$ מלא.
• לא נעשה שימוש בשום טכניקה של הפחתת שגיאות או דיכוי. אנחנו יכולים לשנות את עקומת הדעיכה הזו באמצעות טכניקות שנלמד בקורס הזה.
• השתמשנו כאן רק ב-100 shots, שזה נמוך באופן חריג כי ביקשנו רק להדגים שהאפקט קיים. סביר שתשתמשו ביותר מ-1,000 shots ביישומים.

הוויזואליזציה הראשונה הזו של שגיאה דרשה כמעט אף שער מלבד עיכובים (ושער ה-X הבודד ששימש להכנת $|1\rangle$). בואו נסתכל עכשיו על דוגמה נוספת שמתמקדת בשגיאת שער.

שגיאות שער והצטברותן

כשמפעילים שער קוונטי, נניח שער מסוג $X$, מבחינה תאורטית שער זה מסובב מצב קוונטי בזווית $\pi$ רדיאנים סביב הציר $X$ על כדור בלוך, וממפה את $\alpha |0\rangle + \beta |1\rangle$ אל $\alpha |1\rangle + \beta |0\rangle$ באמצעות

$$\begin{aligned} X|\psi\rangle & = R_X(\pi) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta/2)} & -i \sin{(\theta/2)} \\ -i \sin{(\theta/2)} & \cos{(\theta/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \beta \\ \alpha \end{pmatrix}\\ \end{aligned}$$

עם זאת, שער אמיתי אינו מושלם. ייתכן שהוא מכוּון בצורה לא מדויקת (מה שגורם לסיבובים שאינם בדיוק סביב הציר X), או שהוא גורם לסיבוב מעט גדול או קטן יותר מהמיועד. בואו נמדל שגיאת שער כסיבוב-יתר או תת-סיבוב טהור בזווית קטנה $\epsilon$.

$$\begin{aligned} X_\epsilon|\psi\rangle & = R_X(\pi+\epsilon) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta+\epsilon/2)} & -i \sin{(\theta+\epsilon/2)} \\ -i \sin{(\theta+\epsilon/2)} & \cos{(\theta+\epsilon/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & \approx \begin{pmatrix} \epsilon & 1-\epsilon^2/2 \\ 1-\epsilon^2/2 & \epsilon \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \epsilon \alpha+(1-\epsilon^2/2)\beta \\ (1-\epsilon^2/2)\alpha+\epsilon \beta \end{pmatrix}\\ \end{aligned}$$

אם שער לא מושלם מופעל פעמים רבות, שגיאות קטנות $\epsilon$ עלולות להצטבר. לפעמים שגיאות חוזרות אלה אף גורמות למצב לנוע באותו כיוון בכל פעם (תופעה שנקראת "הצטברות קוהרנטית", שאליה נחזור בהמשך). בואו נראה מה קורה כשמפעילים שער X אמיתי על Qubit פעמים רבות.

# This took 78 s on penguino1

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same bit flips
max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2(mode=backend)
results = estimator.run(pubs=pubs).result()
real_expectations = [pub_res.data.evs for pub_res in results]

# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService()           # uses stored IBM Quantum account
# job_id = "d5immof67pic7386l8eg"

# job = service.job(job_id)                 # retrieve the job
# results = job.result()                        # this is your .result() object

# Convert from the expectation value of Z to the probability of a transition
# y_real_values = [(1-r.data.evs.item())/2 for r in results]

# Create the plot
plt.figure(figsize=(8, 5))
# plt.plot(range(max_depth + 1), y_real_values, 'o-')
# plt.plot(x_real_values, y_real_values, marker='o', linestyle='-', color='blue', label='EV Data')
plt.plot(
    range(max_depth + 1),
    real_expectations,
    marker="o",
    linestyle="-",
    color="blue",
    label="EV Data",
)

plt.xlabel("Number of Flip-Back Cycles")
plt.ylabel("Expectation ⟨Z⟩")
plt.title("Accumulated Gate Noise Effects on Flips")
plt.grid(True)
plt.show()

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

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

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

from qiskit_aer.noise import NoiseModel, coherent_unitary_error
from qiskit_aer import AerSimulator
import numpy as np

# For your SINGLE-QUBIT test on qubit 0, just override X error specifically
noise_model = NoiseModel.from_backend(backend, gate_error=True, thermal_relaxation=True)

theta_error = 0.025  # model over-rotation error around 0.01-0.03 radians
U_over = np.array(
    [
        [np.cos(theta_error / 2), -1j * np.sin(theta_error / 2)],
        [-1j * np.sin(theta_error / 2), np.cos(theta_error / 2)],
    ]
)

unitary_error = coherent_unitary_error(U_over)
# Target ONLY qubit 0 (your circuit) - no warning!
noise_model.add_quantum_error(unitary_error, ["x"], [0])

simulator = AerSimulator(noise_model=noise_model)

WARNING: quantum error already exists for instruction "x" on qubits (0,) , appending additional error.

max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2.from_backend(simulator)
results = estimator.run(pubs).result()
expectations = [pub_res.data.evs for pub_res in results]  # no [0], use value directly

עכשיו אפשר לצייר את העקומות האמיתיות והמדומות יחד.

fig, ax = plt.subplots()

# Add simulator values
ax.scatter(range(max_depth + 1), expectations, c="blue", label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(range(max_depth + 1), real_expectations, c="red", label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Number of Flip-Back Cycles")
ax.set_ylabel("Expectation ⟨Z⟩")
ax.set_title("Accumulated Gate Noise Effects on Flips")
ax.legend()
ax.grid(True)

plt.show()

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

אפיון שגיאות קוונטיות

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

הבחנה חשובה נוספת היא האם השגיאות קוהרנטיות או לא-קוהרנטיות. לסיכום קצר (נדון בהן ביתר פירוט בהמשך), שגיאות קוהרנטיות בדרך כלל ממודלות על ידי פעולות אוניטריות ושומרות על טוהר המצב (purity). שגיאות לא-קוהרנטיות ממודלות על ידי ערוצים קוונטיים לא-אוניטריים, ובדרך כלל מפחיתות את טוהר המצב. קל לדמיין שגיאות לא-קוהרנטיות כאינטראקציות תרמיות שגורמות לאובדן מידע קוונטי, אך למעשה הן יכולות להיגרם על ידי כל צימוד אקראי לסביבה. כדוגמה לשגיאה קוהרנטית, נניח שיש אי-דיוק בכיוון הפולס במימוש שער מסוג RY, כך ששער $RY(\theta)$ גורם בפועל ל-$RY(\theta) \cdot RX(\epsilon)$. אי-דיוק כזה תמיד יגרום לסיבוב שגוי סביב X באותו כיוון. זו תהיה שגיאה קוהרנטית.

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

שגיאות SPAM

כפי שהשם מרמז, שגיאות SPAM מתעוררות בשני שלבים נפרדים של ניסוי קוונטי: ההכנה הראשונית והקריאה/מדידה. שגיאות הכנת מצב מתרחשות כשהחומרה נכשלת לאתחל באופן אמין את ה-Qubit-ים במצב ההתחלתי הרצוי ($|0\rangle$ עבור מחשבי IBM Quantum). הגורמים כוללים:

• עירור תרמי (Qubit-ים אמיתיים אינם מקוררים בצורה מושלמת ולעיתים יכולים להתחיל במצב $|1\rangle$ במקום $|0\rangle$)
• פוטונים שיוריים או רעש ברזוננטורים ב-Qubit-ים על-מוליכים
• סחיפה בכיול המשפיעה על מידת הדיוק של איפוס ה-Qubit-ים

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

• רעש במגבר הקריאה הגורם לבלבול בין $|0\rangle$ ל-$|1\rangle$

• רלקסציה של ה-Qubit במהלך הקריאה (לדוגמה, Qubit במצב $|1\rangle$ דועך ל-$|0\rangle$ ממש לפני המדידה או במהלכה)

• צליבת ערוצים (crosstalk) בין קווי קריאה: קריאת Qubit אחד משפיעה מעט על קריאות ה-Qubit-ים השכנים

• ספי הבחנה לא מושלמים במערכות המדידה מבוססות-הרזוננטור של IBM

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

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

מבחינה מתמטית, אפשר לתאר שגיאות SPAM כאלה שמייצרות התפלגות רועשת $\vec{p}_\text{noisy}$ המתקשרת להתפלגות האידיאלית $\vec{p}_\text{ideal}$ באמצעות מטריצה $A$:

$$\vec{p}_\text{noisy} = A \vec{p}_\text{ideal}$$

כאן $p_i$ היא ההסתברות למדוד מחרוזת סיביות $i$, ו-$A_{ij}$ היא ההסתברות לקבל מצב $j$ כאשר המצב היה אמור להיות מוכן במצב $i$. דמיינו את ההקשר של מחרוזות סיביות שנדגמו מ-Sampler. התפלגות המצבים שנמדדה תכלול הרבה מדידות מדויקות, אך גם כמה מדידות שבהן ההוראות להכנת המצב אינן תואמות את המצב שנצפה. משמעות הדבר היא שההסתברויות יהיו קצת לא מדויקות.

באיור שלמעלה, חלק (a) מציג את ההתפלגות האידיאלית של מצב GHZ בצבע טורקיז, ואת המדידות בפועל בצבע סגול. בחלק (b) רואים דוגמה למטריצת $A$. שימו לב שהמטריצה אינה סימטרית באופן מושלם לאורך האלכסון, שכן אין הכרח שכל Qubit יהיה בעל סבירות שווה להחזיר בטעות 0 ולהחזיר בטעות 1. בפועל, לרוב קשה להפריד בין שגיאות הכנה לשגיאות קריאה, ולכן הן מטופלות לעיתים קרובות כמקשה אחת (מכאן השימוש הנפוץ במונח SPAM).

דרך אחת לתקן שגיאות SPAM אלה היא להשתמש במעגלים פשוטים עם תוצאות מדידה אידיאליות ידועות, ולהשוות אותן לתוצאות שנמדדו בנוכחות שגיאות SPAM. אפשר להשתמש בכך כדי להסיק לאחור את התוצאות האידיאליות של מעגלים מורכבים יותר. עבור מצבים כלליים בעלי אנטרופיה גבוהה, ייתכן שהדבר ידרוש בניית מטריצה עם $2^N\times2^N$ הסתברויות, אך במקרים פחות קיצוניים אפשר להפחית את השגיאות הללו.

שגיאות קוהרנטיות לעומת שגיאות לא-קוהרנטיות

שגיאות קוהרנטיות הן סיבובים שגויים, שיטתיים, דטרמיניסטיים ואוניטריים של המצב הקוונטי. הן נובעות מפעולות קוונטיות לא מושלמות שסוטות בצורה צפויה. דוגמאות כוללות שגיאות קלות בסיבוב שמופעל על ידי שערי סיבוב Qubit בודד, כולל כאלה שנגרמות על ידי סחיפה בכיול שגורמת לסיבוב-יתר או תת-סיבוב באופן עקבי. מבחינה מתמטית, אפשר לכתוב ששער סיבוב אמיתי, נניח $\tilde{R_X}(\theta)$, ניתן על ידי שער הסיבוב האידיאלי בתוספת שגיאה נוספת כלשהי:

$$\tilde{R_X}(\theta) = R_X(\theta + \epsilon)$$

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

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

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

מדוע הן מטרידות

שגיאות קוהרנטיות יכולות "להצטבר" בדרכים מסוכנות, ולייצר סטיות גדולות מהמצב הנכון אם הן לא מאוקראנות (randomized) או מתוקנות.

שגיאות לא-קוהרנטיות הן סטוכסטיות, אקראיות, ולעיתים קרובות לא-אוניטריות. הן נובעות מאינטראקציות עם הסביבה או ממקורות רעש לא מבוקרים. כבר ראינו כמה דוגמאות: רלקסציית אנרגיה / דעיכת $T_1$ היא לא-קוהרנטית. כך גם רעש שער סטוכסטי, רעש תרמי ושגיאת מדידה.

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

שגיאות לא-קוהרנטיות גורמות ל-Qubit-ים לאבד מידע באופן בלתי הפיך (אובדן טוהר ומידע פאזה).

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

מטריצות צפיפות וערוצים קוונטיים

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

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

במכניקת הקוונטים הסטנדרטית, מצב "טהור" נכתב כ-$|\psi\rangle$. כאן "טהור" מתייחס לטוהר המידע או הידיעה על הכנת המצב; זה לא אומר מצב עצמי של איזושהי מערכת. לדוגמת Qubit, $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ הוא מצב טהור מכיוון שיש לנו ידיעה מושלמת על האמפליטודות היחסיות והפאזה. ההתפתחות בזמן של מצב טהור כזה נשלטת על ידי אופרטור אוניטרי $U$:

$$|\psi\rangle \rightarrow U|\psi\rangle$$

לפי משוואת שרדינגר, שבה $U = e^{-iHt/\hbar}$, כאשר $H$ הוא ההמילטוניאן של המערכת ו-$\hbar$ הוא קבוע פלאנק המצומצם, שלעיתים קרובות "נקבע להיות שווה לאחד", או בצורה מדויקת יותר, נספג לתוך ההמילטוניאן כך שכל האנרגיות ניתנות ביחידות של $\hbar$.

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

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

התפתחות אוניטרית לבדה אינה יכולה לתאר תהליכים אלה; לכן, אנחנו זקוקים לייצוג כללי יותר של מצבים ותהליכים קוונטיים. מצב מעורב (mixed state) מתאר התפלגות קלאסית של מצבים קוונטיים. כלומר, אנחנו כבר מכירים את העובדה שלמצב הקוונטי: $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ יש סיכוי של 50% להימדד (לקרוס למידע קלאסי) במצב $|0\rangle$, וסיכוי של 50% להימדד במצב $|1\rangle$. אבל הטענה היא שהמצב הקוונטי ההתחלתי הוא בדיוק $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ בהסתברות של 100%. עכשיו אנחנו רוצים להוסיף מעל ההסתברות הקוונטית-מכנית הסתברות קלאסית, לדוגמה:

המצב הקוונטי ההתחלתי מוכן במצב $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ בהסתברות קלאסית של 25%, ומוכן במצב $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle-i|1\rangle)$ בהסתברות קלאסית של 75% (שימו לב לפאזות היחסיות השונות).

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

מצב מעורב מתואר על ידי אופרטור צפיפות:

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

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

$$\rho = \sum_{i,j} \rho_{ij} |i\rangle\langle j|.$$

כאן האיברים האלכסוניים $\rho_{ii}$​ הם הסתברויות:

• $\rho_{00}$​ = ההסתברות שה-Qubit נמצא ב-$|0\rangle$

• $\rho_{11}$​ = ההסתברות שה-Qubit נמצא ב-$|1\rangle$

הם ממשיים, אי-שליליים, וסכומם שווה ל-1.

איברים חוץ-אלכסוניים $\rho_{ij}, i \neq j$ הם קוהרנסים (coherences): יחסי פאזה או יכולת התאבכות, והם בדרך כלל מתואמים לכמות המידע הקוונטי-מכני שקיים במצב. זו הצהרה לא פורמלית, אבל בואו נראה מה המשמעות שלה בפועל.

דוגמה

קחו בחשבון את המצב הטהור $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. (a) מה אתם יודעים על הסתברויות המדידה ועל מידע הפאזה בלי לעשות שום חישוב? (b) בנו את מטריצת הצפיפות ואמתו את האינטואיציה שלכם.

Solution:

(a) מכיוון שזה מצב טהור, יש רק פאזה אפשרית אחת בין $|0\rangle$ ל-$|1\rangle$: +1. זהו מידע פאזה מושלם, ולכן אנחנו מצפים שהאיברים החוץ-אלכסוניים במטריצת הצפיפות שלנו יהיו גדולים. ייתכן שיש לכם אינטואיציה מפורטת יותר לגבי האיברים החוץ-אלכסוניים, אבל זה מספיק לעת עתה. בנוסף, האמפליטודות של שני מצבי הבסיס שוות, ולכן אנחנו מצפים להסתברות של 50% למדוד את $|0\rangle$ או את $|1\rangle$. לכן אנחנו מצפים שהאיברים האלכסוניים יהיו 1/2. (b) באמצעות ההגדרה שלמעלה:

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ רק עבור המצב $|\psi\rangle$. אז אפשר לכתוב

$$\begin{aligned} \rho & = 1 |\psi\rangle\langle\psi| \\ & = \frac{1}{2}(|0\rangle+|1\rangle)(\langle0|+\langle1|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}. \end{aligned}$$

האיברים האלכסוניים הם כל אחד $1/2$ כצפוי, והאיברים החוץ-אלכסוניים גדולים (סכומם שווה לאחד).

עכשיו בואו נראה מה קורה כשאין לנו מידע פאזה טוב.

דוגמה

קחו בחשבון מקרה דומה, אבל הפעם עם הסתברות קלאסית של 50% להיות במצב $|\psi_+\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ והסתברות קלאסית של 50% להיות במצב $|\psi_-\rangle = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$. אותן שתי שאלות: (a) מה אתם יודעים על הסתברויות המדידה ועל מידע הפאזה בלי לעשות שום חישוב? (b) בנו את מטריצת הצפיפות ואמתו את האינטואיציה שלכם.

Solution:

(a) כמו קודם, האמפליטודות של שני מצבי הבסיס שוות, ולכן אנחנו מצפים להסתברות של 50% למדוד את $|0\rangle$ או את $|1\rangle$. לכן אנחנו מצפים שהאיברים האלכסוניים יהיו 1/2. אבל הפעם יש שתי אפשרויות הפוכות לפאזה בין $|0\rangle$ ל-$|1\rangle$: +1 ו-(-1), וכל אחת מהן סבירה באותה מידה. אפשר לצפות שעם שתי פאזות הפוכות שסבירותן שווה, יש מעט מאוד או אין בכלל מידע פאזה. אפשר לצפות שהאיברים החוץ-אלכסוניים יהיו קטנים. (b) שוב באמצעות ההגדרה שלמעלה

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ רק עבור שני המצבים $|\psi_+\rangle$ ו-$|\psi_-\rangle$. אז אפשר לכתוב

$$\begin{aligned} \rho & = \frac{1}{2} |\psi_+\rangle\langle\psi_+| + \frac{1}{2}|\psi_-\rangle\langle\psi_-| \\ & = \frac{1}{4}(|0\rangle+|1\rangle)(\langle0|+\langle1|)+\frac{1}{4}(|0\rangle-|1\rangle)(\langle0|-\langle1|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}+\frac{1}{4}\begin{pmatrix} 1 & -1 \\ -1 & 1\end{pmatrix}\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 \\ 0 & 1\end{pmatrix}. \end{aligned}$$

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

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

בדקו את ההבנה שלכם

כתבו את מטריצת הצפיפות עבור מצב בל (Bell) הטהור $|\Phi_+\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$.

תשובה

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ רק עבור המצב $|\Phi_+\rangle$. אז אפשר לכתוב

$$\begin{aligned} \rho & = 1 |\Phi_+\rangle\langle\Phi_+| \\ & = \frac{1}{2}(|00\rangle+|11\rangle)(\langle00|+\langle11|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

כתבו את מטריצת הצפיפות עבור הסתברות קלאסית של 25% ל-$|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ והסתברות קלאסית של 75% ל-$|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$.

תשובה

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ רק עבור שני המצבים $|\Phi_+\rangle$ ו-$|\Psi_-\rangle$. אז אפשר לכתוב

$$\begin{aligned} \rho & = \frac{1}{4} |\Phi_+\rangle\langle\Phi_+| + \frac{3}{4}|\Psi_-\rangle\langle\Psi_+| \\ & = \frac{1}{8}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{3}{8}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{3}{8}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 3 & -3 & 0 \\ 0 & -3 & 3 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

שנו את העבודה שלכם מהשאלה הקודמת כדי לכתוב את מטריצת הצפיפות עבור הסתברות קלאסית של 50% ל-$|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ והסתברות קלאסית של 50% ל-$|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$. נחשו איזה מידע פאזה אמור להישאר.

תשובה

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ רק עבור שני המצבים $|\Phi_+\rangle$ ו-$|\Psi_-\rangle$. אז אפשר לכתוב

$$\begin{aligned} \rho & = \frac{1}{2} |\Phi_+\rangle\langle\Phi_+| + \frac{1}{2}|\Psi_-\rangle\langle\Psi_-| \\ & = \frac{1}{4}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{1}{4}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{1}{4}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

האיברים האלכסוניים מסתכמים ל-1, כפי שצריך. האיברים החוץ-אלכסוניים אינם מתבטלים כאן, כפי שקרה בדוגמה הקודמת של Qubit בודד. אפשר לראות מדוע, במתמטיקה, אבל הסבר קצר הוא שיש יותר מצבים במרחב הילברט שלנו עכשיו. אף על פי שלמצב בל הראשון הייתה פאזה יחסית חיובית ולשני הייתה פאזה שלילית, פאזות אלה היו בין מצבי בסיס שונים. למצב בל הראשון הייתה פאזה בין $|00\rangle$ ל-$|11\rangle$, בעוד שלשני הייתה פאזה יחסית בין $|01\rangle$ ל-$|10\rangle$.

ערוצים קוונטיים

ערוץ קוונטי הוא הטרנספורמציה הפיזיקלית הכללית ביותר המותרת עבור מצב קוונטי. הוא לוקח מטריצת צפיפות התחלתית $\rho$ למטריצת צפיפות אחרת:

$$\rho \quad \longrightarrow \Phi(\rho)$$

כאן $\Phi(\rho)$ פירושו ערוץ קוונטי $\Phi$ הפועל על מטריצת צפיפות $\rho$, ואין לבלבל זאת עם מצבי בל $|\Phi_+\rangle$ או $|\Phi_-\rangle$.

ערוצים קוונטיים הם כלליים ביותר. הם יכולים לכלול:

• התפתחות אוניטרית $\Phi(\rho) = U\rho U^\dagger$

• תערובות הסתברותיות של אופרטורים אוניטריים

• Measurements

• Decoherence

• דעיכת אמפליטודה (אובדן אנרגיה)

• דה-פאזינג (אובדן מידע פאזה)

• אינטראקציה עם סביבה ועוד דברים רבים אחרים.

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

האילוצים היחידים על ערוץ קוונטי הם שהוא חייב להיות:

1. ליניארי תערובות של מצבים צריכות להתפתח בעקביות: $\Phi(p\rho_1 + (1-p)\rho_2) = p\Phi(\rho_1) + (1-p)\Phi(\rho_2)$
2. חיובי לחלוטין הוא לא אמור לייצר הסתברויות שליליות, גם אם המערכת שלכם שזורה (entangled) עם משהו אחר.
3. משמר עקבה ההסתברויות חייבות להסתכם ל-1. לעיתים אלה מכונסים יחד תחת ראשי התיבות CPTP: Completely Positive Trace-Preserving maps.

יש ייצוגים שונים של ערוצים קוונטיים, כולל ייצוגי Stinespring, Kraus ו-Choi. אלה מטופלים בפירוט בשיעור הזה על ערוצים קוונטיים בניסוח כללי של מידע קוונטי, ושם גם מראים שהם שקולים. לא ניכנס לייצוגים השונים האלה כאן. די יהיה לומר שהם אנלוגיים לתיאור וקטורים באמצעות שלוש מערכות צירים שונות. כל אחד עשוי להדגיש היבטים שונים ולבנות אינטואיציה בדרך שונה; אבל כולם נותנים לכם את התשובה הנכונה. ייצוגי Kraus נוחים למטרות שלנו. הם מציעים דרך נוסחתית נוחה לבטא את פעולת הערוץ באמצעות כפל וחיבור מטריצות. בפרט, ייצוג Kraus הוא מפרט של ערוץ, $\Phi$, בצורה הבאה.

$$\Phi(\rho) = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}$$

כאן, $A_0,\ldots,A_{N-1}$ הן מטריצות שכולן בעלות אותם ממדים: העמודות שלהן מתאימות למצבים הקלאסיים של מערכת הקלט, $\mathsf{X}$, והשורות שלהן מתאימות למצבים הקלאסיים של מערכת הפלט, בין אם זו $\mathsf{X}$ או מערכת אחרת כלשהי $\mathsf{Y}$. כדי ש-$\Phi$ יהיה ערוץ תקף, המטריצות האלה חייבות לקיים את התנאי הבא.

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

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

ערוץ דה-פאזינג מלא

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

$$\rho_i = \begin{pmatrix} \rho_{11} & \rho_{12} & \dots & \rho_{1n} \\ \rho_{21} & \rho_{22} & \ddots & \rho_{2n} \\ \vdots & \ddots & \ddots & \vdots \\ \rho_{n1} & \rho_{n2} & \dots & \rho_{nn} \end{pmatrix}$$

ולמפות אותה אל

$$\rho_f = \Phi(\rho_i) = \begin{pmatrix} \rho_{11} & 0 & \dots & 0 \\ 0 & \rho_{22} & \ddots & 0 \\ \vdots & \ddots & \ddots & \vdots \\ 0 & 0 & \dots & \rho_{nn} \end{pmatrix}$$

אם נניח שמטריצת הצפיפות כבר נכתבה בבסיס החישובי, אפשר לבטא את $\rho_{ij}$ כ-$\langle i|\rho|j\rangle$. זה מציע קבוצה של מטריצות Kraus שיכולות לבצע את פעולת הערוץ הזו: $A_k = |k\rangle\langle k|$. בואו ניישם את האסטרטגיה הזו על מקרה דוגמה של Qubit בודד, ונראה אם היא עובדת כפי שאנחנו דורשים:

נגדיר $A_0 = \vert 0\rangle\langle 0\vert$ ו-$A_1 = \vert 1\rangle\langle 1\vert$.

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger} & = \vert 0\rangle\langle 0 \vert \rho \vert 0\rangle\langle 0 \vert + \vert 1\rangle\langle 1 \vert \rho \vert 1\rangle\langle 1 \vert \end{aligned}$$

מכיוון ש-$\langle 0 \vert \rho \vert 0\rangle$ הוא מספר, אפשר פשוט להעביר את הווקטור $\vert 0\rangle$ מעברו. הדבר חל גם על האיבר השני. יש לנו:

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger}& = \langle 0 \vert \rho \vert 0\rangle \, \vert 0\rangle\langle 0 \vert + \langle 1 \vert \rho \vert 1\rangle \, \vert 1\rangle\langle 1 \vert \\[2mm] & = \begin{pmatrix} \langle 0 \vert \rho \vert 0 \rangle & 0 \\[1mm] 0 & \langle 1 \vert \rho \vert 1 \rangle \end{pmatrix} \end{aligned}$$

שימו לב שהמטריצות הללו מקיימות את התנאי הנדרש:

$$\sum_{k = 0}^1 A_k^{\dagger} A_k = \vert 0\rangle\langle 0\vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert 1\rangle\langle 1\vert = \vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert = \mathbb{I}$$

כדאי לציין שהבחירה הזו של מטריצות Kraus אינה ייחודית.

אפיון רעש כערוצים

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

שגיאות לא קוהרנטיות

בואו נחזור לשגיאות לא קוהרנטיות ונתמקד בשגיאות רלקסציית אנרגיה. נזכיר שהמצב $|0\rangle$ הוא מצב היסוד של הקיוביט, והמצב $|1\rangle$ הוא בעל אנרגיה מעט גבוהה יותר. לפעמים מצבים קוונטיים פשוט דועכים באופן ספונטני מרמת אנרגיה גבוהה יותר לרמה נמוכה יותר. תהליך הפליטה הספונטנית הוא נושא עשיר, ולא ניתן להבין אותו באמת בלי טיפול באמצעות תורת השדות הקוונטית. אבל האינטואיציה מוכרת לכולנו: הפרעות אקראיות עלולות לגרום לסלע להתגלגל במורד גבעה; הן לא יגרמו לסלע להתגלגל במעלה גבעה. משך הזמן שבו קיוביט נשאר במצב האנרגיה הגבוה מאופיין באמצעות זמן $T_1$. באופן מדויק יותר, ההסתברות שקיוביט שהוכן במצב $|1\rangle$ יישאר באותו מצב לאחר זמן $t$ היא $e^{-t/T_1}$. או, באופן שקול, ההסתברות $p$ לשגיאת רלקסציית אנרגיה לאחר זמן $t$ היא

$$p = 1-e^{-t/T_1}$$

כדי לתאר זאת באמצעות ערוץ קוונטי בייצוג Kraus, אנחנו זקוקים למטריצות Kraus שמתאימות ל:

• השארת מצבי $|0\rangle$ ללא שינוי
• שינוי מצבי $|1\rangle$ למצב $|0\rangle$ בהסתברות כלשהי p.

הבה נגדיר

$$\begin{aligned} A_0 & = 1|0\rangle\langle0| + \sqrt{1-p}|1\rangle\langle1|\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}|0\rangle\langle1|\\ & = \begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix} \end{aligned}$$

ראשית, נבדוק שיש לכך את האפקט הרצוי על מטריצת צפיפות. נבחן מערכת שנמצאת במצב טהור $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. ראינו בדוגמה למעלה שמטריצת הצפיפות במקרה הזה היא

$$\rho =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}.$$

בהפעלת ערוץ רלקסציית האנרגיה באמצעות מטריצות Kraus, אנחנו מקבלים את מטריצת הצפיפות החדשה, הממופה:

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^{\dagger} + A_1 \rho A_1^{\dagger}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}+\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\\ & = \frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix} \end{aligned}$$

בואו נבחן את זה ונשווה אותו לאינטואיציה שלנו:

ראשית, נבדוק את הגבול כאשר $t$ שואף לאפס. אנחנו מקבלים בחזרה את מטריצת הצפיפות ההתחלתית שלנו, כפי שצריך:

$$\Phi(\rho,t \rightarrow 0) = \lim_{p\rightarrow 0}{\frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix}} = {\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}}.$$

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

$$\begin{aligned} P_{|0\rangle} & = \langle 0 | \rho |0\rangle = \frac{1}{2}(1+p) = 1-\frac{1}{2}e^{-t/T_1}\\ P_{|1\rangle} & = \langle 1 | \rho |1\rangle = \frac{1}{2}(1-p) = \frac{1}{2}e^{-t/T_1} \end{aligned}$$

אנחנו יכולים גם לראות בקלות שההסתברויות למדוד $|0\rangle$ ו-$|1\rangle$ מסתכמות ל-1, כפי שצריך.

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

$$\lim_{p\rightarrow 1}{\sqrt{1-p}} = \lim_{t\rightarrow \infty}{\sqrt{e^{-t/T_1}}} = 0$$

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

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

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

בדקו את ההבנה שלכם

אמתו שמטריצות Kraus ששימשו בערוץ רלקסציית האנרגיה למעלה מקיימות את תנאי הזהות:

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

תשובה

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

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

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

$$p = 1-e^{-t/T_2}$$

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

$$\begin{aligned} A_0 & = \sqrt{1-p}\mathbb{I}\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}Z\\ & = \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\\ \end{aligned}$$

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

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

בדקו את ההבנה שלכם

אמתו שמטריצות Kraus שהוגדרו למעלה עבור ערוץ הפחתת הפאזה מקיימות את תנאי הזהות:

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

תשובה

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \begin{pmatrix} 1-p & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} p & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

התחילו עם מצב טהור של קיוביט בודד לבחירתכם, עם פאזה מוגדרת היטב בין $|0\rangle$ ל-$|1\rangle$. כתבו אותו כמטריצת צפיפות. הפעילו את ערוץ הפחתת הפאזה באמצעות אופרטורי Kraus שהוצעו למעלה. פרשו את מטריצת הצפיפות הממופה המתקבלת.

תשובה

בואו נבחר את המצב $|\psi\rangle = \frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle$. מטריצת הצפיפות המתאימה $\rho$ היא

$$\begin{aligned} \rho & = \sum_i p_i |\psi_i\rangle\langle\psi_i|\\ & = 1\left(\frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle\right) \left( \frac{4}{5}|0\langle +i\frac{3}{5} |1\langle\right)\\ & = \frac{16}{25}\begin{pmatrix} 1 & 0 \\ 0 & 0\end{pmatrix}+\frac{12i}{25}\begin{pmatrix} 0 & 1 \\ 0 & 0\end{pmatrix}-\frac{12i}{25}\begin{pmatrix} 0 & 0 \\ 1 & 0\end{pmatrix}+\frac{9}{25}\begin{pmatrix} 0 & 0 \\ 0 & 1\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \end{aligned}$$

כעת נפעיל את ערוץ הפחתת הפאזה על מטריצת הצפיפות הזו באמצעות אופרטורי Kraus.

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^\dagger + A_1 \rho A_1^\dagger\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16(1-p) & 12i(1-p) \\ -12i(1-p) & 9(1-p)\end{pmatrix} + \frac{1}{25}\begin{pmatrix} 16p & -12ip \\ 12ip & 9p\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i(1-2p) \\ -12i(1-2p) & 9\end{pmatrix} \end{aligned}$$

ראשית, אנחנו שמים לב שסכום האיברים באלכסון אכן שווה לאחד, כפי שצריך. שנית, שימו לב שהאיברים מחוץ לאלכסון היו גדולים בתחילה, עם סכום של 24/25, מה שמצביע על קוהרנטיות חזקה. שימו לב שככל שההסתברות לשגיאת הפחתת פאזה $p$ עולה, האיברים הללו מחוץ לאלכסון פוחתים. גם זה תואם את הציפייה שלנו. נקודה מעודנת אחת: שימו לב למה שקורה כאשר $p\rightarrow 1$. הקוהרנטיות שוב הופכת לחזקה! זה נראה בהתחלה לא אינטואיטיבי, מכיוון שהסתברות גבוהה לשגיאת הפחתת פאזה אמורה לבלבל את הפאזה שלנו, נכון? העניין הוא שאם אנחנו בטוחים ב-100% ששגיאת פאזה מתרחשת, אז שוב יש לנו מידע חזק על הפאזה; הפאזה פשוט התהפכה. עם התובנה הזו, אנחנו יכולים לצפות שהמידע הגרוע ביותר על הפאזה יתאים לסיכוי של 50-50 להתרחשות שגיאת פאזה, וזה אכן מה שאנחנו מוצאים.

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

• שגיאת היפוך ביט (שגיאת X) בהסתברות $p_x$
• שגיאת היפוך פאזה (שגיאת Z) בהסתברות $p_z$
• שילוב של X ו-Z (שגיאת Y) בהסתברות $p_y$ כאן, $0\leq p_j \leq 1$ לכל $j$. מסקנה נלווית היא שההסתברות שלא תתרחש שגיאה כלל היא $p_I = 1-p_x-p_y-p_z$.

אופרטורי Kraus עבור ערוץ זה הם:

$$\begin{aligned} A_0 & = \sqrt{p_I}I\\ A_1 & = \sqrt{p_X}X\\ A_2 & = \sqrt{p_Y}Y\\ A_3 & = \sqrt{p_Z}Z \end{aligned}$$

במקרה של ערוץ רעש פאולי, מועיל לרשום את הערוץ עצמו:

$$\Phi(\rho) = p_I I\rho I + p_X X\rho X+p_Y Y \rho Y + p_Z Z \rho Z$$

אנחנו רואים מהצורה הזו שערוץ רעש פאולי מיישם שגיאה אחת או יותר שמתאימות לפעולה של מטריצות פאולי $P_j$, כל אחת בהסתברות $p_j$.

שילובים שונים של הסתברויות היפוך ייצרו הדמיות ויזואליות שונות. כאן אנחנו מציגים ויזואלית את המקרה המיוחד שבו $p_X = p_Y = p_Z$, הנקרא גם ערוץ הדה-פולריזציה (depolarizing channel).

מידול שגיאות קוהרנטיות

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

שגיאות קוהרנטיות ניתנות למידול באמצעות שערים יוניטריים לא רצויים. כמה דוגמאות פשוטות כוללות סיבובים לא מיושרים או תת-/יתר-סיבוב. בתמונה למטה, אנחנו מציגים סיבוב לא מיושר כסיבוב $Y$ נוסף בכמות קטנה $\epsilon$ בנוסף לסיבוב הרצוי סביב הציר $X$. יתר-סיבוב מתואר על ידי הסיבוב הרצוי $X$ וגם סיבוב נוסף כלשהו סביב אותו ציר $X_\epsilon$.

שגיאות בשני קיוביטים וקווי אור מוצללים

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

שערי תהודה-חוצה מהדהדים

ארכיטקטורות חומרה שונות ומשפחות שערים שונות מהנדסות את האינטראקציה הזו בדרכים שונות. מחשבים קוונטיים של IBM מיישמים שערים אבסטרקטיים בשני קיוביטים כמו שערי CZ או CX באמצעות שערי ECR (תהודה-חוצה עם הד) שהם שערים טבעיים (native) של החומרה. שערי ECR מייצרים אינטראקציית $ZX$ אפקטיבית באמצעות הנעה במיקרוגל. שערים קשורים כמו CNOT נבנים מ-$ZX$ על ידי הוספת סיבובים בקיוביט בודד.

לקיוביטים שונים יש תדרי תהודה שונים (תדרים שאליהם הם מגיבים בעוצמה). פעולה סטנדרטית עשויה להשתמש בתדר התהודה הזה כדי לגרום למעבר בקיוביט. אבל מה קורה אם מניעים (drive) את קיוביט C בתדר התהודה של קיוביט T סמוך? קיוביטים סמוכים מקושרים באמצעות אינטראקציה קיבולית קבועה או אינטראקציה שמתווכת על ידי מהוד (resonator). בשל צימוד זה, הנעה על קיוביט C "דולפת" לתוך ההמילטוניאן של קיוביט T. העוצמה והכיוון של ההנעה האפקטיבית הזו תלויים במצב של קיוביט C ($|0\rangle$ או $|1\rangle$). כאן, קיוביט C הוא הבקרה וקיוביט T הוא המטרה.

התוצאה היא סיבוב אפקטיבי של קיוביט המטרה, המותנה במצב של קיוביט הבקרה. באופן מתמטי:

$$H_{eff} \approx \Omega Z_C X_T +\text{איברים נוספים}$$

האינטראקציה ZX הזו היא בדיוק מה שצריך כדי לבנות CNOT. אבל האיברים הנוספים עשויים לכלול שגיאות מסוימות, וכמעט בוודאות כוללים צימוד קיבולי בין קיוביטים C ו-T, שמתאים לאיבר ZZ.

$$H_\mathrm{CR} = \underbrace{\Omega \, Z_C X_T}_{\text{desired}} + \underbrace{\alpha\, I_C X_T + \beta\, Z_C I_T + \gamma\, I_C Z_T + \delta\, Z_C Z_T + \dots}_{\text{undesired}}.$$

אנחנו יכולים לחשוב על האיברים הנוספים האלה בדרך הבאה:

• IX = קיוביט המטרה מונע (driven) בלי כוונה

• ZI = קיוביט הבקרה רוכש סיבוב Z לא רצוי

• IZ = קיוביט המטרה רוכש סיבוב Z לא רצוי

• ZZ = היסט פאזה סטטי התלוי-מצב

• אחרים = אינטראקציות קטנות מסוג XY, XX, ואינטראקציות מסדר גבוה יותר

שער ECR הוא פשוט סיבוב מבוקר בתוספת פולס הד (echo) שנבחר בקפידה על קיוביט הבקרה. ההד הופך את הסימן של איברים לא רצויים רבים תוך שמירה על האינטראקציה ZX. תהליך זה מבטל שגיאות IX ו-ZI היטב למדי, ולעיתים גם כמה איברים מסדר גבוה יותר. אבל ההד אינו יכול לבטל את צימוד ה-ZZ הסטטי, מכיוון שהוא מתחלף (commutes) עם פולס ההד. ישנן אינטראקציות נוספות שלא יתבטלו בתהליך זה: אי-לינאריות שיורית מסוימת ואפקטים של קיוביטים צופים (spectator qubits), דליפה (leakage) וזיהום הנעה ארוך-טווח, בתוספת כמה נוספים — אבל איבר ה-ZZ חשוב במיוחד.

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

בדקו את ההבנה שלכם

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

תשובה

לשערים בשני קיוביטים יש שיעורי שגיאה גבוהים בהרבה מאשר לשערים בקיוביט בודד. שערים בקיוביט בודד אינם מושלמים, כך שיכולים להיות מקרים שבהם גם התייחסות לעומק בקיוביט בודד מועילה. אבל עומק השערים בשני קיוביטים נוטה לשלוט בהתנהגות השגיאה של מעגל. עלינו להתייחס למעגל לאחר transpilation. מחשבים קוונטיים מודרניים אינם בעלי קישוריות מלאה בין כל הקיוביטים (all-to-all). מחשבים קוונטיים של IBM משתמשים ברשת ריבועית או ברשת "heavy hex", כלומר לקיוביטים יש 2, 3 או 4 שכנים קרובים שאליהם ניתן להיות מצומדים ישירות באמצעות שער בודד בשני קיוביטים. כל שזירה עם קיוביטים אחרים, לא סמוכים, מחייבת הזזת מידע על פני המחשב הקוונטי באמצעות שערי SWAP בשני קיוביטים. לכן, transpilation נוטה להגדיל את העומק של שערים בשני קיוביטים. עבור מעגלים בעלי שזירה גבוהה, הגדלה זו יכולה להיות גדולה מאוד.

קווי אור מוצללים

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

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

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

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

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

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

אם שגיאה במטרה מתחלפת (commutes) עם צימוד ה-ZZ, אז היא לא יכולה להתפשט לקיוביט הבקרה. אפשר לראות זאת דרך המנגנונים הפיזיקליים בפעולה. דרך מהירה לראות זאת היא שאם שגיאה $E$ מתחלפת עם $ZZ$, אז ניתן להחליף את הסדר ביניהן בלי להשפיע על התוצאה. עם זאת, אם ההתרחשות של $E$ ממש לפני צימוד $ZZ$ זהה לפעולתה אחרי צימוד $ZZ$, אז היא לא יכולה להשפיע על הבקרה, מכיוון שבמקרה האחרון, השגיאה הייתה צריכה לנוע אחורה בזמן. אם שגיאה לא מתחלפת עם צימוד ה-ZZ, אז ייתכן שהיא אכן תתפשט מהמטרה בחזרה לבקרה. לכן, במקרה של שער ECR, שגיאות Z לא יכולות להתפשט מהמטרה לבקרה, אבל שגיאות X או Y יכולות.

בדקו את ההבנה שלכם

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

תשובה

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

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

תשובה

(א) קיוביט 3 יכול להיות מושפע, וכמובן גם קיוביט 2 עצמו. אף אחד אחר! אם רשמתם את קיוביטים 0 ו-1, שימו לב שקיוביט 2 הוא המטרה של ה-ECR ששוזר אותו עם קיוביט 1. לא נעשה שינוי בקיוביט 1 באותו שער. (ב) קיוביטים 0-3 יכולים להיות מושפעים. שגיאת היפוך הביט, או שגיאה מסוג X, אינה מתחלפת עם צימוד ה-ZZ בשער ה-ECR, ולכן יכולה להתפשט מהמטרה לבקרה.

התפשטות שגיאות

בפרק הקודם דנו בהתפשטות שגיאות מבלי לתת לה הגדרה פורמלית. מכאן ואילך:

עבור שגיאה $E$ שמתרחשת לפני חלק כלשהו מהמטען הלוגי של מעגל $U$, התפשטות שגיאה פירושה מציאת האופרטור השקול $E'$ שמשחזר את אותה תוצאה שגויה כאשר הוא מיושם אחרי $U$ במקום לפניו.

$$\boxed{ \text{An error } E \text{ propagates through a unitary } U \text{ as } E' = U E U^\dagger }$$ $$\boxed{ U\,E\,|\psi\rangle = E'\,U\,|\psi\rangle }$$

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

נניח שהבקרה היא קיוביט 0 והמטרה היא קיוביט 1. נתייחס לשגיאות X ו-Z על קיוביטי הבקרה והמטרה ($X_c$, $Z_c$, $X_t$, ו-$Z_t$, בהתאמה). העברת השגיאות הללו מעבר ל-$\text{CNOT}_{0\to1}$ גורמת לשגיאות להפוך ל:

$$\begin{aligned} X_c &\to X_c X_t\\ Z_c &\to Z_c\\ X_t &\to X_t\\ Z_t &\to Z_c Z_t \end{aligned}$$

אנחנו מציגים את הנ"ל ללא הוכחה. אבל אם אתם כמו מחבר השיעור הזה, ומעדיפים את תמונת שרדינגר (Schr"odinger picture), אתם יכולים גם לכתוב מצבי בקרה ומטרה שרירותיים, להפעיל את השגיאה, אז את ה-CNOT, ולבחון את המצב הסופי. אם תשוו את המצב הסופי הזה למקרה נטול שגיאות, תוכלו לראות איזה שילוב שגיאה שמיושם אחרי ה-CNOT יניב את המצב השגוי, ובפרט, תוכלו לראות אם פעולת השגיאה התפשטה מקיוביט אחד לשני.

בקרה ראשוני	מטרה ראשוני	שגיאה	סופי	שקילות שגיאה לאחר CNOT
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	ללא	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle +\beta\delta \vert 01\rangle$	לא רלוונטי
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X על הבקרה	$\alpha\gamma \vert 11\rangle+\alpha\delta \vert 01\rangle + \beta\gamma \vert 10\rangle +\beta\delta \vert 00\rangle$	$X_c X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z על הבקרה	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle - \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X על המטרה	$\alpha\gamma \vert 10\rangle+\alpha\delta \vert 00\rangle + \beta\gamma \vert 01\rangle +\beta\delta \vert 11\rangle$	$X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z על המטרה	$\alpha\gamma \vert 00\rangle-\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c Z_t$

אולי באופן מפתיע, שגיאת Z על המטרה כן גורמת לשגיאה שמתפשטת בחזרה לבקרה!

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

יש addon של Qiskit שנקרא Shaded Lightcones. ה-addon של קווי אור מוצללים (SLC) מנתח התפשטות שגיאות במעגלים קוונטיים באמצעות שימוש בהתפשטות פאולי (Pauli propagation) כדי לזהות אילו חלקים במעגל יכולים למעשה להשפיע על אובזרבל מטרה. הוא מיועד בעיקר להפוך את הפחתת השגיאות ליעילה יותר, במיוחד עבור תהליכי עבודה של ביטול שגיאות הסתברותי (PEC). נחקור כאן את הכלי הזה רק בקצרה, ונעשה בו שימוש נרחב יותר בהקשר של טכניקות הפחתת שגיאות בשיעורים עתידיים. הוא משתמש בהתפשטות אופרטורי פאולי כדי למפות את ההתפשטות של סוגי שגיאות שונים, ומייצר קו אור עבור שגיאות מסוג X, Y ו-Z.

חרוטי אור מוצללים (SLC) הולכים צעד נוסף, ומשתמשים בסימולציות קלאסיות כדי לתחום בצורה הדוקה יותר את הרגישות לשגיאות לאורך כל המעגל. גישה זו ממירה חלק מזמן ה-QPU בזמן CPU ומצמצמת את התקורה הנדרשת לדגימה לצורך נרמול ההטיה מחדש. במקום סף חד, לכל שגיאה פוטנציאלית במעגל מוקצה “גוון” מדורג התוחם מלמעלה את רגישות האובזרבל (observable) לאותה שגיאה. אפיון מעודן זה מאפשר יישומים יעילים וממוקדים יותר של PEC עם שונות מופחתת, ומעניק למשתמש את היכולת לכוונן בצורה מבוקרת את ההטיה באמידת האובזרבל. לפרטים נוספים ראו Lightcone shading for classically accelerated quantum error mitigation.

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

זרימת העבודה מפרידה את המעגל ל"תיבות" השימושיות ללמידת התנהגות הרעש:

לבסוף, היא משתמשת בהפצת אופרטורים ובלמידת רעש כדי להפיק מפת הצללה של רגישות לשגיאות לאורך המעגל:

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

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

בדקו את הבנתכם

האם לדעתכם עדיף להכין מפת אור-קונוס מוצללת לפני או אחרי הטרנספילציה? מדוע?

תשובה

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