קוד הטורוס

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

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

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

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

תיאור קוד הטורוס

יהי $L\geq 2$ מספר שלם חיובי, ונשקול סריג $L\times L$ עם מה שנקרא גבולות מחזוריים. לדוגמה, הצורה הבאה מתארת סריג $L\times L$ עבור $L=9.$

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

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

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

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

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

שימו לב שה-Qubits המוצבים על הקווים המקווקווים אינם מלאים מכיוון שהם כבר מיוצגים בקווים הימניים ועליוניים ביותר בסריג. בסך הכל יש $2L^2$ Qubits: $L^2$ Qubits על קווים אופקיים ו-$L^2$ Qubits על קווים אנכיים.

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

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

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

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

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

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

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

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

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

נשארים $L^2 - 1$ מחוללי סטביליזטור מכל סוג, או $2L^2 - 2$ בסך הכל, בקבוצה מחוללת מינימלית (היפותטית). מכיוון שיש $2L^2$ Qubits בסך הכל, פירוש הדבר שקוד הטורוס מקדד $2L^2 - 2 (L^2 - 1) = 2$ Qubits.

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

גילוי שגיאות

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

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

הדיאגרמה הבאה מתארת את ההשפעה של שגיאת $X$ על Qubit יחיד. כאן, ההנחה היא שה-$2L^2$ Qubits שלנו היו לפני כן במצב הכלול במרחב הקוד של קוד הטורוס, מה שגרם לכל מדידות מחוללי הסטביליזטור לתת פלט $+1.$ מחוללי הסטביליזטור $Z$ מגלים שגיאות $X$, ויש מחולל אחד כזה לכל משבצת בצורה, כך שנוכל לציין את תוצאת המדידה של מחולל הסטביליזטור המתאים בצבע אותה משבצת: תוצאות $+1$ מסומנות במשבצות לבנות ותוצאות $-1$ מסומנות במשבצות אפורות. אם מתרחשת שגיאת היפוך ביט על אחד מה-Qubits, ההשפעה היא שמדידות מחוללי הסטביליזטור המתאימות לשתי המשבצות הגובלות ב-Qubit המושפע עכשיו מניבות פלט $-1.$

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

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

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

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

עם זאת, ייתכן ששרשרת של שגיאות $X$ סמוכות לא תהיה בעלת קצות, כלומר שרשרת השגיאות עשויה ליצור לולאה סגורה, כמו בצורה הבאה.

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

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

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

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

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

דוגמה ללולאה סגורה של שגיאות $X$ בקטגוריה השנייה מוצגת בדיאגרמה הבאה.

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

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

מכיוון שקוד הטורוס משתמש ב-$2L^2$ Qubits כדי לקדד $2$ Qubits ובעל מרחק $L$, הוא קוד סטביליזטור $[[2L^2,2,L]]$.

תיקון שגיאות

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

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

לדוגמה, נשקול את הדיאגרמה הבאה, המתארת סינדרום עם שתי תוצאות $-1$, המסומנות במשבצות אפורות, הנגרמות על ידי שרשרת של שגיאות $X$ המומחשת על ידי הקו והעיגולים המג'נטה. כפי שכבר ציינו, השרשרת עצמה אינה נחשפת על ידי הסינדרום; רק הקצות גלויים.

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

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

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

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

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

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