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

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

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

נקודת המוצא לדיון טכני בנושא זה היא ההכרה שגיטים דו-Qubit (או גיטים מרובי-Qubit בצורה כללית יותר) יכולים להפיץ שגיאות, גם כשהם פועלים בצורה מושלמת. לדוגמה, נשקול Gate מסוג controlled-NOT, ונניח שמתרחשת שגיאת $X$ על ה-Qubit השולט ממש לפני ביצוע ה-controlled-NOT. כפי שכבר ראינו בשיעור "תיקון שגיאות קוונטיות", זה שקול לשגיאת $X$ המתרחשת על שני ה-Qubits אחרי ביצוע ה-controlled-NOT. והמצב דומה לשגיאת $Z$ הפועלת על ה-target ולא על ה-control לפני ביצוע ה-controlled-NOT.

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

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

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

מימוש גיטים טרנסברסלי

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

דוגמאות למימוש גיטים טרנסברסלי

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

יש שני בלוקי קוד בתמונה זו, כל אחד מוצג כמורכב מחמישה Qubits (אם כי יכולים להיות יותר, כפי שכבר נרמז). המעגל בצד ימין בעומק אחד, וכל אחד מגיטי ה-CNOT פועל על מיקום Qubit יחיד בתוך כל בלוק: גם ה-control וגם ה-target עבור ה-CNOT הראשון הם ה-Qubit העליון ביותר (כלומר, Qubit 0 לפי מוסכמת המספור של Qiskit), גם ה-control וגם ה-target עבור ה-CNOT השני הם ה-Qubit השני מלמעלה (כלומר, Qubit 1), וכן הלאה. לכן, זהו גאדג'ט טרנסברסלי.

לדוגמה שנייה — שהיא למעשה מחלקה של דוגמאות — נשקול כל Gate מסוג Pauli. גיטי Pauli תמיד ניתן לממש בצורה טרנסברסלית, עבור כל קוד stabilizer, על ידי בניית גאדג'טים המורכבים מפעולות Pauli. בפרט, כל פעולת Pauli על Qubit לוגי המקודד על ידי קוד stabilizer ניתן לממש בצורה טרנסברסלית על ידי בחירת פעולת Pauli מתאימה על ה-Qubits הפיזיים המשמשים לקידוד. זה עקבי עם עובדה שהוזכרה דרך אגב בשיעור "פורמליזם ה-Stabilizer": עד כדי פאזה גלובלית, פעולות Pauli שמתחלפות עם כל גנרטור stabilizer של קוד stabilizer פועלות כמו פעולות Pauli על ה-Qubit או ה-Qubits המקודדים על ידי אותו קוד.

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

$$\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) \\[3mm] \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}$$

Gate מסוג $X$ על ה-Qubit הלוגי המקודד על ידי קוד זה ניתן לממש בצורה טרנסברסלית על ידי פעולת Pauli בת $9$ Qubits

$$Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I}$$

בעוד ש-Gate מסוג $Z$ על ה-Qubit הלוגי ניתן לממש בצורה טרנסברסלית על ידי פעולת Pauli בת $9$ Qubits

$$X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}.$$

לשתי פעולות Pauli אלה יש משקל $3,$ שהוא המשקל המינימלי הנדרש. (לקוד Shor בן $9$ ה-Qubits יש מרחק $3,$ לכן כל פעולת Pauli שאינה זהות ובמשקל $2$ או פחות מזוהה כשגיאה.)

ולדוגמה שלישית, קוד Steane בן $7$ ה-Qubits (ואכן כל קוד צבע) מאפשר מימוש טרנסברסלי של כל גיטי Clifford. כבר ראינו כיצד מממשים גיטי CNOT בצורה טרנסברסלית עבור כל קוד CSS, ולכן נותר לשקול גיטי $H$ ו-$S$. Gate מסוג Hadamard המוחל על כל $7$ ה-Qubits של קוד Steane שקול ל-$H$ המוחל על ה-Qubit הלוגי שהוא מקודד, בעוד ש-Gate מסוג $S^{\dagger}$ (בניגוד ל-Gate מסוג $S$) המוחל על כל $7$ ה-Qubits שקול ל-Gate $S$ לוגי.

