1ממה ניתן לחשב למה ניתן לחשב ביעילות: המודל, המשאבים והמחלקות הבסיסיות

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

ביטחון: high2 הקלטות4 עמודי סיכוםturing-machinestime-and-spacemultitape-simulationuniversal-machineconfigurationsdtime-dspace

עמודי הסיכום בכתב יד

פתיחת עמוד 1 בגודל מלא

סיבוכיות שיעור 1.pdf

עמוד 1 מתוך 4 בסיכום הכתב יד

בקצרה

  • הקורס הזה הוא המשך ישיר של חישוביות. שם שאלנו מה ניתן לחשב; כאן נשאל מה ניתן לחשב ביעילות — כלומר אנחנו עושים zoom-in לתוך המחלקה RR של הבעיות הכריעות ומחלקים גם אותה.
  • "יעילות" איננה מושג אבסולוטי כמו "ניתן לחשב". צריך לומר יעיל במה — זמן, מקום, רוחב פס, ביטים אקראיים, דיוק — ולכן כל הגדרה בקורס תיאמר תמיד ביחס למשאב מסוים ולאורך הקלט.
  • סרגל המדידה הוא מכונת טיורינג. המשאבים הבסיסיים הם timeM(x)time_M(x) (מספר הפעלות פונקציית המעברים) ו-spaceM(x)space_M(x) (מספר התאים השונים שהמכונה כותבת בהם).
  • מעברים בין מודלים עולים כסף, ואנחנו סופרים אותו: סימולציה של מכונה kk-סרטית על ידי מכונה חד-סרטית עולה O(time⋅space)O(time\cdot space) בזמן ואפס בסדר גודל במקום; המכונה האוניברסלית עולה פקטור של ∣⟨M⟩∣|\langle M\rangle| בזמן ופקטור lg⁡∣ΓM∣\lg|\Gamma_M| במקום.
  • הקשר בין זמן למקום אינו סימטרי: תמיד spaceM(x)≤timeM(x)space_M(x)\le time_M(x), אבל בכיוון ההפוך אין חסם כלל — אלא אם יודעים שהמכונה עוצרת, ואז timeM(x)≤2cM⋅spaceM(x)time_M(x)\le 2^{c_M\cdot space_M(x)} בעזרת ספירת קונפיגורציות.
  • מכאן נגזרות שתי המחלקות הבסיסיות DTime(f)DTime(f) ו-DSpace(f)DSpace(f) ושתי ההכלות DTime(f)⊆DSpace(f)DTime(f)\subseteq DSpace(f) ו-DSpace(f)⊆DTime(2O(f))DSpace(f)\subseteq DTime\left(2^{O(f)}\right). אלה הלבנים שמהן ייבנה כל הקורס.

רקע ותלויות

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

1. מכונת טיורינג ופונקציית המעברים. מכונה היא אוסף סופי של מצבים, א"ב קלט/פלט, א"ב עבודה ופונקציית מעברים δ\delta שרואה את המצב הנוכחי ואת התו שהראש הקורא־כותב עומד עליו, ומחליטה למה מצב לעבור, איזה תו לכתוב, ולאן להזיז את הראש. המצב הוא, כדברי המרצה, "כמו שורת קוד". הסרט אינו חסום מאף כיוון.

2. הווריאנט הרב-סרטי ומשפט השקילות. לכל kk קבוע מראש (לפני הקלט!) מוגדרת מכונה kk-סרטית. משפט השקילות מחישוביות: לכל מכונה רב-סרטית MM קיימת מכונה חד-סרטית M^\hat{M} מעל אותו א"ב קלט/פלט, כך שלכל x∈ΣM∗x\in\Sigma_M^* מתקיים M^(x)=M(x)\hat{M}(x)=M(x). בחישוביות זה הספיק; בסיבוכיות נוסיף לזה מימד — כמה זה עולה.

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

4. המחלקות מחישוביות. RE\mathrm{RE} — השפות שניתן לזהות; coREcoRE — המשלימות שלהן; RR — השפות שניתן להכריע. בחישוביות RR הייתה "הבעיות הקלות", מפני שלא שאלנו כלל כמה משאבים ההכרעה דורשת. כל הקורס הזה מתרחש בתוך RR.

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

6. סדר הכמתים. בסיבוכיות זה קריטי פי עשרה מאשר בחישוביות. כשכותבים "לכל MM קיים cc כך שלכל xx", הקבוע cc מותר שיהיה תלוי ב-MM ואסור שיהיה תלוי ב-xx — פשוט מפני ש-xx מופיע אחריו.

הגדרות

הגדרה 1: מכונת טיורינג (חד-סרטית)

מכונת טיורינג היא

M=(Q,qstart,F,Σ,Γ,δ),M=(Q,q_{start},F,\Sigma,\Gamma,\delta),

כאשר QQ קבוצת מצבים סופית, qstart∈Qq_{start}\in Q המצב ההתחלתי, F⊆QF\subseteq Q קבוצת המצבים הסופיים, Σ\Sigma א"ב הקלט והפלט, Γ⊇Σ\Gamma\supseteq\Sigma א"ב העבודה, ופונקציית המעברים

δ:Q×Γ⟶Q×Γ×{L,R}.\delta:Q\times\Gamma\longrightarrow Q\times\Gamma\times\{L,R\}.

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

על FF. במכונת חישוב מסתפקים במצב סופי אחד, qHq_H; במכונת הכרעה בשניים בלבד, qaccq_{acc} ו-qrejq_{rej}, והפלט נקבע לפי המצב שבו נעצרה הריצה. לכן בהרבה מקומות (וגם בסיכום) פשוט מוותרים על FF כרכיב נפרד בהגדרה. קונבנציה של הקורס [00:46:21]: אם לא נאמר אחרת במפורש, "מכונת טיורינג" פירושו מכונה סטנדרטית — חד-סרטית, וכל המדדים נמדדים ביחס אליה.

הגדרה 2: מכונת טיורינג kk-סרטית

לכל k∈Nk\in\mathbb{N} הנקבע מראש, לפני הקלט, מכונה kk-סרטית מוגדרת בדיוק כמו הגדרה 1 פרט לפונקציית המעברים:

δ:Q×Γk⟶Q×Γk×{L,R}k.\delta:Q\times\Gamma^{k}\longrightarrow Q\times\Gamma^{k}\times\{L,R\}^{k}.

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

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

הגדרה 3: מדדי הזמן והמקום

בהינתן מכונה MM וקלט x∈ΣM∗x\in\Sigma_M^*:

  • timeM(x)time_M(x) — מספר ההפעלות של פונקציית המעברים בריצת MM על xx.
  • spaceM(x)space_M(x) — מספר התאים השונים שבהם MM כותבת במהלך ריצתה על xx.

אינטואיציה והבחנות עדינות. אין דבר כזה "מספר הצעדים של מכונה"; יש רק מספר צעדים של מכונה על קלט מסוים. אם המכונה כתבה חמש פעמים באותו תא, זה נספר חמש פעמים בזמן ופעם אחת במקום. שימו לב גם למה לא נספר במקום: תאים שהקלט ההתחלתי יושב בהם והמכונה לא כתבה בהם, אינם נספרים [01:05:20]. מכאן שאם MM מקבלת מיד את xx בלי לקרוא אותו — timeM(x)time_M(x) ו-spaceM(x)space_M(x) הם 11 בלבד, גם אם xx ארוך.

