סימולציה של הטבע

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

שיעור זה משתמש בתוכן מהמדריך הבא:

מדריך להפחתת שגיאות בקנה מידה utility עם הגברת שגיאה הסתברותית

מבוא

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

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

ריצ'רד פיינמן נשא הרצאה רבת השפעה בקלטק ב-1959. הכותרת המפורסמת שלה הייתה "There's Plenty of Room at the Bottom," ברמז שובב לאפשרויות הרחבות שטרם נחקרו בסקלה המיקרוסקופית. פיינמן טען שחלק גדול מהפיזיקה ברמה האטומית ותת-האטומית טרם התגלה.

החשיבות של ההרצאה גדלה בשנות ה-80 עם התקדמות הטכנולוגיה. בתקופה זו, פיינמן חזר לרעיונות אלו בהרצאה חשובה נוספת בקלטק, שבה הציג מאמר בשם "Simulating Nature with Computers." שם הוא שאל שאלה נועזת: האם ניתן להשתמש במחשבים לביצוע סימולציות מדויקות שמשחזרות את התנהגות הטבע ברמה הקוונטית? פיינמן הציע שבמקום להסתמך על קירובים גסים לדגום תהליכים אטומיים, נוכל להשתמש במחשבים שמנצלים את חוקי מכניקת הקוואנטים עצמם — לא רק לדגם את הטבע, אלא לחקות אותו.

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

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

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

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

תהליך עבודה כללי

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

1. זיהוי ההמילטוניאן של המערכת
2. קידוד המילטוניאן
3. הכנת המצב
4. אבולוציה בזמן של המצב
5. אופטימיזציה של Circuit
6. הרצת Circuit
7. עיבוד לאחר

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

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

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

1. זיהוי ההמילטוניאן של המערכת

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

$$H=\sum_i^N {H_i}$$

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

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

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

$$H = \sum_i^N {H_i} = J \sum_{<i,j>}Z_iZ_j + h\sum_{i=0}^N X_i$$

כאשר האיבר הראשון מייצג את אנרגיית האינטראקציה בין ספינים שכנים. כאן $<i,j>$ מציין שאנו סוכמים על כל זוגות הספינים המחוברים ישירות על הסריג, $Z_i$ ו-$Z_j$ הם מטריצות פאולי-Z המייצגות את מצב הספינים באתר $i$ ו-$j$, ו-$J$ הוא קבוע הצימוד, המגדיר את עוצמת האינטראקציה. האיבר השני מייצג את השפעת שדה מגנטי חיצוני המופעל על פני המערכת כולה. כאן $X_i$ הוא מטריצת פאולי-X הפועלת על הספין הבודד באתר $i$, ו-$h$ מציין את עוצמת השדה החיצוני הזה.

2. קידוד המילטוניאן

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

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

בעת סימולציה של חלקיקים לא ניתנים להבחנה של פרמיונים או בוזונים, נדרש להחיל טרנספורמציית קידוד. חלקיקים אלה משמשים לתיאור במסגרת מתמטית מיוחדת הנקראת second quantization, המעקבת אחרי מספר האוכלוסייה של כל מצב קוונטי על ידי הכנסת אופרטורי creation ו-annihilation, כאשר אופרטור היצירה $\hat{a}_i^\dagger$ מוסיף חלקיק אחד למצב $i$ בעוד אופרטור ההשמדה $\hat{a}_i$ מסיר חלקיק אחד ממצב $i$. בהתבסס על מסגרת הקוואנטיזציה השנייה הזו, הפרמיון ניתן לטרנספורמציה על ידי Bravyi-Kitaev ו-Jordan-Wigner. טרנספורמציית Jordan-Wigner מגדירה את אופרטור היצירה הפרמיוני $\hat{f}_j^\dagger = \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j + i Y_j}{2} \Bigr)$ שממלא את המצב הקוונטי ה-$j$ בפרמיון ואת אופרטור ההשמדה הפרמיוני $\hat{f}_j= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j - i Y_j}{2} \Bigr)$ שמרוקן פרמיון מהמצבים ה-$j$. ניתן למצוא פרטים נוספים על טרנספורמציית Jordan-Wigner זו בQuantum Computing in Practice, פרק 5 - Mapping. באופן דומה, גם בוזונים דורשים שיטות קידוד משלהם, כמו טרנספורמציית Holstein-Primakoff, כדי להיות מיוצגים על ידי קיוביטים.

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

3. הכנת המצב