התפשטות שגיאות עבור גאדג'טים טרנסברסליים

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

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

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

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

אי-אוניברסליות של גיטים טרנסברסליים

עבור שני קודי stabilizer שונים, ייתכן ש-Gate מסוים ניתן לממש בצורה טרנסברסלית עם קוד אחד אבל לא עם השני. לדוגמה, אמנם לא ניתן לממש Gate מסוג $T$ בצורה טרנסברסלית באמצעות קוד Steane בן $7$ ה-Qubits, יש קודים אחרים שעבורם זה אפשרי.

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

משפט

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

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

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

מצבי Magic

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

מימוש גיטים עם מצבי magic

נתחיל בבחינת גיטי $S$ ו-$T$, שיש להם תיאורי מטריצה כדלקמן.

$$S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/2} \end{pmatrix} \qquad\text{and}\qquad T = \begin{pmatrix} 1 & 0\\ 0 & \frac{1+i}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix}$$

בהגדרה, $S$ הוא פעולת Clifford, בעוד ש-$T$ אינה; לא ניתן לממש Gate מסוג $T$ עם מעגל המורכב מגיטי Clifford (גיטי $H$, גיטי $S$, וגיטי CNOT).

אולם, ניתן לממש Gate מסוג $T$ (עד כדי פאזה גלובלית) עם מעגל המורכב מגיטי Clifford אם, בנוסף, יש לנו עותק של המצב

$$T\vert {+} \rangle = \frac{1}{\sqrt{2}} \vert 0 \rangle + \frac{e^{i\pi/4}}{\sqrt{2}} \vert 1\rangle,$$

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

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

$$T \vert {+} \rangle \otimes \vert\psi\rangle \stackrel{\text{CNOT}}{\longmapsto} \frac{1}{\sqrt{2}} \vert 0\rangle \otimes T \vert \psi\rangle + \frac{1+i}{2} \vert 1\rangle \otimes T^{\dagger} \vert \psi\rangle$$

לכן המדידה נותנת את התוצאות $0$ ו-$1$ בהסתברות שווה. אם התוצאה היא $0,$ ה-Gate מסוג $S$ אינו מבוצע, ומצב הפלט הוא $T\vert\psi\rangle;$ ו- אם התוצאה היא $1,$ ה-Gate מסוג $S$ מבוצע, ומצב הפלט הוא $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

המצב $T\vert {+}\rangle$ נקרא מצב magic בהקשר זה, אם כי הוא אינו ייחודי בהקשר זה: מצבים אחרים נקראים גם הם מצבי magic כאשר ניתן להשתמש בהם בדרך דומה (עבור גיטים שונים ייתכן ובמעגלים שונים). לדוגמה, החלפת המצב $T\vert{+}\rangle$ במצב $S\vert{+}\rangle$ והחלפת ה-Gate מסוג $S$ במעגל לעיל ב-Gate מסוג $Z$ מממשת Gate מסוג $S$ — שעשוי להיות שימושי לחישוב קוונטי עמיד לתקלות באמצעות קוד שעבורו לא ניתן לממש גיטי $S$ בצורה טרנסברסלית.

גאדג'טים עמידים לתקלות ממצבי magic

ייתכן שלא ברור שהשימוש במצבי magic לממש גיטים מועיל לעמידות לתקלות. עבור מימוש Gate מסוג $T$ שתואר לעיל, לדוגמה, נראה שעדיין עלינו להחיל Gate מסוג $T$ על מצב $\vert{+}\rangle$ כדי לקבל מצב magic, שאותו אנחנו משתמשים כדי לממש Gate מסוג $T$. אז מה היתרון בשימוש בגישה זו לעמידות לתקלות?

הנה שלוש נקודות מפתח שמספקות תשובה לשאלה זו.

1. יצירת מצבי magic אינה מחייבת החלת ה-Gate שאנחנו מנסים לממש על מצב מסוים. לדוגמה, החלת Gate מסוג $T$ על מצב $\vert {+} \rangle$ אינה הדרך היחידה לקבל מצב $T\vert{+}\rangle$.

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

3. אם הגיטים הבודדים במעגל המממש Gate נבחר באמצעות מצב magic יכולים להיות מיושמים בצורה עמידה לתקלות, ואנחנו מניחים את הזמינות של מצבי magic, אנחנו מקבלים מימוש עמיד לתקלות של ה-Gate הנבחר.

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