מוסכמה נוספת [00:19:10]: מדדי היעילות נמדדים תמיד כפונקציה של אורך הקלט ∣x∣|x|, ואנחנו מתעניינים בסדרי גודל, לא בספירה מדויקת.

הגדרה 4: המכונה האוניברסלית MUM_U

MUM_U היא המכונה שהא"ב שלה בינרי, המקיימת: לכל מכונה MM ולכל x∈ΣM∗x\in\Sigma_M^*,

MU(⟨M,x⟩)=⟨M(x)⟩.M_U(\langle M,x\rangle)=\langle M(x)\rangle .

אינטואיציה. MUM_U יודעת לקבל מכונה מבחוץ ולהריץ אותה. שימו לב שהיא מחזירה את הקידוד של הפלט ולא את הפלט עצמו — ולזה יש סיבה מדויקת. שאלה של סטודנטים [00:35:22]: למה לא להחזיר את הפלט? התשובה: MUM_U היא מכונה אחת קבועה עם א"ב קבוע (בינרי), והיא צריכה לעבוד עבור מכונות בעלות א"ב שרירותי; אין לה שום דרך לכתוב תו מא"ב שהיא רואה בפעם הראשונה. במכונת הכרעה ההערה מתייתרת: שם MUM_U פשוט מקבלת אם MM מקבלת ודוחה אם MM דוחה.

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

הגדרה 5: קונפיגורציה

בהינתן מכונה MM ומחרוזת x∈ΣM∗x\in\Sigma_M^*, קונפיגורציה בריצת MM על xx מורכבת משלושה רכיבים:

  1. המצב הנוכחי;
  2. תוכן הסרט;
  3. מיקום הראש הקורא־כותב.

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

דוגמה לגבול ההגדרה (שאלת סטודנטית, [01:23:52]): למה לא די בתו הנוכחי? כי ייתכן שבהמשך הריצה הראש יזוז עשרה תאים ימינה, ואם אין לך את תוכן כל הסרט לא תדעי מה מחכה שם. זה בדיוק כמו להעביר מישהו באמצע ריצה של תוכנית ב-C: לא די בערכי המשתנים של השורה הנוכחית.

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

הגדרה 6: המחלקות DTimeDTime ו-DSpaceDSpace

לכל פונקציה f:N→Nf:\mathbb{N}\to\mathbb{N}:

DTime(f)={A⊆Σ∗ ∣ ∃M decider for A, ∃c>0, ∀x: timeM(x)≤c⋅f(∣x∣)},DTime(f)=\Big\{A\subseteq\Sigma^*\ \Big|\ \exists M \text{ decider for } A,\ \exists c>0,\ \forall x:\ time_M(x)\le c\cdot f(|x|)\Big\}, DSpace(f)={A⊆Σ∗ ∣ ∃M decider for A, ∃c>0, ∀x: spaceM(x)≤c⋅f(∣x∣)}.DSpace(f)=\Big\{A\subseteq\Sigma^*\ \Big|\ \exists M \text{ decider for } A,\ \exists c>0,\ \forall x:\ space_M(x)\le c\cdot f(|x|)\Big\}.

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

סדר הכמתים — נקודת הכישלון הקלאסית [01:22:31]: הקבוע cc נבחר אחרי המכונה ולפני הקלט. מותר לו להיות תלוי ב-MM ובפונקציה, ואסור לו להיות תלוי ב-xx. כשכתוב O(f)O(f) בהקשר של מדדי סיבוכיות — זו בדיוק המשמעות.

Abuse of notation [01:20:25]: כותבים DTime(n2)DTime(n^2) אף שפורמלית צריך להגדיר את הפונקציה f(n)=n2f(n)=n^2 ואז לכתוב DTime(f)DTime(f). זו הכתיבה המקובלת.

מקרה גבול. אפשר לדבר על f(n)=⌈lg⁡n⌉f(n)=\lceil\lg n\rceil, אבל אז המכונה אפילו לא מספיקה לקרוא את כל הקלט; במכונה דטרמיניסטית שאמורה להכריע נכונה זה נדיר, ויופיע בעיקר בהקשרים מקורבים או הסתברותיים.

משפטים והוכחות

משפט 1: מחיר המעבר ממכונה רב-סרטית למכונה חד-סרטית

לכל מכונה רב-סרטית MM קיימת מכונה חד-סרטית M^\hat{M} מעל אותו א"ב קלט/פלט, כך ש:

  1. הסמנטיקות של MM ושל M^\hat{M} שוות — הן מחשבות בדיוק אותו דבר;
  2. לכל x∈ΣM∗x\in\Sigma_M^* מתקיים
timeM^(x) ≤ 4⋅timeM(x)⋅(spaceM(x)+2) ≤ O(timeM(x)⋅spaceM(x)),time_{\hat{M}}(x)\ \le\ 4\cdot time_M(x)\cdot\big(space_M(x)+2\big)\ \le\ O\big(time_M(x)\cdot space_M(x)\big), spaceM^(x) ≤ O(spaceM(x)).space_{\hat{M}}(x)\ \le\ O\big(space_M(x)\big).

הוכחה (הרעיון והחשבון במלואו).

הבנייה. מגדילים את א"ב העבודה כך שכל תא בסרט היחיד של M^\hat{M} יחזיק kk-ייה של תווים — תו אחד עבור כל אחד מ-kk סרטי MM — ובנוסף סימון של מיקומי kk הראשים. כך כל "פרוסה אנכית" של kk הסרטים של MM מיוצגת בתא אחד של M^\hat{M}.

הסימולציה של צעד בודד. כדי לסמלץ צעד אחד של MM, המכונה M^\hat{M} חייבת קודם כול לדעת מה kk הראשים קוראים; אך מיקומי הראשים מפוזרים לאורך הסרט, ולכן היא צריכה לסרוק את כל התוכן. אחרי שאספה את kk התווים היא מפעילה את δ\delta במצב הפנימי שלה, וסורקת שוב כדי לכתוב את kk התווים החדשים ולהזיז את kk סימוני הראשים. בסך הכול נדרשים ארבעה סוויפים על כל התוכן עבור כל צעד של MM [00:29:52].

החשבון. אורך התוכן שיש לסרוק חסום על ידי הטווח שהראשים ביקרו בו, כלומר על ידי spaceM(x)space_M(x); ה-+2+2 הוא בגלל חריגה של תא אחד לכל צד. לכן כל צעד של MM עולה ל-M^\hat{M} לכל היותר 4⋅(spaceM(x)+2)4\cdot(space_M(x)+2) צעדים, ומכיוון ש-MM מבצעת timeM(x)time_M(x) צעדים, סך הכול 4⋅timeM(x)⋅(spaceM(x)+2)4\cdot time_M(x)\cdot(space_M(x)+2).

המקום. M^\hat{M} כותבת בדיוק על אותו טווח תאים שבו השתמשה MM (עד כדי חריגה של תא-שניים), אלא שכל תא "שמן" יותר. השומן הזה נבלע בגודל א"ב העבודה — כלומר בקבוע שאינו תלוי בקלט — ולכן מבחינת מספר התאים מדובר באותו סדר גודל: O(spaceM(x))O(space_M(x)).