לאחר קידוד ההמילטוניאן הרצוי לתוך מערכת ה-Gate של המחשב הקוונטי, השלב החשוב הבא הוא לבחור מצב קוונטי התחלתי מתאים להתחלת הסימולציה. בחירת המצב ההתחלתי משפיעה לא רק על ההתכנסות של אלגוריתמים וריאציוניים כמו Variational Quantum Eigensolver‏ (VQE) אלא גם על הדיוק והיעילות של אבולוציית הזמן ודגימה. בעיקרו של דבר, המצב ההתחלתי משמש כנקודת ההתחלה לחישוב, ומניח את הבסיס לחילוץ ערכים נצפים שימושיים מהמערכת הקוונטית המדוגמת. באופן אידיאלי, מצב זה צריך לייצג תצורה פיזיקלית משמעותית של המערכת הנחקרת.

עבור סימולציות רבות בכימיה קוונטית, מצב Hartree-Fock יכול להיות נקודת פתיחה טובה. בשפת הקוואנטיזציה השנייה, מצב Hartree-Fock ($|\phi\rangle_{HF}$) נוצר על ידי החלת אופרטורי יצירה ($\hat{a}_i^\dagger$) עבור כל אחד מהאורביטלים בעלי האנרגיה הנמוכה ביותר על מצב הריק($|vac\rangle = |0_1 ... 0_k ... 0_N\rangle = |0\rangle ^{\otimes N}$), מצב ללא אלקטרונים.

$$|\phi\rangle_{HF} = \prod\limits_{i=1}^k \hat{a}_i^\dagger |0\rangle ^{\otimes N} = \hat{a}_1^\dagger ... \hat{a}_k^\dagger |0_1 ... 0_k ... 0_N\rangle$$

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

באופן כללי יותר, נוכל לכתוב מצב שרירותי של $n$ קיוביטים כסופרפוזיציה של מצבי בסיס חישובי $∣c_i\rangle$ עם מקדמים $a_i$, המקיימים תנאי נרמול. הכנת מצב כזה ניתנת לגישה כללית על ידי החלת אופרטור ספציפי $\hat{O}$ על המצב ההתחלתי, שהוא בדרך כלל מצב הבסיס הסטנדרטי האפס לפי מוסכמה.

$$|\psi\rangle = \sum_{i=0}^{2^n-1}{a_i |c_i\rangle}=\hat{O}|0\rangle^{\otimes n}\\ \text{with} \qquad \sum_{i=0}^{2^n-1}{|a_i^2|}=1$$

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

עכשיו כשהמצב ההתחלתי הוגדר, נוכל לבסוף להתחיל את הסימולציה עצמה — לבחון כיצד המצב $|\phi(t=0)\rangle$ של המערכת השתנה ל-$|\phi(t)\rangle$ לאחר זמן $t$. במכניקת הקוואנטים, אבולוציה זו מתוארת על ידי פעולה מתמטית יחידה הנקראת אופרטור האבולוציה בזמן:

$$U(t) = e^{-iHt}$$

כאשר קבענו $\hbar=1$ לפי מוסכמה. החלת אופרטור זה על המצב ההתחלתי שלנו נותנת לנו את המצב הסופי: $|\phi(t)\rangle = e^{-iHt}|\phi(t=0)\rangle$

אולם, בניית Circuit קוונטי שמממש ישירות את האופרטור המלא $e^{-iHt}$ היא בדרך כלל בלתי אפשרית כאשר ההמילטוניאן שלנו הוא סכום של חלקים שונים. לכן, אנחנו זקוקים ל-Trotterization.

במונחים פשוטים, Trotterization היא טכניקה לקירוב הנחלת מטריצה (כאן ההמילטוניאן, $H$), במיוחד כאשר החזקה מכילה אופרטורים שאינם מתחלפים ($[H_A, H_B] \neq 0$). לעיתים קרובות ההמילטוניאן $H$ מורכב ממספר אופרטורים שאינם מתחלפים. במקרה זה, אינכם יכולים להפריד את האקספוננטים שלהם:

$$e^{-i(H_A + H_B)t} \neq e^{-iH_A t}e^{-iH_B t}$$

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

$$e^{−i H t}\approx \left(e^{−i H_A t/n}e^{−i H_B t/n}\right)^n$$

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

$$\begin{aligned} \text{First order:} & \qquad e^{-iHt}\approx \left(\prod_j{e^{-iH_i t/n}}\right)^n\\ \text{Second order:} & \qquad e^{-iHt}\approx \left(\prod_{j=1}^N{e^{-iH_j t/2n}}\right)^n\left(\prod_{k=N}^1{e^{-iH_k t/2n}}\right)^n \end{aligned}$$

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

