DSPACE

1. DSPACE נכתב ע"י: ינון חמדי נועה ספרא רונית קרויטורו

2. הקדמה • עד כה מדדנו במכונת טיורינג את מספר הפעולות שעשתה (ז"א זמן ריצה) וע"פ זה הגדרנו סוגי בעיות בהתאם לזמן הנדרש לריצתן. DTIME • כעת נרצה לסווג בעיות מבחינת המקום הנדרש להתכונן במכונת טיורינג. DSPACE

3. דוגמא 1: • עבור קלט מסוים n ברצוננו להחזיר את אורכו. • במקרה זה מספיק להחזיר את ייצוגו הבינארי, הדורש שטח של o(log n) ביטים. למשל, עבור הקלט הנ"ל: #111111111# הפלט יהיה: #1001#

4. דוגמא 2: • בהינתן קלט n נרצה לחשב את n2. במקרה זה, הפלט יתפוס הרבה מקום. הערות: • כפי שרואים, ניתן להגביל את המקום לפחות מליניארי o(log n). • סיווג הבעיות יעשה ע"פ גודל המקום שיתפסו עם תלות אך ורק בקלט n.

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

6. הגדרה 1:(DSPACE(s(n) • תהי מ"ט כנ"ל: Input S Output כאשר: • Input – סרט קלט שיוגבל ל-log (n) (כאמור, נייצג כל קלט בינארי), עם אפשרות קריאה בלבד (ROH), עם אפשרות תנועה דו כיוונית. Q

7. המשך הגדרה 1: • S – יהיה סרט עבודה. • Output – סרט פלט לכתיבה בלבד (WOH), עם אפשרות תנועה רק לצד ימין. • תהי s(n) פונקציה כלשהי. • נגדיר (DSPACE(s(n) ככל הבעיות הניתנות לפתרון ע"י מ"ט הנ"ל, כאשר S (סרט העבודה) מוגבל ע"י s(n). • למשל, כפי שראינו, דוגמא 1 שייכת ל- .DSPACE(o(log n))

9. משפט 1: ומה לגבי סרטה- Output? DSPACE (s(n)) < DTIME (o(2o(s(n)))) - ז"א כשסרט העבודה S מוגבל ע"י s(n), אזי אחרי 2o(s(n)) צעדים, המכונה תעצור.

10. הוכחה: • נניח {1,0,#}=  . • מספר המצבים בסרט העבודה – 3s(n)[בכל אחד מ- s(n) מקומות יתכנו אחד מ-3 אותיות]. • מספר אפשרויות למיקום הראש בסרט העבודה – s(n) [כאורך הסרט]. • מספר אפשרויות למיקום הראש בסרט הקלט – log n [כאורך הסרט, מכיוון שהקלט הוא בייצוג בינארי].

11. המשך ההוכחה: • מספר מצבי מ"ט - | Qm |. • לכן סה"כ המצבים האפשריים: 3s(n)·s(n)·log n·|Qm| < 2o(s(n)) • כל המרכיבים במכפלה, למעט 3s(n), קטנים מ- 2o(s(n)). 3s(n) < 2k·s(n), כאשר k > 2 3s(n) < 2(o(s(n))

12. המשך ההוכחה: • הערה : לא סופרים מספר אפשרויות בסרט הקלט כי הוא ROH ולא משפיע על המצבים. • נניח בשלילה שיש יותר מ- 2o(s(n)) צעדים. • יש לפחות מצב אחד שחוזר על עצמו פעמיים. צעד 2 צעד 1 ...

13. המשך ההוכחה: • אך במקרה כזה, היה חוזר למופע המצב הראשוני והייתה לולאה אינסופית ולא היה עוצר. • ומכיוון שמניחים שמ"ט עוצרת (נותנת פתרון) לא יתכן שמצב יחזור על עצמו פעמיים זמן ריצה חסום ב- 2o(s(n)) (מספר המצבים). מסקנה : סרט ה- Output חסום ע"י 2o(s(n)), ומכיוון שלא יכול לכתוב יותר מ- 2o(s(n)) צעדים.

14. סיכום: בהינתן מ"ט לעיל עם קלט n אזי: * סרט הקלט חסום ב – log n ביטים. * סרט העבודה חסום ב – s(n) ביטים. * סרט הקלט חסום ב – 20(s(n)) ביטים.

15. טענה 1: • DSPACE (o(1)) שקול לאוטומט סופי דטרמיניסטי (שפות רגולריות). הוכחה: • DSPACE(o(1))S חסום במספר קבוע k. • בסרט העבודה יהיו מקסימום 3k אפשרויות.

16. המשך ההוכחה: • אפשרויות אלה ניתן לתרגם למצבים ולהוסיפם ל- Qm (נסמן מצבים אלו ב-Qm+). • נקבל מ"ט כנ"ל Input S Output Input Output Qm Qm+

17. המשך ההוכחה: • מ"ט היא מכונה 2Way השקולה לאוטומט סופי דטרמיניסטי. מהו DSPACE (o(log n)) ?

19. טענה 2: DSPACE(o(log(n)) = DSPACE(o(1)). ז"א אינו שקול לשפות רגולריות. הוכחה: • תהי L={w=0..0$0..1$…$1..1} kkk • L אינה רגולרית. ז"א L=DSPACE(o(1)).

20. המשך ההוכחה: • אבל נראה L  DSPACE(o(log(n)). (נראה בעצם ש- L  DSPACE(o(loglog n))). [ אורך המילה ב-L הוא n = k(2k+1) = 2o(k). (ישנם 2k תתי מילים, כל אחת באורך k, ועוד k $-ים)].

21. המשך ההוכחה: • סדרת הפעולות במ"ט תהינה כנ"ל: • "בדוק שכל תת מילה באורך k. אם לא, החזר '0' ועצור". • "בדוק שאורך כל המילה הוא n. אם לא, החזר '0' ועצור". • "בדוק שתתי המילים עוקבים, ז"א ...$1+X$1$... אם לא, החזר '0' ועצור".

22. המשך ההוכחה: [- אם הספרה הימנית היא '0', בודק שבתת מילה הבאה הספרה הימנית היא '1', והשאר שוות. - אם הספרה הימנית היא '1', בודק שבתת מילה הבאה כל הספרות הן '0' עד המקום הראשון שבתת מילה ראשונה יש '1' : $001000$000111$ .] 4. "בדוק האם מתחיל ב - $0..00$ ומסתיים ב – $1..11$."

23. המשך ההוכחה: • המקום הדרוש לכל שלב בסרט העבודה: • את המילה עצמה w מייצגים ע"י log n (=k) ביטים, ולכן אורך כל תת מילה log k ביטים. לכן ע"מ לבדוק שאורכה log k ביטים, מספיק: o(loglog k). • ע"מ לבדוק שאורך כל המילה k מספיק o(log k). • מספיק לזכור כמה לקפוץ )כי בודקים שתי תתי מילים צמודות), שזה שווה לאורך תת מילה שהיא log k. על כן מספיק: o(loglog k). • בדיקה זו לוקחת o(1). סה"כ : o(log k) = o(loglog n)

24. המשך ההוכחה: • L  DSPACE(o(loglog n)) • L  DSPACE(o(log n)) הערה: אמנםDSPACE(o(log n)) = DSPACE(o(1)) אבל DSPACE(0(1))  DSPACE(o(log n)) (בעיה הדורשת גודל קבוע בסרט העבודה, ודאי יספיק לה log n מקום).

25. טענה 3: • DSPACE (o(log log n))  DSPACE (o(1)) • ז"א, כל השפות שניתן לפותרן ע"י שמגבילים את S בסדר גודל קטן מ- log log n אזי מספיק להן מספר קבוע של מקום (ובעצם שייך לרגולרי). [ מקודם הראנו שמה שיותר מ- log log n לא חסום ב – o(1) ].

26. הוכחה: • בהינתן קלט n נשכתב אותו כדלהלן – לכל אות נכתוב את רשימת הקונפיגורציות שעוברות דרכה. # 0 0 1 0 1 1 0 # מערך עבור אות אחרונה קונפיגורציה

27. המשך ההוכחה: • עבור כל אות, מספר הקונפיגורציות האפשריות: S(n) · |Qm| · 3s(n) = 2o(s(n)) מספר אפשרויות בסרט העבודה מספר מצבי הראש בסרט הקלט מספר מצבי מ"ט

28. המשך ההוכחה: • גודל מערך כל אות חסום ע"י 2o(s(n)), כי אחרת יהיו שתי קונפיגורציות זהות, ותהיה לולאה אינסופית. ז"א, לא תתכן אותה קונפיגורציה פעמיים. • כעת, בכל אות, עבור קונפיגורציה מסוימת, נסמן '1' – אם היה בה '0' – אם לא • ישנם אורך מערך 2 אפשרויות של מערכים. ז"א : 2o(s(n)) 2

29. המשך ההוכחה: • ע"פ הנתון s(n) = o(log log n) ז"א שיש 2o(loglogn) אפשרויות. • ז"א עבור כל אות ישנם פחות מ- n מצבים. • ישנם n אותיות ופחות מ – n אפשרויות למערכים. ז"א שיש לפחות מערך אחד שחוזר על עצמו (בפרט יתכן שב – 2 המערכים ישנו אותו תו). 2

30. המשך ההוכחה: ... ... ... } } } X X U V Y

31. המשך ההוכחה: • החישוב על Wn = UXVXY יהיה שקול לחישוב על UXV או על UXY. (כי בעצם מ-X השני הכל חוזר על עצמו). • ז"א אם נחשב על המילה UXVW = (או XY), החישוב יתפוס אותו מקום כך שנוכל לצמצם ונקבל s(n) < s(n1). • וכך נוכל להמשיך לצמצם עד שנקבל ש – n n0 | s(n) = s(n0) n1

32. המשך ההוכחה: • S(n0) = s(o(1)) כפי שראינו בטענה 1. • ז"א ש – DSPACE (o(log log n))  DSPACE o(1))