הערה: בהרצאה זה נאמר בקיצור — המרצה הפנה לסרטוני האנימציה מקורס חישוביות ואמר מפורשות שההוכחה שם היא "יותר רעיון מהוכחה פורמלית" [00:31:27]. הפירוט לעיל הוא מה שהיד-מנופפת עומדת מאחוריו.

מה חשוב לקרוא נכון בטענה (שאלה מצוינת של סטודנטית, [00:27:12]). האי-שוויון timeM^≤O(timeM⋅spaceM)time_{\hat{M}}\le O(time_M\cdot space_M) אינו אומר ש-M^\hat{M} מהירה יותר. הוא אומר שהיא לא גרועה בהרבה מדי — הכפל ב-spaceMspace_M יכול להיות משמעותי ביותר. הדוגמה: שפת הפלינדרומים נכרעת בזמן ליניארי במכונה דו-סרטית ובזמן ריבועי במכונה חד-סרטית. כלומר המודל הרב-סרטי אינו מחזק אותנו מבחינה חישובית, אבל כן מחזק אותנו מבחינת יעילות.

מסקנה 1.1. מכיוון ש-spaceM(x)≤timeM(x)space_M(x)\le time_M(x) (משפט 3 להלן), נובע גם

timeM^(x)≤O(timeM(x)2),time_{\hat{M}}(x)\le O\big(time_M(x)^2\big),

כלומר הפער בזמן במעבר לחד-סרטית הוא לכל היותר ריבועי.

משפט 2: יעילות המכונה האוניברסלית הרב-סרטית

תהי MM מכונה ויהי x∈ΣM∗x\in\Sigma_M^*. אז

timeMU(⟨M,x⟩)=O(∣⟨M,x⟩∣+∣⟨M⟩∣⋅timeM(x)) ≤ O(∣⟨M⟩∣⋅timeM(x)),time_{M_U}(\langle M,x\rangle)=O\Big(|\langle M,x\rangle|+|\langle M\rangle|\cdot time_M(x)\Big)\ \le\ O\Big(|\langle M\rangle|\cdot time_M(x)\Big), spaceMU(⟨M,x⟩)≤O(∣⟨M,x⟩∣+lg⁡∣ΓM∣⋅spaceM(x)) ≤ O(lg⁡∣ΓM∣⋅spaceM(x)),space_{M_U}(\langle M,x\rangle)\le O\Big(|\langle M,x\rangle|+\lg|\Gamma_M|\cdot space_M(x)\Big)\ \le\ O\Big(\lg|\Gamma_M|\cdot space_M(x)\Big),

כאשר האי-שוויון הימני בכל שורה תקף כאשר MM קוראת את כל הקלט שלה, וכל הקבועים המוסתרים אינם תלויים לא ב-MM ולא ב-xx.

הוכחה — חשבון מפורש של הסימולציה.

שלב האתחול. MUM_U מעתיקה את ⟨M⟩\langle M\rangle לסרט המכונה, את ⟨x⟩\langle x\rangle לסרט העבודה, את ⟨qstart⟩\langle q_{start}\rangle לסרט המצב, וכותבת סדרת אפסים באורך ⌈lg⁡∣ΓM∣⌉+1\lceil\lg|\Gamma_M|\rceil+1 בסרט אורך התו. כל זה דורש מעבר אחד על הקלט, כלומר O(∣⟨M,x⟩∣)O(|\langle M,x\rangle|) צעדים ו-O(∣⟨M,x⟩∣)O(|\langle M,x\rangle|) תאים.

למה בכלל צריך את סרט אורך התו? [00:41:12] בסרט העבודה לא כתוב xx אלא הקידוד הבינרי של xx. כדי לקרוא תו בודד, MUM_U חייבת לדעת כמה ביטים מרכיבים קידוד של תו אחד; סדרת האפסים משמשת כמונה לאורך זה. (השם "סרט אורך תו" הוא קיצור; מדובר באורך קידוד התו.)

הסימולציה. על כל צעד ש-MM הייתה עושה בריצתה על xx, MUM_U קוראת את התו הנוכחי מסרט העבודה ואת המצב מסרט המצב, ואז סורקת את כל טבלת δ\delta הכתובה בסרט המכונה כדי למצוא את המעבר המתאים. במקרה הגרוע היא עוברת על כל הטבלה, כלומר על O(∣⟨M⟩∣)O(|\langle M\rangle|) תאים. אם MM עוצרת — MUM_U עוצרת.

חשבון הזמן. אתחול פלוס timeM(x)time_M(x) צעדים, שלכל אחד תקורה של ∣⟨M⟩∣|\langle M\rangle|:

O(∣⟨M,x⟩∣)+timeM(x)⋅O(∣⟨M⟩∣).O\big(|\langle M,x\rangle|\big)+time_M(x)\cdot O\big(|\langle M\rangle|\big).

מדוע הביטוי השמאלי בדרך כלל נבלע? אם MM קוראת את כל הקלט שלה אז timeM(x)≥∣x∣time_M(x)\ge|x|, ולכן ∣⟨M⟩∣⋅timeM(x) ≥ ∣⟨M⟩∣+∣⟨x⟩∣|\langle M\rangle|\cdot time_M(x)\ \ge\ |\langle M\rangle|+|\langle x\rangle| עד כדי קבוע. חשוב: זה לא תמיד נכון — אצל מכונה שאינה קוראת את כל הקלט הביטוי הראשון עשוי לשלוט. המרצה תיקן את עצמו מפורשות ואמר שהמילה "זניח" כבדה מדי, ושהניסוח הנכון הוא "קטן לעומת השני" [00:45:00].

מדוע ∣⟨M⟩∣|\langle M\rangle| אינו נבלע ב-OO? [00:42:52] מפני ש-MM היא חלק מהקלט של MUM_U. קבוע מותר שיהיה תלוי במכונה שמריצים — כאן המכונה שמריצים היא MUM_U, ואילו MM משתנה. לכן אסור להסתיר את ∣⟨M⟩∣|\langle M\rangle|.

חשבון המקום. MUM_U נוגעת באותו מספר תאים כמו MM, אבל היא כותבת בביטים: לכל תו מא"ב ΓM\Gamma_M דרושים ⌈lg⁡∣ΓM∣⌉\lceil\lg|\Gamma_M|\rceil ביטים (כדי לקודד את כל המספרים מ-11 עד ∣ΓM∣|\Gamma_M|). מכאן lg⁡∣ΓM∣⋅spaceM(x)\lg|\Gamma_M|\cdot space_M(x), ובתוספת האתחול מתקבל החסם המבוקש. הערך השלם העליון נבלע בסימון OO. שימו לב שכאן, בניגוד לזמן, לא באמת הרווחנו — פשוט בלענו את אורך הקלט בתוך המקום.

מסקנה 2.1: מכונה אוניברסלית חד-סרטית

קיימת מכונה אוניברסלית חד-סרטית M^U\hat{M}_U כך שלכל MM ולכל x∈ΣM∗x\in\Sigma_M^*:

timeM^U(⟨M,x⟩)≤O((∣⟨M,x⟩∣+∣⟨M⟩∣⋅timeM(x))⋅(∣⟨M,x⟩∣+lg⁡∣ΓM∣⋅spaceM(x))),time_{\hat{M}_U}(\langle M,x\rangle)\le O\Big(\big(|\langle M,x\rangle|+|\langle M\rangle|\cdot time_M(x)\big)\cdot\big(|\langle M,x\rangle|+\lg|\Gamma_M|\cdot space_M(x)\big)\Big),

