קוד שור ב-9 Qubit

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

תיאור הקוד

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

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

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

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

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[4mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

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

תיקון שגיאות היפוך ביט ופאזה

שגיאות ו-CNOT Gate

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

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

המצב דומה עבור $Z$ Gate, אלא שתפקידי ה-Qubit הבקרה והיעד מתחלפים. בפרט, שלושת היחסים מתוארים על ידי ה-Circuit הקוונטיים הבאים.

תיקון שגיאות היפוך ביט

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

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

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

תיקון שגיאות היפוך פאזה

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

נניח שמתרחשת שגיאת $Z$ על אחד מ-9 ה-Qubit של קוד שור, כמו זה המצוין בדיאגרמה הבאה.

כבר ראינו מה קורה כשמתרחשת שגיאת $Z$ בעת שימוש בקוד החזרה של 3 ביטים — זה שקול לשגיאת $Z$ שמתרחשת לפני הקידוד. בהקשר של קוד שור ב-9 Qubit, כלומר שגיאת $Z$ על כל אחד משלושת ה-Qubit בתוך בלוק תמיד מייצרת את אותה השפעה, השקולה לשגיאת $Z$ המתרחשת על ה-Qubit המתאים לפני שהקוד הפנימי מוחל.

לדוגמה, דיאגרמת ה-Circuit שלמעלה שקולה לדיאגרמה הבאה. ניתן להסביר זאת בעזרת היחסים בין $Z$ ו-CNOT Gate שתוארו לעיל, או פשוט על ידי הערכת ה-Circuit על מצב Qubit שרירותי $\vert\psi\rangle.$

זה מציע אפשרות אחת לגילוי ותיקון שגיאות $Z$: לפענח את הקוד הפנימי, מה שישאיר אותנו עם שלושת ה-Qubit המשמשים לקידוד החיצוני יחד עם שישה Qubit מאוחסנים מאותחלים. לאחר מכן נוכל לבדוק את שלושת ה-Qubit הללו של הקוד החיצוני לאיתור שגיאות $Z$, ואז לקדד מחדש באמצעות הקוד הפנימי, כדי לחזור לקידוד ב-9 Qubit של קוד שור. אם נגלה שגיאת $Z$, נוכל לתקן אותה לפני הקידוד מחדש עם הקוד הפנימי, או לאחר הקידוד מחדש, על ידי החלת $Z$ Gate על כל אחד מה-Qubit של אותו בלוק.

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

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

יתרון אחד של תיקון שגיאות $Z$ לאחר שלב הקידוד מחדש, ולא לפניו, הוא שנוכל לפשט את ה-Circuit שלמעלה. ה-Circuit הבא שקול, אך דורש ארבעה CNOT Gate פחות.

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

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

שגיאות היפוך ביט ופאזה בו-זמנית

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

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

כדי להבין מדוע, שקלו את הדוגמה המתוארת בדיאגרמת ה-Circuit הבאה, שבה הן שגיאת $X$ והן שגיאת $Z$ השפיעו על ה-Qubit התחתון של הבלוק האמצעי.

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

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

מכאן נובע שה-Circuit הבא שקול לזה שלמעלה עד לגורם פאזה גלובלי של $-1.$

עכשיו אפשר להזיז את שגיאת ה-$Z$ בדיוק כמו קודם כדי לקבל Circuit שקול נוסף.

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

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

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

הפחתת שגיאות עבור שגיאות אקראיות

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

כדי להיות יותר קונקרטיים, נבחן מודל רעש פשוט שבו שגיאות מתרחשות באופן עצמאי על ה-Qubit, כשכל Qubit חווה שגיאה בהסתברות $p$, וללא קורלציה בין שגיאות על Qubit שונים — בדומה לערוץ סימטרי בינארי עבור ביטים קלאסיים. יכולנו להקצות הסתברויות שונות לשגיאות $X,$ $Y,$ ו-$Z$ להתרחש, אבל כדי לשמור על פשטות מרבית, נבחן את תרחיש הגרוע ביותר עבור קוד שור ב-9 Qubit: שגיאת $Y$ מתרחשת על כל אחד מה-Qubit המושפעים. שגיאת $Y$, אגב, שקולה (עד לגורם פאזה גלובלי לא רלוונטי) לשגיאות $X$ וגם $Z$ המתרחשות על אותו Qubit, כיוון ש-$Y = iXZ.$ זה מסביר את ההתעלמות לכאורה שלנו משגיאות $Y$ עד כה.

כעת, נניח ש-$\mathsf{Q}$ הוא Qubit במצב מסוים שאנחנו רוצים להגן עליו מפני שגיאות, ונשקול את האפשרות להשתמש בקוד שור ב-9 Qubit. שאלה טבעית לשאול היא: "האם כדאי לנו להשתמש בו?"

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

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

לכן, הקוד מגן על $\mathsf{Q}$ כל עוד לכל היותר אחד מתשעת ה-Qubit מושפע על ידי שגיאה, מה שקורה בהסתברות

$$(1-p)^9 + 9 p (1-p)^8.$$

אחרת, בהסתברות

$$1 - (1-p)^9 - 9 p (1-p)^8,$$

הקוד נכשל בהגנה על $\mathsf{Q}.$

ספציפית, מה שזה אומר בהקשר הזה הוא שפעולת פאולי שאינה זהות תוחל על ה-Qubit שלנו $\mathsf{Q}$ (כ-Qubit לוגי), עד לפאזה גלובלית. כלומר, אם שגיאות $X$ ו-$Z$ מתגלות ומתוקנות עבור קוד שור כפי שתואר קודם בשיעור, נישאר עם הקידוד של מצב השקול, עד לפאזה גלובלית, לקידוד של פעולת פאולי שאינה זהות המוחלת על המצב המקורי של $\mathsf{Q}.$ דרך תמציתית יותר לומר זאת היא שהתרחשה שגיאה לוגית. ייתכן שיהיה לזה השפעה על המצב המקורי של $\mathsf{Q}$ — או במילים אחרות ה-Qubit הלוגי שקידדנו עם תשעה Qubit פיזיים — ולא, אך לצורך ניתוח זה, אנחנו מחשיבים אירוע זה ככישלון.

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

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

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

אם $p$ קטן מנקודת האיזון הזו, הקוד מועיל; בנקודת האיזון ההסתברויות שוות, כך שאנחנו פשוט מבזבזים זמן יחד עם 8 Qubit אם אנחנו משתמשים בקוד; ומעבר לנקודת האיזון בהחלט אסור להשתמש בקוד זה מכיוון שהוא מגדיל את הסיכוי לשגיאה לוגית על $\mathsf{Q}.$

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