Qubits במעגל $T$ המקורי מתאימים ל-Qubits לוגיים בדיאגרמה זו, המקודדים על ידי כל קוד שאנחנו משתמשים בו לעמידות לתקלות. הקלטים והפלטים בדיאגרמה צריכים לכן להיות מובנים כקידודים של מצבים אלה. משמעות הדבר היא, בפרט, שלמעשה אנחנו לא צריכים רק מצבי magic — אנחנו צריכים מצבי magic מקודדים. הגיטים במעגל $T$ המקורי מוחלפים כאן בגאדג'טים, שאנחנו מניחים שהם עמידים לתקלות.

תמונה ספציפית זו מרמזת לכן שכבר יש לנו גאדג'טים עמידים לתקלות עבור גיטי CNOT וגיטי $S$. עבור קוד צבע, גאדג'טים אלה יכולים להיות טרנסברסליים; עבור קוד surface (או כל קוד CSS אחר), ניתן לבצע את ה-CNOT בצורה טרנסברסלית, בעוד שגאדג'ט ה-Gate מסוג $S$ עצמו עשוי להיות מיושם באמצעות מצבי magic, כפי שהוצע קודם שאפשרי. (התמונה גם מרמזת שיש לנו גאדג'ט עמיד לתקלות לביצוע מדידה בבסיס סטנדרטי, שהתעלמנו ממנו עד כה. זה יכול להיות מאתגר עבור קודים מסוימים שנבחרו כך שיהיה, אבל עבור קוד CSS מדובר במדידת כל Qubit פיזי ואחריה עיבוד קלאסי.)

המימוש הוא לכן עמיד לתקלות, בהנחה שיש לנו קידוד של מצב magic $T\vert{+}\rangle.$ אבל עדיין לא התמודדנו עם הסוגיה של כיצד אנחנו מקבלים קידוד של מצב זה. דרך אחת לקבל מצבי magic מקודדים (או, אולי ביתר דיוק, לשפר אותם) היא דרך תהליך הידוע כזיקוק מצבי magic. הדיאגרמה הבאה ממחישה כיצד תהליך זה נראה ברמה הגבוהה ביותר.

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

ישנן דרכים ידועות שונות לבנות את המזקק עצמו, אבל הן לא יוסברו או ינותחו כאן. ברמה לוגית, הגישה הטיפוסית — באופן מרשים ומקרי במקצת — היא להריץ מעגל קידוד עבור קוד stabilizer בהפוך! זה יכול, למעשה, להיות קוד stabilizer שונה מזה המשמש לתיקון שגיאות. לדוגמה, ניתן לשקול שימוש בקוד surface או קוד צבע לתיקון שגיאות, אבל להריץ מקודד עבור קוד ה-$5$ Qubits בהפוך לצורך זיקוק מצבי magic. מעגלי קידוד עבור קודי stabilizer דורשים רק גיטי Clifford, מה שמפשט את המימוש העמיד לתקלות של מזקק. בפועל, הפרטים תלויים בקודים המשמשים.

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

תיקון שגיאות עמיד לתקלות

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

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

שיטה אחת ידועה כתיקון שגיאות Shor, כי היא התגלתה לראשונה על ידי Peter Shor. הרעיון הוא לבצע מדידות סינדרום באמצעות מה שנקרא מצב חתול, שהוא מצב $n$-Qubit בצורה

$$\frac{1}{\sqrt{2}} \vert 0^n \rangle + \frac{1}{\sqrt{2}} \vert 1^n \rangle,$$

כאשר $0^n$ ו-$1^n$ מתייחסים למחרוזות האפס-כולה והאחד-כולה באורך $n.$ לדוגמה, זהו מצב $\vert\phi^+\rangle$ כאשר $n=2$ ומצב GHZ כאשר $n=3,$ אבל באופן כללי, תיקון שגיאות Shor דורש מצב כזה עבור $n$ שהוא המשקל של גנרטור ה-stabilizer הנמדד.

כדוגמה, המעגל המוצג כאן מודד גנרטור stabilizer בצורה $P_2\otimes P_1 \otimes P_0.$

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

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

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