ובחסם הגס יותר

timeM^U(⟨M,x⟩)≤O(∣⟨M⟩∣⋅timeM(x)⋅lg⁡∣ΓM∣⋅spaceM(x)),time_{\hat{M}_U}(\langle M,x\rangle)\le O\Big(|\langle M\rangle|\cdot time_M(x)\cdot\lg|\Gamma_M|\cdot space_M(x)\Big), spaceM^U(⟨M,x⟩)≤O(∣⟨M,x⟩∣+lg⁡∣ΓM∣⋅spaceM(x)).space_{\hat{M}_U}(\langle M,x\rangle)\le O\Big(|\langle M,x\rangle|+\lg|\Gamma_M|\cdot space_M(x)\Big).

הוכחה. הרכבה של שני המשפטים הקודמים. MUM_U מומשה כמכונה רב-סרטית; לפי משפט 1, מכונה חד-סרטית שקולה לה רצה בזמן O(time⋅space)O(time\cdot space) של הרב-סרטית ובאותו סדר גודל של מקום. מציבים את timeMUtime_{M_U} ואת spaceMUspace_{M_U} ממשפט 2 ומקבלים בדיוק את הביטויים לעיל. ■\blacksquare

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

משפט 3: המקום חסום על ידי הזמן

תהי MM מכונה ויהי x∈ΣM∗x\in\Sigma_M^*. אז

spaceM(x)≤timeM(x).space_M(x)\le time_M(x).

הוכחה (מלאה). נסמן n=timeM(x)n=time_M(x), ונסמן ב-AA את קבוצת התאים שהמכונה כותבת בהם בריצתה על xx. לפי הגדרה 3, ∣A∣=spaceM(x)|A|=space_M(x), ובבירור ∣{1,2,…,n}∣=n=timeM(x)|\{1,2,\ldots,n\}|=n=time_M(x). מדובר, אם כן, באי-שוויון בין גדלים של שתי קבוצות; וכפי שהודגש בהרצאה [01:01:39], מאחורי כל אי-שוויון בין גדלים מסתתרת פונקציה חד-חד-ערכית.

נגדיר φ:A→{1,2,…,n}\varphi:A\to\{1,2,\ldots,n\} כך: לכל תא t∈At\in A, נגדיר φ(t)\varphi(t) להיות הצעד הראשון שבו MM כתבה ב-tt.

φ\varphi מוגדרת היטב: אם t∈At\in A אז לפי הגדרת AA קיים צעד שבו המכונה כתבה ב-tt; קבוצת הצעדים האלה אינה ריקה וסופית, ולכן יש לה מינימום.

φ\varphi חד-חד-ערכית: בכל צעד המכונה כותבת בתא אחד בדיוק. לכן אם φ(t1)=φ(t2)=j\varphi(t_1)=\varphi(t_2)=j, אזי בצעד jj נכתב גם ב-t1t_1 וגם ב-t2t_2, ומכאן t1=t2t_1=t_2.

קיום פונקציה חד-חד-ערכית מ-AA אל {1,…,n}\{1,\ldots,n\} גורר ∣A∣≤n|A|\le n, כלומר spaceM(x)≤timeM(x)space_M(x)\le time_M(x). ■\blacksquare

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

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

משפט 4: בכיוון ההפוך אין חסם כלל

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

הוכחה (נגד-דוגמה). נגדיר מכונה MM שעל כל קלט רצה לנצח, כאשר הראש הקורא־כותב זז ימינה ושמאלה על אותם שני תאים ללא הפסקה. אז לכל xx מתקיים spaceM(x)=2space_M(x)=2 בעוד timeM(x)=∞time_M(x)=\infty. אף פונקציה gg לא תקיים ∞≤g(2)\infty\le g(2). ■\blacksquare

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

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

תהי MM מכונת טיורינג. אז קיים קבוע cM>0c_M>0 כך שלכל x∈ΣM∗x\in\Sigma_M^*: אם MM עוצרת על xx אז

timeM(x)≤2 cM⋅spaceM(x).time_M(x)\le 2^{\,c_M\cdot space_M(x)} .

בכתיב מקוצר: timeM(x)≤2O(spaceM(x))time_M(x)\le 2^{O(space_M(x))}.

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

הוכחה.

שלב א' — אם המכונה עוצרת, היא לא מבקרת פעמיים באותה קונפיגורציה. המכונה דטרמיניסטית: ברגע שידוע המצב, תוכן הסרט ומיקום הראש — הצעד הבא נקבע ביחידות. נניח בשלילה ש-MM בריצתה על xx הגיעה לקונפיגורציה CC בצעד ii ושוב לאותה CC בצעד j>ij>i. הקונפיגורציה קובעת את כל ההמשך (ההיסטוריה אינה חלק ממנה, וגם למכונה אין אמצעי לזכור אותה), ולכן מצעד jj ואילך תחזור בדיוק אותה סדרת צעדים, ובצעד j+(j−i)j+(j-i) נגיע שוב ל-CC — וכן הלאה עד אינסוף. מכאן ש-MM לא תעצור, בסתירה. לכן:

אם MM עוצרת על xx, אז MM עוברת בכל קונפיגורציה לכל היותר פעם אחת.

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

timeM(x) ≤ #{configurations of M on x}.time_M(x)\ \le\ \#\{\text{configurations of } M \text{ on } x\}.

שלב ג' — ספירת הקונפיגורציות. קונפיגורציה מורכבת משלושה רכיבים בלתי תלויים:

  • מצב: ∣Q∣|Q| אפשרויות.
  • תוכן הסרט: אמנם הסרט אינסופי, אך התאים שמחוצה לטווח הריצה נשארים ריקים לנצח. בטווח יש spaceM(x)space_M(x) תאים, ולכל תא ∣Γ∣|\Gamma| אפשרויות בלתי תלויות — מחרוזת באורך ss מעל א"ב בגודל gg נותנת gsg^{s} אפשרויות. סך הכול ∣Γ∣spaceM(x)|\Gamma|^{space_M(x)}.
  • מיקום הראש: הראש אינו יכול לחרוג מהטווח שנכתב בו (בכל צעד הוא כותב), ולכן spaceM(x)space_M(x) אפשרויות.

לכן

timeM(x) ≤ ∣Q∣⋅∣Γ∣spaceM(x)⋅spaceM(x).time_M(x)\ \le\ |Q|\cdot|\Gamma|^{space_M(x)}\cdot space_M(x).

שלב ד' — האלגברה: העברה לבסיס 22. נסמן s=spaceM(x)s=space_M(x). נשתמש בזהות a=2lg⁡aa=2^{\lg a} ובכלל ab=2 blg⁡aa^{b}=2^{\,b\lg a}:

∣Q∣⋅∣Γ∣s⋅s  =  2lg⁡∣Q∣⋅2 s⋅lg⁡∣Γ∣⋅2lg⁡s  =  2 lg⁡∣Q∣+s⋅lg⁡∣Γ∣+lg⁡s.|Q|\cdot|\Gamma|^{s}\cdot s \;=\; 2^{\lg|Q|}\cdot 2^{\,s\cdot\lg|\Gamma|}\cdot 2^{\lg s} \;=\; 2^{\,\lg|Q|+s\cdot\lg|\Gamma|+\lg s}.