ראו את חלק Trotterization בקורס Quantum Diagonalization Algorithms לפרטים נוספים. 5. אופטימיזציה של Circuit

לאחר יצירת Circuit ה-Trotterized, שלב המיפוי הושלם ואנו יכולים להמשיך לאופטימיזציה של Circuit. תהליך זה כולל מספר משימות מרכזיות:

• הגדרת פריסת קיוביט שממפה את הקיוביטים האבסטרקטיים של Circuit לקיוביטים הפיזיים על החומרה. שלב זה נדרש מכיוון שלארכיטקטורת החומרה לעיתים קרובות יש אילוצי קישוריות ספציפיים, בעוד שעיצובי Circuit קוונטיים בדרך כלל מניחים שכל קיוביט יכול לתקשר עם כל אחר.
• הכנסת Gate-ים מסוג swap לפי הצורך כדי לאפשר אינטראקציות בין קיוביטים שאינם מחוברים ישירות על המכשיר.
• תרגום ה-Gate-ים של Circuit להוראות ISA (Instruction Set Architecture) שהחומרה יכולה לבצע ישירות.
• ביצוע אופטימיזציות Circuit כדי להפחית את עומק Circuit ואת מספר ה-Gate-ים. ניתן להחיל אופטימיזציה זו גם מוקדם יותר, על Circuit הוירטואלי לפני שהקיוביטים הוקצו לחיבורי חומרה ספציפיים.

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

6. הרצת Circuit

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

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

7. עיבוד לאחר

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

שחזור מאמר ה-"Utility"

הערה

חלק זה הוא סקירה ברמה גבוהה של המדריך Utility-scale error mitigation with probabilistic error amplification, השוחזר את תוצאות מאמר Evidence for the Utility of Quantum Computing Before Fault Tolerance. אנחנו ממליצים בחום לפתוח את המדריך המוזכר לצד שיעור זה.

כעת נבחן דוגמה קונקרטית ממאמר רב השפעה שפרסמה IBM ב-2023, שכותרתו Evidence for the Utility of Quantum Computing Before Fault Tolerance, המכונה לעיתים קרובות "מאמר ה-Utility".

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

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

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

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

מאחר שסדרה זו נושאת את השם Quantum Computing in Practice, נכסה פרטים נוספים של הטכניקות הניסויות המשמשות לשיפור איכות התוצאות. אחת הנהלים החשובים כוללת זיהוי והסרת קיוביטים "רעים" — אלה עם נאמנות Gate נמוכה או זמני decoherence קצרים — שעשויים להשפיע משמעותית על תוצאת הניסוי. קיוביטים בעייתיים כאלה עשויים להיווצר עקב כיול גרוע או אינטראקציות עם מערכות דו-רמה (TLS). הסרת קיוביטים אלה משנה את הטופולוגיה המקורית של החומרה, ומשנה למעשה את הסריג שעליו הסימולציה מבוצעת.

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

שלב 1 בדפוסי Qiskit: מיפוי

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

• יוצר Circuit של מודל איזינג עם פרמטרים
• יוצר שכבות מסבכות ומסיר קיוביטים רעים
• מייצר גרסה Trotterized של Circuit

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

• הסרת צימודי קיוביט
• הגדרת צימודי קיוביט
• בניית צימודי שכבה
• בניית שכבה מסבכת
• הגדרת Circuit Trotterized

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

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

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

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

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

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

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

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

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

from qiskit.circuit import Parameter

num_steps = 6           #Trotter steps
theta = Parameter("theta")
circuit = trotter_circuit(
        theta, layer_couplings, num_steps, qubits = good_qubits, backend = backend
)
num_params = 12

# 12 parameter values for Rx between [0,p/2].
#Reshape to outer product broadcast with observables

parameter_values = np.linespace(0,np.pi/2,num_params).reshape((num_params,1))
num_params = parameter_values.size

שלב 2 בדפוסי Qiskit: אופטימיזציה