נוציא את ss כגורם משותף בחזקה:

=  2(lg⁡∣Q∣s+lg⁡∣Γ∣+lg⁡ss)⋅s.=\;2^{\left(\frac{\lg|Q|}{s}+\lg|\Gamma|+\frac{\lg s}{s}\right)\cdot s}.

כעת נחסום מלמעלה. אם s≥1s\ge 1 אז lg⁡∣Q∣s≤lg⁡∣Q∣\frac{\lg|Q|}{s}\le\lg|Q|, וכן lg⁡ss≤1\frac{\lg s}{s}\le 1 מפני ש-lg⁡s≤s\lg s\le s לכל s≥1s\ge1. לכן

≤  2(lg⁡∣Q∣+lg⁡∣Γ∣+1)⋅s.\le\;2^{\left(\lg|Q|+\lg|\Gamma|+1\right)\cdot s}.

נגדיר cM=lg⁡∣Q∣+lg⁡∣Γ∣+1c_M=\lg|Q|+\lg|\Gamma|+1 ונקבל בדיוק את הנדרש. ■\blacksquare

הערה — התנאי s≥1s\ge1 מסומן בסיכום באדום. החלוקה ב-ss בשלב ד' אינה חוקית כאשר spaceM(x)=0space_M(x)=0. המקרה הזה מטופל בנפרד וטריוויאלית: spaceM(x)=0space_M(x)=0 פירושו שהמכונה לא כתבה באף תא, כלומר לא ביצעה אף צעד, ואז timeM(x)=0≤1=2cM⋅0time_M(x)=0\le 1=2^{c_M\cdot 0}. בכל מקרה אחר המכונה ביצעה לפחות צעד אחד, ובכל צעד היא כותבת בתא, ולכן spaceM(x)≥1space_M(x)\ge1.

מה חשוב בביטוי שהתקבל. cM=lg⁡∣Q∣+lg⁡∣Γ∣+1c_M=\lg|Q|+\lg|\Gamma|+1 תלוי רק במכונה — במספר המצבים ובגודל א"ב העבודה — ולא בקלט. זו כל הפואנטה. כמו כן החסם אינו הדוק: בשלב ד' העלמנו לתוך המכפלה איברים שיכלו להיות קטנים בהרבה. זה בסדר, מפני שכל מה שרצינו הוא הצורה 2O(space)2^{O(space)}.

משפט 6: DTime(f)⊆DSpace(f)DTime(f)\subseteq DSpace(f)

טענה. לכל f:N→Nf:\mathbb{N}\to\mathbb{N} מתקיים DTime(f)⊆DSpace(f)DTime(f)\subseteq DSpace(f).

הוכחה. תהי ff כלשהי ותהי A∈DTime(f)A\in DTime(f). לפי ההגדרה קיימת מכונה MM וקיים קבוע c>0c>0 כך ש-MM מכריעה את AA ולכל x∈Σ∗x\in\Sigma^* מתקיים timeM(x)≤c⋅f(∣x∣)time_M(x)\le c\cdot f(|x|).

לפי משפט 3, לכל xx מתקיים spaceM(x)≤timeM(x)space_M(x)\le time_M(x). בשרשור:

spaceM(x) ≤ timeM(x) ≤ c⋅f(∣x∣).space_M(x)\ \le\ time_M(x)\ \le\ c\cdot f(|x|).

כלומר אותה מכונה MM עצמה מכריעה את AA ומקיימת את מגבלת המקום עם אותו קבוע cc, שאינו תלוי ב-xx. לפי ההגדרה, A∈DSpace(f)A\in DSpace(f). ■\blacksquare

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

משפט 7: DSpace(f)⊆DTime ⁣(2O(f))DSpace(f)\subseteq DTime\!\left(2^{O(f)}\right)

סימון. הכתיב DTime ⁣(2O(f))DTime\!\left(2^{O(f)}\right) הוא קיצור לאיחוד

DTime ⁣(2O(f))  =  ⋃c=1∞DTime ⁣(2 c⋅f).DTime\!\left(2^{O(f)}\right)\;=\;\bigcup_{c=1}^{\infty} DTime\!\left(2^{\,c\cdot f}\right).

כלומר: קיים איזשהו קבוע cc שאינו תלוי בקלט, שעבורו הבעיה נכרעת בזמן 2c⋅f2^{c\cdot f}. שימו לב שמסתתרים כאן שני קבועים — אחד מתוך ה-OO שבמעריך ואחד מהגדרת DTimeDTime עצמה [01:33:10].

הוכחה. תהי ff כלשהי ותהי A∈DSpace(f)A\in DSpace(f). לפי ההגדרה קיימת מכונה MM וקיים c>0c>0 כך ש-MM מכריעה את AA ולכל xx מתקיים

spaceM(x)≤c⋅f(∣x∣).space_M(x)\le c\cdot f(|x|).

שלב א' — למה MM עוצרת על כל קלט? זו נקודה עדינה שעלתה בכיתה [01:39:00]: חסם על המקום לבדו אינו מבטיח עצירה — ראו משפט 4. אבל כאן נתון יותר מזה: MM מכריעה את AA, ומהגדרת ההכרעה, על קלט בשפה היא עוצרת ומקבלת ועל קלט מחוץ לשפה היא עוצרת ודוחה. לכן לכל xx, MM עוצרת על xx.

שלב ב' — הפעלת משפט 5. מכיוון ש-MM עוצרת על כל קלט, קיים c′>0c'>0 (התלוי ב-MM בלבד) כך שלכל xx

timeM(x)≤2 c′⋅spaceM(x).time_M(x)\le 2^{\,c'\cdot space_M(x)} .

שלב ג' — שרשור. נציב את חסם המקום בתוך המעריך:

timeM(x) ≤ 2 c′⋅spaceM(x) ≤ 2 c′⋅c⋅f(∣x∣).time_M(x)\ \le\ 2^{\,c'\cdot space_M(x)}\ \le\ 2^{\,c'\cdot c\cdot f(|x|)} .

שלב ד' — הגדרת הקבוע. נגדיר d=c′⋅cd=c'\cdot c. גם cc וגם c′c' הם קבועים התלויים במכונה בלבד ואינם תלויים ב-xx, ולכן גם dd כזה. קיבלנו מכונה MM המכריעה את AA, ולכל xx מתקיים timeM(x)≤2 d⋅f(∣x∣)time_M(x)\le 2^{\,d\cdot f(|x|)}. לפי ההגדרה A∈DTime ⁣(2 d⋅f)⊆DTime ⁣(2O(f))A\in DTime\!\left(2^{\,d\cdot f}\right)\subseteq DTime\!\left(2^{O(f)}\right). ■\blacksquare

דוגמאות ותרגילים מהשיעור

דוגמה 1: שפת הפלינדרומים במכונה חד-סרטית — חשבון מלא

נגדיר

PAL={x∈{0,1}∗ : x=xR}.PAL=\{x\in\{0,1\}^*\ :\ x=x^{R}\}.

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

ספירת הצעדים. נסמן n=∣x∣n=|x|. המעבר הראשון משמאל לימין עולה בערך nn צעדים; החזרה עולה בערך n−1n-1; המעבר הבא n−2n-2, וכן הלאה עד לצעד בודד. בסך הכול

n+(n−1)+(n−2)+⋯+1=n(n+1)2=O(n2).n+(n-1)+(n-2)+\cdots+1=\frac{n(n+1)}{2}=O(n^2).

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

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

מסקנה. PAL∈DTime(n2)PAL\in DTime(n^2) וגם PAL∈DSpace(n)PAL\in DSpace(n). ההוכחה היא בדיוק בדיקת ההגדרה: הצגנו מכונה שמכריעה, ולכל xx הזמן שלה O(∣x∣2)O(|x|^2) והמקום שלה O(∣x∣)O(|x|).

דוגמה 2: אותה שפה במכונה דו-סרטית — הרווח בזמן

האלגוריתם. שני הראשים מתחילים בתו השמאלי ביותר.

  1. מעבר אחד משמאל לימין על שני הסרטים במקביל, שבו מעתיקים את כל xx מהסרט הראשון לסרט השני. עלות: nn צעדים.
  2. מחזירים את הראש בסרט הראשון לתו השמאלי ביותר. עלות: nn צעדים.
  3. מעבר מקבילי: הראש בסרט הראשון הולך ימינה, הראש בסרט השני הולך שמאלה (מהסוף להתחלה). בכל צעד משווים את שני התווים; אם אי-פעם הם שונים — דוחים. עלות: nn צעדים.

החשבון. בסך הכול כ-3n3n צעדים, כלומר time=O(n)time=O(n) — ליניארי, לא ריבועי. במקום, לעומת זאת, אנחנו משלמים קצת יותר: בכל צעד כותבים על שני תאים חדשים (אחד בכל סרט), כלומר בערך 2n+12n+1; אבל מאחר ש-k=2k=2 קבוע מראש, זה עדיין O(n)O(n).

התרגיל שנובע מזה. הריצו את משפט 1 על המכונה הזאת: המעבר לחד-סרטית עולה O(time⋅space)=O(n⋅n)=O(n2)O(time\cdot space)=O(n\cdot n)=O(n^2) — וקיבלנו בדיוק את המכונה החד-סרטית מדוגמה 1. זה מדגים ששני החסמים תופרים זה לזה בצורה הדוקה במקרה הזה.

דוגמה 3: המכונה שהמקום שלה 22 והזמן שלה אינסוף

מכונה שכל מה שהיא עושה הוא להזיז את הראש ימינה, שמאלה, ימינה, שמאלה לנצח, ולכתוב בכל צעד באחד משני תאים. space=2space=2, time=∞time=\infty. זו הנגד-דוגמה של משפט 4, והיא גם התשובה לשאלה "האם אי-העצירה היא כל הסיפור?" — התשובה, לפי משפט 5, היא כן: ברגע שמניחים עצירה, כן מתקבל חסם.

דוגמה 4 (תרגיל מהכיתה): מכונה שמקבלת מיד

נתונה מכונה שמקבלת כל קלט מיד, בלי לקרוא אותו. מהם המדדים שלה?

פתרון. time=1time=1 ו-space=1space=1. שימו לב שאורך הקלט אינו משפיע: התאים שהקלט יושב בהם לא נכתבו על ידי המכונה ולכן אינם נספרים במקום [01:05:20]. זו בדיוק ההבחנה שההגדרה של spacespace היא "תאים שנכתבו" ולא "תאים שקיימים".

תרגיל 5 (ספירה קומבינטורית, מהכיתה)

כמה מחרוזות שונות באורך kk יש מעל א"ב בגודל mm?

פתרון. לכל אחד מ-kk המקומות יש mm אפשרויות, והבחירות בלתי תלויות, ולכן mkm^{k}. זה בדיוק הרכיב ∣Γ∣spaceM(x)|\Gamma|^{space_M(x)} בספירת הקונפיגורציות — נקודה שבלבלה כמה סטודנטים בשיעור, שחשבו שמדובר ב-∣Γ∣⋅space|\Gamma|\cdot space במקום בחזקה.

תרגיל 6 (הבנת ההגדרה): לאיזו מחלקה שייכת PALPAL?

פתרון. לפי דוגמה 1 (מכונה סטנדרטית, כמתחייב מהקונבנציה): PAL∈DTime(n2)PAL\in DTime(n^2) ו-PAL∈DSpace(n)PAL\in DSpace(n). מדגישים "סטנדרטית", שכן אילו מדדנו במכונה דו-סרטית היינו מקבלים O(n)O(n) בזמן — וזו הסיבה שהקונבנציה נקבעה מראש.

בדיקת עקביות עם משפט 6 ומשפט 7. משפט 6 נותן DTime(n2)⊆DSpace(n2)DTime(n^2)\subseteq DSpace(n^2), ואכן O(n)⊆O(n2)O(n)\subseteq O(n^2) — עקבי, אם כי לא הדוק כאן. משפט 7 נותן DSpace(n)⊆DTime(2O(n))DSpace(n)\subseteq DTime(2^{O(n)}), וגם זה מתקיים בבירור עבור מכונה שרצה בזמן O(n2)O(n^2).

הערות מהשיעור

  • "יעיל" הוא מושג לא אבסולוטי [00:04:06]. בניגוד ל"ניתן/לא ניתן לחשב", שהוא מוחלט, יעילות היא "עניין של אופנה". כשהתחום התחיל בשנות ה-70 של המאה הקודמת, זמן ריצה פולינומי בגודל הקלט נחשב יעיל — אף שגם אז ידעו ש-x100x^{100} אינו באמת יעיל [00:04:37]. היום, בגלל גדלי הנתונים, גם זמן ליניארי לא תמיד נחשב יעיל [00:05:08].
  • אילו משאבים בכלל יש? [00:06:13]–[00:12:42] הדיון בכיתה העלה: זמן, מקום/זיכרון, רוחב פס (כמות הנתונים שצריך להעביר — קריטי באלגוריתמים מודרניים), ביטים אקראיים (יקרים, ו"הרנדום" של המחשב אינו באמת אקראי), ונאמנות/דיוק של האלגוריתם — אלגוריתם אקראי לפעמים טועה, וזה משאב שאני מוכן לסחור בו. בעולם האמיתי משתמשים במשאבים האלה "כמו פלסטלינה": משלמים בזמן כדי לקבל דיוק, משלמים במקום כדי לחסוך בזמן, מחשבים יותר בבית כדי לחסוך ברוחב פס.
  • מה לא נספור [00:09:31]. זמן קומפילציה, זמן מתכנת, כמות שורות קוד — אלה משאבים אמיתיים בעולם האמיתי, אבל הם לא תלויים בקלט והם קורים לפני הריצה. בקורס הזה סופרים רק משאבים שנצרכים ב-run time.
  • מה הקורס יכסה [00:09:09, בהקלטה השנייה]: (1) מה ניתן לחשב כשהמשאבים מוגבלים; (2) קשרים בין רמות הקושי של בעיות שונות, גם כשלא יודעים להכריע לגבי כל בעיה בנפרד; (3) מה עושים כשבעיה "קשה" — קירוב, אלגוריתמים הסתברותיים. בניגוד לחישוביות, כאן יודעים הרבה פחות: יש המון בעיות שלא יודעים לפתור ביעילות וגם לא יודעים להוכיח שאי אפשר.
  • סימון OO מחביא דברים — דעו מה [00:26:08]. במעבר מרב-סרטית לחד-סרטית הקבועים המוסתרים תלויים במספר הסרטים. זה לא תלוי בקלט, אבל צריך להיות ברור מה בדיוק נבלע.
  • "קטן שווה" אינו "יותר טוב" [00:28:13]. כשכותבים ≤\le לא אומרים "זה טוב יותר", אלא "זה לא הרבה יותר גרוע".
  • המשפט הכי חוזר בשיעור [01:30:37], [00:52:11], [01:22:31]: כשאתם רואים O(⋅)O(\cdot) בהקשר של מדדי סיבוכיות, שאלו את עצמכם במה הקבוע תלוי ובמה אינו תלוי. הוא אף פעם לא תלוי בקלט. "זה המקום שבו טועים" — נאמר מפורשות שלוש פעמים.
  • מתי לא נכתוב יותר מכונות טיורינג [00:40:07]. "רוב הזמן בקורס הזה לא נכתוב מכונות טיורינג בצורה מפורשת, אנחנו נכתוב אותן כאלגוריתמים." כתבנו אותן בחישוביות כדי לקבל תחושה של המודל; קיבלנו את התחושה, אפשר להמשיך.
  • על מספר הסרטים של המכונה האוניברסלית [00:38:33]. המרצה ציין שהוא "נדיב" בסרטים — שלושה או חמישה זה עד כדי קבוע, וקבוע כפלי אינו משחק תפקיד מספיק חשוב בתיאוריה הזאת. בעולם האמיתי ההבדל בין שלושה לחמישה כן חשוב.
  • שאלת סטודנט ששווה לזכור [01:18:05]: "האם ייתכן שמכונה מיועדת להגיע לאותה קונפיגורציה כמה פעמים ורק אז לעצור?" התשובה — לא. ברגע שהיא לא יודעת את ההיסטוריה, היא לא יודעת שהיא כבר הייתה שם. אבל שימו לב לניסוח: אותו תוכן סרט יכול לחזור פעמיים; מה שלא יכול לחזור הוא השלישייה כולה.
  • על כתיבה ביד [00:22:53]. המרצה מעלה את המחברת ואת ההקלטה, ובכל זאת המליץ לכתוב, לפחות את הטענות המרכזיות וההגדרות — "הזיכרון שלנו עובד יותר טוב כשזה עובר דרך היד", וגם כדי שהחומר יהיה מול העיניים כשמפנים אליו כעבור עשר דקות.
  • תנאי הלמידה [00:53:37]: השיעור הופסק פעמיים באמצע בגלל אזעקות; הפסקה של רבע שעה. "תשמרו על עצמכם, זה יותר חשוב מסיבוכיות."
  • המשימה לשיעור הבא [01:32:10]: לחזור על החשבון של שלב ד' במשפט 5 ולוודא שאתם יודעים לבצע אותו לבד — המניפולציות של לוגים וחזקות והמעבר ל-2lg⁡(⋅)2^{\lg(\cdot)} "צריכים לשבת ממש ממש טוב". זו אלגברה, לא סיבוכיות. בנוסף — למי שלא ראה, לצפות בסרטוני הסימולציה הרב-סרטית מקורס חישוביות.

פערים בין הסיכום להקלטה

  • מקור: עמוד 1 בסיכום. הפער: מכונת טיורינג מוגדרת שם כחמישייה M=(Q,F,Σ,Γ,δ)M=(Q,F,\Sigma,\Gamma,\delta), ללא qstartq_{start}; גם בהקלטה הראשונה המרצה התבלבל בהגדרה בזמן אמת [00:15:56] ותיקן את עצמו כמה פעמים. ההכרעה: בגוף השיעור כתבתי את ההגדרה עם qstartq_{start}, מפני שהמכונה חייבת מצב התחלתי; ההקלטה השנייה [00:12:48] אכן מונה אותו במפורש כרכיב.
  • מקור: ההקלטה השנייה בלבד, [01:13:29]–[01:43:19]. הפער: הגדרות DTime(f)DTime(f) ו-DSpace(f)DSpace(f), שתי ההכלות ביניהן, והפירוק DTime(2O(f))=⋃cDTime(2cf)DTime(2^{O(f)})=\bigcup_c DTime(2^{c f}) — כל אלה אינם מופיעים כלל בארבעת עמודי הסיכום. ההכרעה: נכללו במלואם, שכן הם נלמדו בשיעור והם התוצר העיקרי שלו.
  • מקור: ההקלטה הראשונה. הפער: ההקלטה הראשונה אינה מגיעה למחלקות; היא נעצרת בדיוק אחרי הטענה timeM(x)≤2c⋅spaceM(x)time_M(x)\le 2^{c\cdot space_M(x)}, ככל הנראה בגלל שתי הפסקות האזעקה. ההכרעה: שתי ההקלטות סומנו coverage: full מפני שיחד הן מכסות את השיעור, והשנייה מכסה גם את מה שהראשונה החמיצה.
  • מקור: דוגמת הפלינדרומים. הפער: מופיעה בשתי ההקלטות (בהרחבה בשנייה, [00:16:32]–[00:20:14]) ואינה מופיעה בסיכום כלל. ההכרעה: נכללה בסעיף הדוגמאות עם החשבון המלא, כי היא הדוגמה היחידה בשיעור שבה מדדי הזמן והמקום מחושבים מקצה לקצה.
  • מקור: עמוד 2 בסיכום מול ההקלטה השנייה [00:43:10]. הפער: הסיכום נותן למכונה האוניברסלית החד-סרטית חסם זמן במכפלה O(∣⟨M⟩∣⋅timeM(x)⋅lg⁡∣ΓM∣⋅spaceM(x))O\big(|\langle M\rangle|\cdot time_M(x)\cdot\lg|\Gamma_M|\cdot space_M(x)\big), ואילו בהקלטה השנייה נאמר החסם הגס יותר O(∣⟨M⟩∣2⋅timeM(x)2)O\big(|\langle M\rangle|^2\cdot time_M(x)^2\big). ההכרעה: שני החסמים נכונים — השני מתקבל מהראשון על ידי הצבת space≤timespace\le time ו-lg⁡∣ΓM∣≤∣⟨M⟩∣\lg|\Gamma_M|\le|\langle M\rangle| — והבאתי את גרסת הסיכום כעיקרית, כי היא ההדוקה יותר, עם המסקנה הריבועית כהערה.
  • מקור: עמוד 2 בסיכום. הפער: חסם הזמן של המכונה האוניברסלית נכתב עם סימן שוויון: timeMU(⟨M,x⟩)=O(…)time_{M_U}(\langle M,x\rangle)=O(\ldots). ההכרעה: מדובר בחסם עליון; שמרתי על הסימון של הסיכום בשורה הראשונה, אך ניסחתי את הטענה כחסם.
  • מקור: עמוד 4 בסיכום, ההערה האדומה. הפער: ההערה מסומנת בצבע ובשני סימני קריאה אך ניסוחה המדויק בכתב היד קשה לפענוח מלא; ברור ממנה שהיא נוגעת לצורך להניח משהו על spacespace לפני החלוקה בשלב (*). ההכרעה: שוחזרה כתנאי spaceM(x)≥1space_M(x)\ge1 (שאחרת החלוקה אינה מוגדרת), והמקרה space=0space=0 טופל בנפרד בגוף ההוכחה. זהו שחזור, לא קריאה מילולית.
  • מקור: ההקלטה הראשונה, [01:04:19] ו-[01:20:11]. הפער: התמלול האוטומטי כותב "פונקציה חד ערכית" במקום "חד-חד-ערכית" (וגם "חדקית", "חדרכית"). ההכרעה: תוקן ל-injective; המשמעות המתמטית הנדרשת בשתי ההוכחות היא חד-חד-ערכיות, שהרי בלעדיה אין אי-שוויון בין גדלי הקבוצות.
  • מקור: ההקלטה הראשונה, [00:24:59] ו-[01:26:32]. הפער: התמלול משבש כמעט כל סימון מתמטי — "טיים"/"ט" ל-timetime, "ספייס"/"ספיס"/"SP" ל-spacespace, "לוגog"/"לogג" ל-lg⁡\lg, "גמה"/"גם m" ל-ΓM\Gamma_M, "אמ כובע" ל-M^\hat M. ההכרעה: כל הסימונים אוחדו לפי הסיכום, שהוא המקור הסמכותי לנוטציה.
  • מקור: ההקלטה הראשונה, [00:24:59]. הפער: המרצה אמר "בעיקרון זה היה ספייס 22" ומיד תיקן ל"ועוד שתיים, זה בגלל החריגה לשני הצדדים". ההכרעה: הסיכום כותב spaceM(x)+2space_M(x)+2, וזה הנוסח שנכלל; ההסבר לתוספת (+1+1 לכל צד) נכלל בגוף ההוכחה.
  • מקור: משפט 1, שני המקורות. הפער: אף מקור אינו נותן הוכחה פורמלית לסימולציה הרב-סרטית; המרצה אמר במפורש שההוכחה בסרטונים "היא לא הוכחה פורמלית, היא יותר מה הרעיון" [00:31:58]. ההכרעה: כתבתי את הבנייה ואת חשבון ארבעת הסוויפים במלואם וסימנתי את הקטע בהערת "בהרצאה זה נאמר בקיצור".

סיכום ונקודות למבחן

מה חייבים לדעת בעל פה.

  1. timeM(x)time_M(x) — מספר הפעלות δ\delta. spaceM(x)space_M(x) — מספר התאים השונים שנכתבו. שתי המחרוזות "השונים" ו"שנכתבו" הן בדיוק הנקודות שנופלים בהן.
  2. רב-סרטית →\to חד-סרטית: timeM^≤4⋅timeM⋅(spaceM+2)=O(timeM⋅spaceM)≤O(timeM2)time_{\hat M}\le 4\cdot time_M\cdot(space_M+2)=O(time_M\cdot space_M)\le O(time_M^2), והמקום נשמר עד כדי סדר גודל.
  3. מכונה אוניברסלית: פקטור ∣⟨M⟩∣|\langle M\rangle| בזמן, פקטור lg⁡∣ΓM∣\lg|\Gamma_M| במקום.
  4. spaceM(x)≤timeM(x)space_M(x)\le time_M(x) — תמיד, ללא הנחות.
  5. אין חסם הפוך בלי הנחת עצירה. עם הנחת עצירה: timeM(x)≤2cM⋅spaceM(x)time_M(x)\le 2^{c_M\cdot space_M(x)}, כאשר cM=lg⁡∣Q∣+lg⁡∣Γ∣+1c_M=\lg|Q|+\lg|\Gamma|+1.
  6. מספר הקונפיגורציות =∣Q∣⋅∣Γ∣space⋅space=|Q|\cdot|\Gamma|^{space}\cdot space.
  7. DTime(f)⊆DSpace(f)⊆DTime ⁣(2O(f))DTime(f)\subseteq DSpace(f)\subseteq DTime\!\left(2^{O(f)}\right).

המלכודות הסטנדרטיות.

  • סדר הכמתים. קבוע התלוי במכונה — מותר. קבוע התלוי בקלט — אסור. אם בהוכחה שלכם הקבוע "נבחר אחרי שראינו את xx", ההוכחה שגויה.
  • לחשוב ש-≤\le פירושו "טוב יותר". במעבר לחד-סרטית האי-שוויון מבטיח רק ש"לא הרבה יותר גרוע".
  • לענות "המכונה לא עוצרת" כנימוק שלם במשפט 4. חייבים גם לומר שהיא משתמשת במקום קבוע.
  • לבלבל ∣Γ∣space|\Gamma|^{space} עם ∣Γ∣⋅space|\Gamma|\cdot space בספירת הקונפיגורציות.
  • לשכוח למה MM עוצרת בהוכחת משפט 7 — הנימוק אינו חסם המקום אלא העובדה שהיא מכריעה.
  • לספור תאים שהקלט יושב בהם כחלק מה-spacespace כשהמכונה לא כתבה בהם.
  • לשכוח את הקונבנציה שכל המדדים במכונה סטנדרטית חד-סרטית, אלא אם נאמר אחרת.

צ'ק-ליסט: מה סטודנט אמור לדעת לעשות אחרי השיעור.

  • לחשב timetime ו-spacespace של מכונה נתונה על קלט נתון, ולנמק כל אחד מהם.
  • להוכיח שייכות של שפה ל-DTime(f)DTime(f) או ל-DSpace(f)DSpace(f) על ידי הצגת מכונה ובדיקת שני התנאים בהגדרה.
  • לבצע לבד את כל האלגברה של שלב ד' במשפט 5: ab=2blg⁡aa^b=2^{b\lg a}, איחוד חזקות, הוצאת spacespace כגורם משותף, והחסימות lg⁡∣Q∣s≤lg⁡∣Q∣\frac{\lg|Q|}{s}\le\lg|Q| ו-lg⁡ss≤1\frac{\lg s}{s}\le1.
  • לספור קונפיגורציות של מכונה נתונה.
  • לתרגם חסם על מכונה רב-סרטית לחסם על מכונה חד-סרטית ולהיפך.
  • לזהות, בכל טענה עם OO, במה הקבוע תלוי.

הסיכום הכתוב שעליו נשען הקובץ הוא של גיא סופר.

שאלות שנשארו פתוחות

  • ה-slug שניתן, intro-what-is-computable, מתאים לשיעור הראשון של *חישוביות*; השיעור הזה כבר עוסק ב'מה ניתן לחשב ביעילות' — כלומר במודל, במשאבים ובמחלקות. השארתי את שם הקובץ כפי שהוקצה והכותרת האמיתית נמצאת ב-title_he.
  • הגדרת מכונת הטיורינג בעמוד 1 בסיכום היא חמישייה $(Q,F,\Sigma,\Gamma,\delta)$ ואינה כוללת את $q_{start}$. בגוף השיעור כתבתי את ההגדרה המלאה; ייתכן שגיא סופר השמיט את $q_{start}$ בכוונה מפני שהמרצה עצמו התבלבל בהגדרה בהקלטה [00:15:56].
  • הגדרות $DTime$ ו-$DSpace$ מופיעות רק בהקלטה השנייה ואינן בסיכום של שיעור 1. ייתכן שהן מופיעות בסיכום של שיעור 2 — כדאי שהרכז יוודא שאין כפילות מול הקובץ של שיעור 2.
  • המרצה אמר [00:21:16] שכדאי לחזור לסרטוני הסימולציה מקורס חישוביות; הסרטונים אינם בין המקורות שלי, ולכן פירוט הסימולציה של מכונה רב-סרטית שוחזר מהתמליל ומהסיכום ולא מהמקור שאליו הפנה.