כעת שיצרנו את Circuit שלנו, השלב הבא הוא לבצע עליו אופטימיזציה. החלק הראשון של תהליך זה כולל הגדרת pass manager. בהקשר של Qiskit SDK, Transpilation הוא תהליך של שינוי Circuit קלט לצורה המתאימה לביצוע על מכשיר קוונטי. שינוי זה מתרחש דרך רצף של שלבים הידועים כ-transpiler passes. pass manager הוא אובייקט המחזיק רשימה של transpiler passes אלה ויכול להחיל אותם על Circuit. כדי ליצור אחד, אתם מאתחלים PassManager עם רשימת transpiler passes הרצויה. בסופו של דבר, pass manager מייצר Circuit ISA — Circuit המבוטא במונחים של ה-Instruction Set Architecture‏ (ISA) של ה-Backend. משמעות הדבר היא שה-Circuit מיוצג תוך שימוש ב-Gate-ים מקוריים לחומרת ה-Backend, אם כי הוא עדיין אינו כולל את מידע התזמון הנדרש להרצת ה-Circuit על המכשיר.

שלב 3 בדפוסי Qiskit: ביצוע באמצעות primitives

כעת הגיע הזמן להריץ את Circuit שלנו. נשתמש ב-Estimator ככלי העיקרי שלנו לניסוי זה מכיוון שמטרתנו היא למדוד את המגנטיזציה הכוללת של המערכת. ה-Estimator תוכנן במיוחד להעריך ערכי ציפיה של ערכים נצפים, מה שהופך אותו לבחירה האידיאלית כאן. בשלב זה, חיוני גם להגדיר את הגדרות הפחתת השגיאות שלנו. נחיל Zero Noise Extrapolation‏ (ZNE) כדי לשפר את דיוק התוצאות שלנו. במדריך, תראו שאנו מציינים שני ערכי גורם רעש או יותר שבהם להעריך את המודלים המוחצנים, ואנו בוחרים "Probabilistic Error Amplification"‏ (PEA) כשיטת הגברה שלנו. PEA עדיפה לניסוי זה מכיוון שהיא מתרחבת בצורה משמעותית טובה יותר מאשר אפשרויות אחרות, שחיוני בעבודה עם מערכות של 100 קיוביטים ויותר.

זה כל מה שנדרש להרצת הניסוי.

הפסקת ביניים להפחתת שגיאות

לפני שנמשיך לעיבוד לאחר, בואו נקח רגע קצר להבהיר מה הכוונה ב-Zero Noise Extrapolation‏ (ZNE). נגענו במושג זה בפרקים קודמים, אך כדאי לסקור אותו בקצרה. ZNE היא טכניקת הפחתת שגיאות שנועדה להפחית את השפעת הרעש הלא ידוע המתרחש במהלך ביצוע Circuit-ים קוונטיים, בתנאי שניתן לשנות את קנה מידה של רעש זה בצורה מבוקרת. השיטה מתבססת על ההנחה שערכי ציפיה משנים קנה מידה עם רעש בהתאם לפונקציה ידועה:

$$\langle A(\lambda)\rangle = \langle A(0)\rangle + \sum_{k=0}^m {a_k \lambda^k}+R,$$

כאשר $λ$ מייצג את עוצמת הרעש, שניתן להגביר בכוונה.

תהליך יישום ZNE מורכב מהשלבים הבאים:

1. הגברת רעש Circuit עבור גורמי רעש שונים $λ_1$, $λ_2$, … .
2. הרצת כל Circuit מוגבר רעש כדי למדוד את ערכי הציפיה המתאימים $\langle A(\lambda_1)\rangle$, $\langle A(\lambda_2)\rangle$, ….
3. חצינה של תוצאות אלה בחזרה לגבול האפס-רעש \langle $A(\lambda_0)\rangle$.

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

האתגר העיקרי ביישום ZNE ביעילות הוא פיתוח מודל רעש מדויק לערך הציפיה והגברת הרעש בצורה מבוקרת ומובנת היטב. טכניקות נפוצות להגברת שגיאות ב-ZNE כוללות שינוי קנה מידה של משך פולסים באמצעות כיול, חזרה על Gate-ים תוך שימוש במחזורי זהות, והוספת רעש דרך ערוצי Pauli לדגימה — שיטה המכונה Probabilistic Error Amplification‏ (PEA).

מבין אלה, PEA היא לעיתים קרובות הבחירה המועדפת מכמה סיבות:

• מתיחת פולסים כרוכה בעלות חישובית גבוהה.
• קיפול Gate, המשתמש בהכנסות זהות, חסרת ערבויות תיאורטיות חזקות לשימור הטיית הרעש.
• PEA ישימה לכל Circuit המורץ עם גורם רעש מקורי, אם כי היא דורשת ללמוד את מודל הרעש מראש.

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

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

שלב 4 בדפוסי Qiskit: עיבוד לאחר

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

סיכום

לסיכום קצר של מה שלמדנו:

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

סקר לאחר הקורס

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

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.