‫סיבוכיות‬

‫‪1‬‬

‫הקדמה‬
‫• חישוביות‪ :‬מה ניתן לחשב‪ .‬לדוגמה‪:‬‬
‫– קלט‪ :‬תוכנית ‪( M‬למשל בשפת ‪ )while‬וקלט ‪ x‬לתוכנית‪.‬‬
‫• השאלה‪ :‬האם ‪ M‬עוצרת בריצתה על ‪?x‬‬
‫• ראינו‪ :‬הבעיה אינה ניתנת להכרעה‪.‬‬

‫• סיבוכיות‪ :‬מה ניתן לחשב ביעילות‪.‬‬

‫• המשאבים שנתרכז בהם‪ :‬זמן‪ ,‬מקום‪.‬‬
‫• דוגמה‪:‬‬
‫– קלט‪ :‬קבוצת מספרים ‪ a1, …, an‬ומספר נוסף ‪ – S‬כולם בייצוג‬
‫עשרוני‪.‬‬
‫השאלה‪ :‬האם קיימת קבוצה חלקית של ‪ a1, …, an‬שסכומה הוא ‪?S‬‬ ‫•‬
‫האם את הבעיה הזאת ניתן להכריע?‬ ‫•‬
‫יעילות של אלג' הכרעה כזה?‬ ‫•‬
‫נראה‪:‬‬ ‫•‬
‫– הבעיה היא ‪- NP‬קשה (הגדרות בהמשך)‪.‬‬
‫– שינוי ייצוג הקלט לאונרי עשוי לשנות את סיבוכיות הבעיה‪.‬‬
‫‪2‬‬

‫‪1‬‬
 ‫במה נעסוק בקורס (רשימה חלקית)‬
‫• קשרים בין המשאבים השונים‪ .‬למשל‪:‬‬
‫– אם בעיה ניתנת להכרעה בזמן )‪ , O(n2‬מה זה אומר על המקום הנדרש?‬
‫– וההפך‪.‬‬
‫• מחלקות סיבוכיות‪:‬‬
‫– נחלק בעיות למחלקות לפי כמות המשאבים הנדרשת לפתרונן‪ .‬למשל‪:‬‬
‫– מחלקות של בעיות שניתן להכריע בזמן )‪. O(n2‬‬
‫היררכיה בין מחלקות סיבוכיות‪:‬‬ ‫•‬
‫– נראה למשל שיש בעיות שניתנות להכרעה בזמן )‪ O(n5‬אך לא )‪. O(n2‬‬
‫– אחת התוצאות‪. P  EXP :‬‬
‫• המחלקה ‪ NP‬והבעיה הפתוחה של התחום (הגדרות בהמשך)‪:‬‬
‫– ‪?P = NP‬‬
‫נראה בעיות פתוחות רבות נוספות‪:‬‬ ‫•‬
‫– ‪?NP = coNP‬‬
‫– ‪... ?L = P ?NP = EXP‬‬

‫‪3‬‬

‫במה נעסוק בקורס (‪)2‬‬

‫• אלגוריתמי קירוב‪:‬‬
‫– לבעיות אופטימיזציה המבוססות על בעיות ‪-NP‬קשות‬
‫אין כנראה אלגוריתם יעיל‪.‬‬
‫– למשל‪:‬‬
‫• בעיית הסוכן הנוסע‪.‬‬
‫– המטרה‪:‬‬
‫• אלגוריתם יעיל המחזיר פתרון מקורב‪.‬‬
‫– בדוגמת הסוכן הנוסע‪:‬‬
‫• למשל למצוא מסלול שערכו לכל היותר כפול מאורך המסלול‬
‫האופטימלי‪.‬‬

‫‪4‬‬

‫‪2‬‬
 ‫במה נעסוק בקורס (‪)3‬‬
‫• אורקלים‪:‬‬
‫– איך משתנה כוח החישוב של אלגוריתם אם נוסיף לו פעולה‬
‫בסיסית של פתרון בעיה קשה מסוימת‪.‬‬
‫– למשל‪ :‬מה ניתן להכריע בזמן פולינומיאלי בעזרת קופסה‬
‫שחורה שמכריעה את ‪ SAT‬ב‪ O(1) -‬זמן‪.‬‬
‫• סיבוכיות מקום תת לינארית‪:‬‬
‫– בד"כ סיבוכיות המקום היא לפחות ליניארית כי‬
‫• צריך לפחות לקרוא את הקלט‪.‬‬
‫– מה אם האלגוריתם לא צריך לשמור את הקלט?‬
‫• דוגמה‪:‬‬
‫– גרף האינטרנט‪.‬‬
‫– סוג השאלות שנתעניין בהם‪:‬‬
‫• מהי מחלקת הבעיות שניתן לפתור במקום )‪? O(log n‬‬
‫‪5‬‬

‫במה נעסוק בקורס (‪)4‬‬

‫• אלגוריתמים הסתברותיים‪:‬‬
‫• מותר לאלגוריתם לבצע בחירות אקראיות (למשל – הטלת‬
‫מטבע)‪.‬‬
‫• עשוי להתנהג באופן שונה בריצות שונות על אותו קלט‪.‬‬
‫• עלול לתת תשובות שגויות‪.‬‬
‫• אך נוכל במקרים כאלו להקטין את הסתברות השגיאה תמורת זמן‪.‬‬
‫• בהרבה מקרים – אלגוריתם הסתברותי פשוט ויעיל יותר‬
‫מהאלגוריתם הדטרמיניסטי לאותה בעיה‪.‬‬
‫• האם אלגוריתמים הסתברותיים הם בכלל פרקטיים?‬
‫• כן ‪ -‬ניתן לסמלץ בתוכנית מחשב בחירות אקראיות‪.‬‬
‫• ולא נשכח שאנחנו בקורס סיבוכיות אז‪:‬‬
‫• נגדיר ונדון במחלקות סיבוכיות הסתברותיות (‪.)BPP ,RP‬‬

‫‪6‬‬

‫‪3‬‬
 ‫דרישות הקורס‬
‫• נוכחות בשיעור‪:‬‬
‫– אינה חובה (ולכן אינה מוזכרת בסילבוס) אבל‪:‬‬
‫• מנסיוני יש קורלציה חיובית בין נוכחות בכיתה והצלחה בקורס‪.‬‬
‫• הגשת תרגילים‪:‬‬
‫– יהיו כ‪ 6 -‬תרגילים‪.‬‬
‫– יש להגיש את כל התרגילים בזמן‪.‬‬
‫– תרגיל שלא יוגש בזמן לא ייחשב‪.‬‬
‫• סיבות כגון עומס בעבודה לא יתקבלו !‬
‫– הגשה שאינה מעידה על מאמץ סביר לא תיחשב‪.‬‬
‫– משמעות אי הגשת תרגיל‪ :‬אי עמידה בדרישות הקורס‪.‬‬
‫– בין התרגילים יהיה חומר ללמידה עצמית‪.‬‬
‫• זה דורש עבודה‪ .‬תתחילו לעבוד על חומר זה מוקדם ככל האפשר !‬
‫• החומר לבחינה‪:‬‬
‫– התכנים שנלמדו במהלך הקורס (כולל התרגילים שניתנו בקורס)‪.‬‬
‫– החומר שניתן ללימוד עצמי‪.‬‬
‫• ציון הקורס‪ :‬ציון הבחינה ‪ +‬עד ‪ 5‬נקודות בונוס על התרגילים‪.‬‬
‫• מנהלה‪:‬‬
‫– תרגילים מוגשים דרך ה‪ Mama -‬כקובץ ‪ PDF‬יחיד‪.‬‬
‫– באחריותכם לוודא שכתב היד ברור וקריא ושהסריקה יוצאת נקיה וברורה‪.‬‬
‫‪7‬‬

‫שעת קבלה‬
‫• שני ‪ 15:00-16:00‬בתאום מראש במייל‪.‬‬
‫• אפשר לנסות לתאם גם זמנים אחרים‪.‬‬
‫• מייל‪:‬‬
‫– ‪first-name@mta.ac.il‬‬
‫– ‪first.last@gmail.com‬‬
‫• אל תהססו להגיע לשעת הקבלה – היא בשבילכם‪.‬‬
‫• מנסיוני יש קורלציה חיובית בין הגעה לשעת קבלה‬
‫והצלחה בקורס‪.‬‬
‫• ניתן גם לשאול שאלות ולבקש רמזים במייל אך אין‬
‫התחייבות במקרה כזה על מהירות התשובה‪.‬‬

‫‪8‬‬

‫‪4‬‬
 ‫סיבוכיות‬

‫‪9‬‬

‫מודל החישוב‬
‫• בחישוביות‪ :‬שפת ‪( while‬וגם ‪.)goto‬‬
‫• בקורס זה‪ :‬מכונת טיורינג (מ"ט)‪.‬‬
‫– מצד אחד‪ :‬ניתן לחשב בו כל מה שניתן לחישוב‪.‬‬
‫שקול ל‪...JAVA ,C ,while -‬‬

‫מודל פשוט‪ .‬שימושי בהוכחות קושי‪.‬‬ ‫– מצד שני‪:‬‬

‫‪10‬‬

‫‪5‬‬
 ‫הגדרות‬
‫• נתון א"ב ∑‪ .‬למשל }‪.  = {0, 1‬‬
‫• רצף סופי של תווים מעל ∑ נקרא מחרוזת‪ .‬למשל ‪.0010‬‬
‫• המחרוזת הריקה מסומנת ‪.ε‬‬
‫• עבור מחרוזת ‪ |w| , w‬מסמן את אורך המחרוזת ‪. w‬‬
‫• עבור ‪ am , a  ‬מסמן את המחרוזת המכילה את התו ’‪ m ‘a‬פעמים‪.‬‬
‫• עבור א"ב ‪ ∑* , ‬מסמן את כל המחרוזות מעל ∑‪.‬‬
‫• למשל עבור }‪.* = {ε, 0, 1, 00, 01, 10, 11, 000, …}  = {0, 1‬‬
‫• שפה ‪ A‬היא קבוצה של מחרוזות מעל ∑ – כלומר *‪.A  ‬‬

‫• למשל‪ xt( PAL = {x  {0, 1}* | x = xt} :‬היא ‪ x‬מהסוף להתחלה)‪.‬‬

‫• הכרעת שפה ‪ – A‬בהינתן קלט *‪ , x  ‬לקבוע האם ‪. x  A‬‬
‫• הגדרה פורמלית בהמשך‪.‬‬
‫• בעיית הכרעה (שם נרדף לשפה)‪ :‬נתון קלט וצריך להכריע האם מקיים תנאי מסוים‪.‬‬
‫• שפות טריוויאליות‪ ∑* :‬ו‪.  -‬‬

‫‪11‬‬

‫מכונת טיורינג‬
‫• עובדת על סרט אינסופי של תווים‪.‬‬
‫• בתחילה‪:‬‬
‫– הקלט כתוב על הסרט ושאר (אינסוף) תאי הסרט מכילים את‬
‫התו רווח (‪.)B‬‬
‫– ראש המכונה מצביע על התו השמאלי ביותר בקלט‪.‬‬
‫– המכונה נמצאת במצב התחלתי ‪.qstart‬‬
‫• המכונה מכילה הוראות הקובעות לפי מצב המכונה והתו שהראש‬
‫מצביע עליו‪ ,‬מה המכונה תעשה בצעד הבא‪.‬‬
‫‪qstart‬‬

‫‪0 0 0‬‬

‫‪12‬‬

‫‪6‬‬
 ‫‪qstart‬‬

‫‪0 0 0‬‬

‫• צעד של המכונה‪ :‬בהתאם למצב המכונה והתו שהראש מצביע עליו‪:‬‬

‫• המכונה כותבת תו חדש במקום שהראש מצביע עליו‪.‬‬
‫• ראש המכונה זז תא אחד ימינה או שמאלה‪.‬‬
‫• המכונה עוברת למצב חדש‪.‬‬
‫‪0‬‬ ‫‪B‬‬ ‫• הצעדים נקבעים לפי טבלת‬
‫מעברים‪.‬‬
‫‪qstart‬‬
‫‪q1‬‬
‫‪q2‬‬
‫‪q3‬‬

‫למשל ‪...‬‬ ‫•‬

‫‪13‬‬

‫מכונת טיורינג – הגדרה פורמלית‬

‫• מ"ט היא רביעייה )‪ . M = (Q, , , ‬כוללת‪:‬‬
‫‪. qreject , qaccept , qstart‬‬ ‫• ‪ - Q‬קבוצה (בגודל סופי) של מצבי המכונה כולל‬
‫• ‪ ‬א”ב קלט (בגודל סופי)‪.‬‬
‫• ‪ - ‬א”ב עבודה (בגודל סופי)‪ .    .‬מאפשר להשתמש בתווים נוספים לעבודת המכונה‪.‬‬
‫תו הרווח ‪ B‬שייך ל‪  -‬אך לא ל‪ .  -‬זה מאפשר‪:‬‬
‫• לזהות היכן הקלט מסתיים‪.‬‬
‫• פועלת על סרט אינסופי דו כווני של תאים‪ .‬ראש המכונה מצביע על אחד התאים‪.‬‬
‫• הסרט מכיל בתחילה את הקלט ושאר התאים מכילים ‪ . B‬הראש על תחילת הקלט‪.‬‬
‫• בכל שלב המכונה באחד מהמצבים‪ .‬בתחילה ב‪ . qstart -‬נעצרת ב‪. qreject , qaccept -‬‬

‫• פונקציית המעברים ‪( ‬בגודל סופי)‪ : Q    Q    {L, R} :‬‬

‫‪0 0 0‬‬
‫‪14‬‬
‫סרט אינסופי‬

‫‪7‬‬
 ‫הכרעת שפה‬
‫מ"ט ‪ M‬מכריעה שפה *‪ A  ‬אם לכל *‪:x  ‬‬
‫– אם ‪:x  A‬‬
‫• המכונה עוצרת על ‪ x‬במצב ‪qaccept‬‬
‫– אם ‪:x  A‬‬
‫• המכונה עוצרת על ‪ x‬במצב ‪qreject‬‬
‫שימו לב‪:‬‬
‫– מ"ט שמכריעה שפה עוצרת על כל קלט‪.‬‬

‫‪15‬‬

‫דוגמאות‬
‫• מ"ט שלא עוצרת (ולכן לא מכריעה שום שפה)‪.‬‬
‫• מ"ט שמכריעה את השפה‬
‫}‪PAL = {x  {0, 1}* | x = xt‬‬
‫– אבחנה‪ :‬מחרוזת ‪ x  {0, 1}n‬היא פלינדרום אמ"מ ‪...‬‬
‫– אלגוריתם‪... :‬‬
‫{=‪‬‬ ‫{ = ‪} ,‬‬ ‫}‬ ‫– המכונה‪:‬‬
‫‪Q = { qstart, qaccept, qreject,‬‬ ‫}‬
‫‪:‬‬
‫‪qstart‬‬

‫‪8‬‬
 ‫הגדרות סיבוכיות זמן ומקום של מ"ט‬
‫• עבור מ"ט ‪ M‬וקלט *‪:x  ‬‬
‫• )‪:timeM(x‬‬
‫– מספר הפעלות ‪ ‬בריצת ‪ M‬על ‪.x‬‬
‫• )‪:spaceM(x‬‬
‫– מספר התאים (השונים) ש‪ M -‬כותבת בהם בריצת ‪ M‬על ‪.x‬‬
‫• דוגמה‪ :‬יעילות המכונה להכרעת }‪:PAL = {x  {0, 1}* | x = xt‬‬
‫= )‪timeM(x‬‬
‫= )‪spaceM(x‬‬
‫• בד"כ נסמן את אורך הקלט ב‪ .n -‬נקבל שהמכונה רצה ב‪:‬‬
‫– זמן‪:‬‬
‫– מקום‪:‬‬

‫‪17‬‬

‫קשר בין זמן ומקום במ"ט‬

‫• נחסום את המקום בעזרת הזמן‪:‬‬
‫– למ"ט ‪ M‬וקלט ‪ x‬מתקיים‪spaceM(x)  timeM(x) :‬‬
‫– הוכחה‪... :‬‬

‫• נחסום את הזמן בעזרת המקום‪:‬‬

‫– האם תמיד ניתן לחסום‪... :‬‬
‫– ואם ‪ M‬כן עוצרת על ‪:x‬‬
‫• נגדיר לשם כך מושג חדש – קונפיגורציות של מ"ט‪.‬‬

‫‪18‬‬

‫‪9‬‬
 ‫קונפיגורציות של מ"ט‬
‫• תהי )‪ M = (Q, , , ‬מ"ט ו‪ x -‬קלט כך ש‪.spaceM(x) = s -‬‬
‫• קונפיגורציה של ‪ M‬על ‪ x‬מייצגת תיאור רגעי בריצת ‪M‬‬
‫על ‪.x‬‬
‫• התיאור כולל את הרשימה הבאה‪:‬‬
‫– מצב המכונה‪.‬‬
‫– מיקום הראש הקורא‪.‬‬
‫– תוכן הסרט‪ .‬ליתר דיוק‪:‬‬
‫• חלק הסרט שהמכונה עשויה היתה לכתוב בו‪ .‬כלומר ‪...‬‬
‫• פורמלית‪(q, i, a-s+1, a-s+2, …, a0, a1, … as-1) :‬‬
‫– ‪ q  Q‬הוא המצב הנוכחי‬
‫– ‪ -s < i < s‬הוא מיקום הראש (‪ 0‬מייצג את המיקום ההתחלתי)‬
‫– ‪ -s+1  j  s-1 ,aj  ‬הוא תוכן התא ה‪.j -‬‬
‫‪19‬‬

‫• תזכורת‪:‬‬
‫– )‪ M = (Q, , , ‬מ"ט ו‪ x -‬קלט כך ש‪.spaceM(x) = s -‬‬
‫– קונפיגורציה‪(q, i, a-s+1, a-s+2, …, a0, a1, … as-1) :‬‬
‫• ריצה של ‪ M‬על ‪ x‬היא סדרת קונפיגורציות ש‪:‬‬
‫– מתחילה ב‪ -‬קונפיגורציה ההתחלתית‪.‬‬
‫• בקונפיגורציה ההתחלתית‪:‬‬
‫– ‪i = 0 ,q = qstart‬‬
‫– התאים ‪ a0, …, an-1‬מכילים את הקלט ‪ x‬ושאר התאים מכילים ‪B‬‬
‫– עוברת מקונפיגורציה לקונפיגורציה לפי ‪...‬‬
‫– מסתיימת בקונפיגורציה עם ‪ qaccept‬או ‪ qreject‬או שאינה‬
‫מסתיימת‪.‬‬

‫‪20‬‬

‫‪10‬‬
 ‫חסם על הזמן כפונקציה של המקום‬
‫(אם המכונה עוצרת)‬
‫• תזכורת‪:‬‬
‫– )‪ M = (Q, , , ‬מ"ט ו‪ x -‬קלט כך ש‪.spaceM(x) = s -‬‬
‫– קונפיגורציה‪(q, i, a-s+1, a-s+2, …, a0, a1, … as-1) :‬‬
‫נניח עתה בנוסף ‪.timeM(x) < ‬‬ ‫•‬
‫אז בהכרח המכונה אינה חוזרת על קונפיגורציה‪.‬‬ ‫•‬
‫מה מספר הקונפיגורציות האפשריות בריצת ‪ M‬על ‪... :x‬‬ ‫•‬
‫ניתן להציג את החסם באופן קומפקטי‪:‬‬ ‫•‬
‫)‪timeM(x) = 2O(s‬‬
‫הסבר‪... :‬‬ ‫•‬
‫הערה לגבי גודל הקבוע שב‪:big O -‬‬ ‫•‬
‫– הוא מסדר גודל של |‪.log |M‬‬

‫‪21‬‬

‫סיכום‬
‫משפט‪:‬‬
‫‪ .1‬אם מ"ט ‪ M‬עוצרת על קלט ‪ x‬אזי‬
‫))‪time M (x)  2O(space M (x‬‬
‫‪ .2‬אם מ"ט ‪ M‬מכריעה שפה במקום ))‪ O(f(n‬אזי לכל קלט ‪x‬‬

‫))|‪time M (x)  2O(f(|x‬‬

‫הערה‪:‬‬
‫– שימו לב שבשני הסעיפים‪ M ,‬היא מכונה קבועה‪.‬‬
‫– לכן גם הגודל של ‪ M‬הוא קבוע וסופי‪.‬‬
‫– בהמשך הקורס יהיו מקרים שמ"ט היא קלט למ"ט אחרת‪.‬‬
‫במקרה כזה המכונה שבקלט אינה קבועה וגודלה אינו חסום‪.‬‬

‫‪22‬‬

‫‪11‬‬
 ‫חישוב פונקציות בעזרת מ"ט‬
‫לעיתים נרצה לחשב פונקציה ולא להכריע‪.‬‬ ‫•‬
‫מה צריך לשנות בהגדרת המכונה?‬ ‫•‬
‫נחליף את ‪ qaccept‬ו‪ qreject -‬במצב יחיד ‪.qhalt‬‬ ‫•‬
‫הגדרה‪ :‬מ"ט מחשבת פונקציה *‪ f : *  ‬אם לכל *‪:x  ‬‬ ‫•‬
‫– המכונה עוצרת על ‪ x‬כאשר )‪ f(x‬מופיע על הסרט (ושאר התווים הם ‪.)B‬‬
‫– ראש המכונה מצביע על התו הראשון ב‪.f(x) -‬‬
‫• דוגמה‪:‬‬
‫– חישוב המספר העוקב (כלומר ‪ )f(n) = n+1‬כאשר הקלט והפלט בייצוג‬
‫אונרי‪.‬‬
‫– עבור קלט ‪000‬‬
‫• הפלט צריך להיות ‪( 0000‬והראש על ה‪ 0 -‬השמאלי)‬

‫‪23‬‬

‫דוגמה ‪ -‬חישוב העוקב למספר בייצוג אונרי‬

‫{=‪‬‬ ‫{ = ‪} ,‬‬ ‫• המכונה‪} :‬‬
‫‪Q = { qstart, qhalt,‬‬ ‫}‬
‫‪:‬‬

‫‪qstart‬‬

‫‪24‬‬

‫‪12‬‬
 ‫האם מ"ט יכולה לחשב כל פונקציה‬
‫• ראינו בחישוביות פונקציות שאינן ניתנות לחישוב (כולל‬
‫שפות שאינן ניתנות להכרעה)‪.‬‬
‫• האם מ"ט יכולה לחשב פונקציות אלו?‬
‫– ברור שלא – המודלים שקולים (אבל לא נוכיח את השקילות)‪.‬‬
‫• נראה פונקציה נוספת שאינה ניתנת לחישוב (הפעם‬
‫תוך שימוש במ"ט כמודל החישוב)‪.‬‬
‫• מטרות‪:‬‬
‫– שימוש במודל להוכחות שליליות‪.‬‬
‫– הדגמה של שרשור של מכונות טיורינג‪.‬‬
‫– הבעיה עצמה מעניינת וקשורה למודל החישוב‪.‬‬

‫‪25‬‬

‫בעיית הבונה החרוץ (‪)Busy Beaver‬‬

‫• תהי ‪ M‬מ"ט עם }‪  = {0, B} , = {0‬שעוצרת על‬
‫הקלט הריק‪.‬‬
‫• נסמן )‪ zero(M‬את מספר האפסים ש‪ M -‬כותבת‬
‫על הסרט בריצתה על הקלט הריק‪.‬‬
‫• דוגמה‪:‬‬
‫– תהיה ‪ M‬המכונה הבאה‪ .‬למה שווה )‪?zero(M‬‬
‫‪0‬‬ ‫‪B‬‬
‫‪qstart‬‬ ‫)‪(qhalt, 0, L‬‬ ‫)‪(q1, 0, R‬‬
‫‪q1‬‬ ‫)‪(qhalt, B, R‬‬ ‫)‪(q2, 0, R‬‬
‫‪q2‬‬ ‫)‪(qhalt, 0, L‬‬ ‫)‪(qhalt, 0, R‬‬
‫‪26‬‬

‫‪13‬‬
 ‫בעיית הבונה החרוץ (‪)Busy Beaver‬‬
‫• נסמן ב‪ R(n) -‬את קבוצת מכונות הטיורינג המקיימות‪:‬‬
‫– הן בעלות ‪ n‬מצבים (וכן ‪)qhalt‬‬
‫– }‪  = {0‬ו‪ = {0, B} -‬‬
‫– הן עוצרות על הקלט הריק‪.‬‬
‫• לכל ‪ n‬מתקיימת תחרות בין כל המכונות ב‪.R(n) -‬‬
‫• מכונה מנצחת‪:‬‬
‫– מכונה שכותבת מספר מירבי של אפסים בריצה על הקלט הריק‪.‬‬
‫במילים אחרות‪:‬‬
‫– מכונה מנצחת היא כזו שעבורה )‪ zero(M‬הוא הגדול ביותר‪.‬‬
‫• הגדרה‪ BB(n) :‬הוא מספר האפסים שכותבת מכונה מנצחת‬
‫בעלת ‪ n‬מצבים (ו‪.)qhalt -‬‬
‫• פורמלית‪:‬‬
‫‪BB : N  N‬‬
‫))‪BB(n) = MAX (zero(M‬‬
‫)‪M  R(n‬‬
‫‪27‬‬

‫ערכי ‪ BB‬עבור מספר ערכי ‪n‬‬

‫• )‪:BB(1‬‬
‫‪0‬‬ ‫‪B‬‬
‫‪qstart‬‬

‫• )‪:BB(2‬‬
‫‪0‬‬ ‫‪B‬‬
‫‪qstart‬‬
‫‪q‬‬
‫)‪6 :BB(3‬‬ ‫•‬
‫)‪13 :BB(4‬‬ ‫•‬
‫‪BB(5)  4098‬‬ ‫•‬
‫‪BB(6)  1018267‬‬ ‫•‬
‫מטרה‪ :‬להראות ש‪ BB -‬אינה ניתנת לחישוב‪ .‬כלומר‪:‬‬ ‫•‬
‫– לא קיימת מ"ט שעל קלט ‪ n‬בייצוג אונרי פולטת )‪ BB(n‬בייצוג אונרי‬
‫‪28‬‬

‫‪14‬‬
 ‫‪ BB‬מוגדרת היטב‬
‫• משפט‪ :‬הפונקציה ‪ BB‬מוגדרת היטב‪.‬‬
‫• כלומר עלינו להראות ש‪:‬‬
‫– לכל ‪ BB(n) ,n‬סופי‪.‬‬
‫• תזכורת‪:‬‬
‫))‪BB(n) = MAX (zero(M‬‬
‫)‪M  R(n‬‬
‫• נראה ש‪:‬‬
‫– )‪ R(n‬קבוצה סופית‬
‫– )‪ Zero(M‬הוא סופי לכל )‪M  R(n‬‬
‫• ונקבל‪:‬‬
‫– המקסימום בביטוי הוא על מספר סופי של ערכים סופיים ומכאן שהוא‬
‫סופי‪.‬‬
‫• )‪ R(n‬קבוצה סופית‪:‬‬
‫– על הלוח‪.‬‬
‫• )‪ Zero(M‬הוא סופי לכל )‪:M  R(n‬‬
‫– מספר האפסים ש‪ M -‬כותבת מוגבל ע"י מספר הצעדים שהוא סופי‪.‬‬
‫‪29‬‬

‫האם ניתן לחשב את ‪?BB‬‬

‫• תזכורת‪:‬‬
‫‪BB : N  N‬‬
‫))‪BB(n) = MAX (zero(M‬‬
‫)‪M  R(n‬‬

‫• האם ניתן לחשב את הפונקציה ‪?BB‬‬

‫• כלומר‪:‬‬
‫– האם קיימת מ"ט שעל קלט‬
‫• ‪ n‬בייצוג אונרי‬
‫– פולטת‬
‫• )‪ BB(n‬בייצוג אונרי‬
‫• הערה‪ :‬א"ב הקלט של מכונה כזו הוא‬
‫– }‪ = {0‬‬
‫‪30‬‬

‫‪15‬‬
 ‫‪ BB‬אינה ניתנת לחישוב‬
‫משפט‪ :‬לא קיימת מ"ט עם }‪  = {0‬שמקבלת כקלט‬ ‫•‬
‫את ‪ n‬בייצוג אונרי ומחשבת את )‪ BB(n‬בייצוג אונרי‪.‬‬
‫נוכיח עבור מכונות עם }‪ = {0, B‬‬ ‫•‬
‫נניח בשלילה שקיימת מכונה כזו‪ .‬נקרא לה ‪.MBB‬‬ ‫•‬
‫הסתירה תתקבל כך‪ :‬נראה שקיימים‬ ‫•‬
‫– מספר טבעי ‪N‬‬
‫– מ"ט )‪ M  R(N‬שבריצתה על הקלט הריק‪:‬‬
‫• כותבת יותר מ‪ BB(N) -‬אפסים‬

‫‪31‬‬

‫זהירות – יש מס' סוגי מכונות טיורינג בהוכחה‬

‫• ‪ MBB‬שהנחנו בשלילה שהיא קיימת‪:‬‬
‫– }‪  = {0‬ו‪ . = {0, B} -‬מה לגבי ‪... ?Q‬‬
‫– מה ‪ MBB‬עושה‪:‬‬
‫• על קלט ‪ n‬בייצוג אונרי מחשבת את )‪ BB(n‬בייצוג אונרי‪.‬‬
‫• ‪ M‬שאנחנו רוצים לבנות כדי להראות את הסתירה‪:‬‬
‫– }‪  = {0‬ו‪ . = {0, B} -‬מה לגבי ‪... ?Q‬‬
‫– מה ‪ M‬עושה‪:‬‬
‫• על קלט ריק כותבת יותר מ‪ BB(N) -‬אפסים ועוצרת‪.‬‬
‫• ויהיו עוד שתי מכונות שמחשבות דברים אחרים‪.‬‬

‫‪32‬‬

‫‪16‬‬
 ‫• לבנית ‪ M‬נשתמש בשלוש מ"ט (שבכולן }‪ = {0‬‬
‫ו‪:) = {0, B} -‬‬
‫– ‪MBB‬‬
‫• נסמן ב‪ n0 -‬את מספר המצבים של ‪( MBB‬מלבד ‪)qhalt‬‬
‫– ‪ M+‬שמחשבת עוקב למספר (קלט ופלט בייצוג אונרי)‪.‬‬
‫• מספר המצבים (מלבד ‪ )qhalt‬של ‪ M+‬הוא ‪3‬‬
‫– ‪ M*2‬שכופלת מספר ב‪( 2 -‬קלט ופלט בייצוג אונרי)‪.‬‬
‫• בתרגיל ‪ 1‬עליכם לבנות את ‪.M*2‬‬
‫• מספר המצבים (מלבד ‪ )qhalt‬של ‪ M*2‬הוא ‪( 10‬אפשר פחות)‬

‫‪33‬‬

‫הוכחה ‪ -‬המשך‬
‫• נקבע‪.)14 = 3 + 10 + 1( N = 2  (n0 + 14) :‬‬
‫• למשל‪ :‬אם ‪ n0 = 200‬אז ‪N = 428‬‬
‫• המטרה עכשיו‪:‬‬
‫– לבנות מכונה )‪ M  R(N‬שכותבת יותר מ‪ BB(N) -‬אפסים‪.‬‬
‫• ‪ M‬תעבוד כך‪:‬‬
‫– תכתוב על הסרט ‪ N/2‬אפסים ותעביר את הראש לתחילתם‪.‬‬
‫• איך נממש זאת? ‪...‬‬
‫– תפעיל את ‪ .M*2‬איך? ‪...‬‬
‫– תפעיל את ‪MBB‬‬
‫– תפעיל את ‪M+‬‬
‫• )‪:M  R(N‬‬
‫– א"ב קלט ועבודה‪... :‬‬
‫– עוצרת על הקלט הריק‪... :‬‬
‫– מספר המצבים (מלבד ‪...:)qhalt‬‬
‫• ‪ M‬כותבת יותר מ‪ BB(N) -‬אפסים‪... :‬‬
‫‪34‬‬

‫‪17‬‬
 ‫תרגיל‬
‫• מה מספר המצבים המינימלי הדרוש למ"ט (חד‬
‫סרטית) שבריצתה על הקלט הריק מחזירה כפלט את‬
‫המספר ‪ 100‬בייצוג אונרי (וכך שראש המכונה יהיה‬
‫בסוף הפעולה על התו הראשון בפלט)?‬
‫פחות מ‪100 -‬‬ ‫–‬
‫בין ‪ 100‬ל‪.200 -‬‬ ‫–‬
‫יותר מ‪ 200 -‬ופחות מ‪.1000 -‬‬ ‫–‬
‫לפחות ‪.1002‬‬ ‫–‬
‫לפחות ‪.2100‬‬ ‫–‬
‫אף אחת מהתשובות א'‪-‬ה'‪.‬‬ ‫–‬

‫‪35‬‬

‫תרגיל‬
‫• איך היינו צריכים לשנות את ההוכחה אם במקום‬
‫להשתמש במ"ט ‪ M*2‬היינו משתמשים במ"ט ‪M*3‬‬
‫שעל קלט ‪ n‬בייצוג אונרי מחשבת את ‪ 3n‬בייצוג‬
‫אונרי?‬

‫‪36‬‬

‫‪18‬‬
 ‫מה יקרה אם נשנה את הגדרת מ"ט?‬
‫נאפשר לראש להישאר במקום‪.‬‬ ‫•‬
‫‪ k‬סרטים במקום סרט אחד‪.‬‬ ‫•‬
‫סרט חד כווני‬ ‫•‬
‫מספר מצבים מקבלים ו‪/‬או דוחים‬ ‫•‬
‫נרצה להראות‪:‬‬ ‫•‬
‫– שקילות בין המודלים‪:‬‬
‫• כל שפה שניתנת להכרעה ע"י מודל אחד ניתנת להכרעה גם‬
‫ע"י המודל השני ולהפך‪.‬‬
‫• משאבי הזמן והמקום "דומים"‪.‬‬

‫‪37‬‬

‫דוגמה ‪ -‬מ"ט עם אפשרות השארות במקום (‪)Stay‬‬

‫• במ"ט סטנדרטית )‪ M = (Q, , , ‬כאשר‪:‬‬
‫‪ :Q‬קב' המצבים‬
‫‪ :‬א"ב קלט‬
‫‪ :‬א"ב עבודה‬
‫‪ :‬טבלת המעברים }‪ : Q   Q    {R, L‬‬
‫• במ"ט עם ‪ Stay‬ההבדל הוא‪:‬‬
‫}‪ : Q   Q    {R, L, S‬‬
‫• נראה שהמודלים שקולים‪ .‬כלומר נראה ש‪:‬‬
‫– קיימת ‪ M‬סטנדרטית שמכריעה שפה ‪ A‬אמ"מ קיימת ’‪ M‬עם‬
‫‪ Stay‬שמכריעה את ‪.A‬‬
‫– בנוסף נראה שמשאבי הזמן הזיכרון של ‪ M‬ו‪ M’ -‬הם מאותו סדר‬
‫גודל‪.‬‬
‫‪38‬‬

‫‪19‬‬
 ‫קיום מ"ט סטנדרטית ‪ ‬קיום מ"ט עם ‪Stay‬‬

‫• תהי ‪ M‬מ"ט סטנדרטית המכריעה שפה כלשהי‪.‬‬

‫• אז‪:‬‬
‫– ‪ M‬היא גם מ"ט עם ‪ Stay‬המכריעה את אותה שפה‪.‬‬
‫– משאבי הזמן והמקום כמובן אינם משתנים‪.‬‬

‫‪39‬‬

‫קיום מ"ט עם ‪  Stay‬קיום מ"ט סטנדרטית‬

‫• תהי ‪ M‬מ"ט עם ‪ Stay‬המכריעה שפה כלשהי‪.‬‬

‫• נבנה מ"ט סטנדרטית ’‪ M‬שמכריעה את אותה שפה‪.‬‬
‫• הרעיון‪:‬‬
‫– בכל מעבר ש‪ M -‬נשארת במקום‪ M’ ,‬תלך ימינה ושמאלה‪.‬‬
‫• הבניה ‪:‬‬
‫– נסמן )‪.M = (Q, , , ‬‬
‫– נבנה )’‪( M’ = (Q’, ’, ’, ‬על הלוח)‪.‬‬

‫‪40‬‬

‫‪20‬‬
 ‫• יעילות זמן‪:‬‬
‫– על כל צעד של ‪ M‬המכונה ’‪ M‬מבצעת לכל היותר‪:‬‬
‫• ‪ 2‬צעדים‪.‬‬
‫• יעילות מקום‪:‬‬
‫– ’‪ M‬כותבת בתא אחד יותר (ימינה) מ‪.M -‬‬
‫• סיכום‪ :‬תהי ‪ M‬מ"ט עם ‪ Stay‬המכריעה שפה‬
‫כלשהי‪ .‬אזי‪:‬‬
‫‪ .1‬קיימת מ"ט סטנדרטית ’‪ M‬המכריעה את אותה שפה‪.‬‬
‫‪ .2‬לכל ‪ x‬מתקיים‪:‬‬
‫))‪timeM’(x) = O(timeM(x‬‬ ‫•‬
‫))‪spaceM’(x) = O(spaceM(x‬‬ ‫•‬

‫‪41‬‬

‫מ"ט מרובת סרטים‬

‫• במ"ט סטנדרטית‪:‬‬
‫– סרט אחד‪.‬‬
‫– ראש אחד של המכונה המצביע על סרט זה‪.‬‬
‫– טבלת המעברים‪:‬‬
‫• }‪: Q   Q    {R, L‬‬
‫– בתחילת העבודה‪:‬‬
‫• הקלט על הסרט‪ ,‬הראש על התו הראשון של הקלט‪ ,‬מצב ‪. qstart‬‬
‫• במ"ט מרובת סרטים‪:‬‬
‫– מספר קבוע ‪ k‬של סרטים‪.‬‬
‫– ‪ k‬ראשים המצביעים כל אחד על אחד הסרטים‪.‬‬
‫– טבלת המעברים‪ : Q  k Q  k  {R,L}k :‬‬
‫בתחילת העבודה‪:‬‬ ‫•‬
‫הקלט על הסרט הראשון‪.‬‬ ‫–‬
‫הראש של סרט זה על התו הראשון של הקלט‪.‬‬ ‫–‬
‫שאר הסרטים ריקים ( ואין חשיבות למיקום הראש על סרטים אלו)‪.‬‬ ‫–‬
‫מצב ‪. qstart‬‬ ‫–‬
‫‪42‬‬

‫‪21‬‬
 ‫הגדרת יעילות הזמן והמקום עבור מ"ט רבת סרטים‬
‫• תזכורת – מ"ט סטנדרטית ‪:M‬‬
‫– )‪:timeM(x‬‬
‫• מספר הפעלות ‪ ‬בריצת ‪ M‬על ‪. x‬‬
‫– )‪:spaceM(x‬‬
‫• מספר התאים (השונים) ש‪ M -‬כותבת בהם בריצת ‪ M‬על ‪. x‬‬
‫• מ"ט רבת סרטים ‪:M‬‬
‫– )‪:timeM(x‬‬
‫• בדיוק כמו חד סרטית‪ :‬מספר הפעלות ‪ ‬בריצת ‪ M‬על ‪. x‬‬
‫– )‪:spaceM(x‬‬
‫‪ M‬כותבת על ‪ k‬סרטים‪.‬‬ ‫•‬
‫נסתכל בכל סרט על מספר התאים (השונים) ש‪ M -‬כותבת בו בריצת ‪M‬‬ ‫•‬
‫על ‪. x‬‬
‫נגדיר את )‪ spaceM(x‬כמספר המקסימלי מבין ‪ k‬המספרים‪.‬‬ ‫•‬
‫הערה‪:‬‬ ‫•‬
‫– היות ש‪ k -‬קבוע‪ ,‬ניתן באופן שקול (בסדר גודל) להגדיר את )‪ spaceM(x‬כסה"כ‬
‫התאים השונים ש‪ M -‬כותבת בהם בכל הסרטים‪.‬‬

‫‪43‬‬

‫שקילות בין המודלים‬

‫• הכוון הקל‪:‬‬
‫– תהי ‪ M‬מ"ט סטנדרטית המכריעה שפה כלשהי‪.‬‬
‫– אז לכל ‪:k‬‬
‫• קיימת מ"ט ’‪ M‬עם ‪ k‬סרטים שמכריעה את אותה שפה‪.‬‬
‫• סדר הגודל של משאבי הזמן והמקום אינו משתנה‪.‬‬
‫• הוכחה‪:‬‬
‫– ’‪ M‬תעבוד כמו ‪ M‬על הסרט הראשון ובאופן מנוון על‬
‫שאר הסרטים‪ .‬למשל‪:‬‬
‫• בכל מעבר נכתוב ‪ B‬בסרטים האחרים‪ ,‬ונלך לאותו כוון‬
‫שהולכים אליו בסרט הראשון‪.‬‬

‫‪44‬‬

‫‪22‬‬
 ‫הכוון המעניין – תיאור עילי‬
‫תהי ‪ M‬מ"ט עם ‪ k‬סרטים המכריעה שפה כלשהי‪.‬‬ ‫•‬
‫נבנה מ"ט סטנדרטית ’‪ M‬שמכריעה את אותה שפה‪.‬‬ ‫•‬
‫איך נייצג ב‪ M’ -‬את תוכן ‪ k‬הסרטים של ‪:M‬‬ ‫•‬
‫אפשרות א'‪:‬‬ ‫•‬
‫– סרט אחרי סרט (עם סימן הפרדה ביניהם)‪.‬‬
‫• אפשרות ב'‪:‬‬
‫– באופן מסורג‪:‬‬
‫• התו הראשון מכל סרט (סה"כ ‪ ,)k‬אח"כ התו השני מכל סרט‬
‫(סה"כ ‪ ,)k‬וכך הלאה‪.‬‬
‫– בייצוג זה אין צורך בסימן הפרדה‪.‬‬
‫• נבחר באפשרות ג' – בשקף הבא‪.‬‬
‫‪45‬‬

‫ייצוג תוכן סרטי ‪M‬‬

‫– נסתכל על ‪ k‬הסרטים כנמצאים אחד מתחת לשני‪.‬‬
‫• אות בא"ב של ’‪ M‬תכלול ‪-k‬יה של אותיות של ‪.M‬‬
‫• כלומר בינתיים‪M’ = (M)k :‬‬
‫– מה לגבי מיקום הראשים (נדרש גם בייצוגים האחרים)?‬
‫• נוסיף ‪ k‬דגלים ל‪ -‬א"ב‪.‬‬
‫• משמעות הדגל ה‪:i -‬‬
‫– האם הראש של הסרט ה‪ i -‬נמצא על התו ה‪ i -‬של ‪-k‬יה זו‪.‬‬
‫‪M’ = (M)k  {0, 1}k‬‬ ‫• כלומר עתה‪:‬‬

‫‪46‬‬

‫‪23‬‬
 ‫איך ’‪ M‬תדע איזה מעבר של ‪ M‬לבצע?‬
‫• מעבר ב‪ M -‬תלוי ב‪ k -‬תווים שהראשים של ‪ M‬נמצאים עליהם‪ .‬למשל ‪(q,‬‬
‫)‪bda) = (p, afc, RLL‬‬
‫• ‪" M‬רואה" ביחד את כל ‪ k‬התווים שהראשים שלה נמצאים עליהם‪.‬‬
‫• כדי לסמלץ מעבר אחד של ‪ ,M‬המכונה ’‪ M‬צריכה לדעת את ‪ k‬התווים האלו‪.‬‬
‫איך היא תעשה זאת‪:‬‬
‫– לפני ביצוע המעבר‪ M’ ,‬תסרוק את הסרט שלה משמאל לימין (סריקה ראשונה)‬
‫ותאסוף את התווים ש‪:‬‬
‫• הדגל שלהם הוא ‪. 1‬‬
‫• היכן נשמור את התווים האלו?‬
‫– במצב של ’‪. M‬‬
‫– לשם כך מצב ב‪ M’ -‬יכיל‪:‬‬
‫את המצב ב‪. M -‬‬ ‫•‬
‫את ‪ k‬התווים שהראשים מצביעים עליהם‪.‬‬ ‫•‬
‫נסמן ב‪  -‬תו שאיננו יודעים עדיין מהו‪.‬‬ ‫•‬
‫בנוסף נצטרך בהמשך את מספר הסריקה (מספר בין ‪ 1‬ל‪ ) 4 -‬ו‪ k -‬דגלים‪.‬‬ ‫•‬
‫‪QM’ = QM  (M  {})k  {1,2,3,4}  (0,1)k‬‬ ‫כלומר‬ ‫•‬
‫בתחילת הסריקה המצב ב‪ M’ -‬יכיל‪:‬‬ ‫•‬
‫‪‬‬ ‫*‬ ‫‪0‬‬
‫‪‬‬ ‫‪‬‬
‫‪q * 1 0‬‬
‫‪‬‬ ‫‪0 ‬‬
‫‪47‬‬ ‫‪‬‬ ‫*‬

‫דוגמאות‬
‫‪‬‬ ‫*‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪0‬‬ ‫‪‬‬ ‫*‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪0‬‬ ‫‪‬‬
‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬
‫‪  q * 1 0 , a2 0  ‬‬ ‫‪‬‬ ‫‪q‬‬ ‫*‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪,‬‬ ‫‪a‬‬ ‫‪2‬‬
‫‪0 , R‬‬
‫‪‬‬ ‫‪0 ‬‬ ‫‪‬‬ ‫‪‬‬
‫‪‬‬ ‫*‬ ‫‪0‬‬ ‫‪a3‬‬ ‫‪‬‬ ‫*‬ ‫‪0‬‬ ‫‪a3‬‬ ‫‪0‬‬ ‫‪‬‬

‫‪‬‬ ‫*‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪1‬‬ ‫‪‬‬ ‫‪a1‬‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪1‬‬ ‫‪‬‬
‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬
‫‪  q * 1 0 , a2 0  ‬‬ ‫‪ q * 1 0 , a2‬‬ ‫‪0 , R‬‬
‫‪‬‬ ‫‪1 ‬‬ ‫‪‬‬ ‫‪‬‬
‫‪‬‬ ‫*‬ ‫‪0‬‬ ‫‪a3‬‬ ‫‪‬‬ ‫‪a3‬‬ ‫‪0‬‬ ‫‪a3‬‬ ‫‪1‬‬ ‫‪‬‬

‫‪48‬‬

‫‪24‬‬
 ‫ביצוע המעבר‬
‫• ‪ M‬מבצעת את המעבר )‪ (q, bda) = (p, afc, RLL‬בצעד‬
‫אחד‪.‬‬
‫• איך ’‪ M‬תעשה זאת?‬
‫– תסרוק את הסרט מימין לשמאל (סריקה שניה) ותחליף‬
‫כל תו שהדגל שלו הוא ‪ 1‬בתו המתאים‪.‬‬
‫• איך ’‪ M‬תדע איזה תו לכתוב במקום תו קיים?‬
‫– האינפורמציה על המעבר הנדרש נמצאת במצב של ’‪. M‬‬
‫– תסרוק את הסרט משמאל לימין (סריקה שלישית) ותזיז‬
‫את הדגלים שצריכים לזוז ימינה‪.‬‬
‫– תסרוק את הסרט מימין לשמאל (סריקה רביעית) ותזיז‬
‫את הדגלים שצריכים לזוז שמאלה‪.‬‬
‫– תעבור למצב החדש עם כוכביות במקום התווים‪.‬‬
‫• כדי ליישם את הנ"ל נדרשות שתי התוספות שהזכרנו קודם‬
‫למצב של ’‪:M‬‬
‫• מספר בין ‪ 1‬ל‪ 4 -‬שיסמן ל‪ M’ -‬באיזו מהסריקות היא נמצאת עתה‪.‬‬
‫• ‪ {0, 1}k‬כדי לסמן ל‪ M’ -‬אם ועל איזה תו צריך לשים את הדגל החדש‬
‫בסריקות השלישית והרביעית‪.‬‬
‫‪49‬‬

‫דוגמאות‬
‫‪‬‬ ‫‪b1‬‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪0‬‬
‫‪‬‬ ‫‪‬‬
‫‪  q b2‬‬ ‫‪2 0 , a2‬‬ ‫‪1‬‬ ‫• איך נגדיר את ‪ ‬עבור המצב והתו הבאים‪:‬‬
‫‪‬‬ ‫‪0 ‬‬
‫‪‬‬ ‫‪b3‬‬ ‫‪0‬‬ ‫‪a3‬‬
‫‪b1 b2 b3‬‬ ‫והתו‬ ‫‪q‬‬ ‫• ‪ ‬במקרה זה תלוי במעבר ש‪ M -‬מבצעת על המצב‬
‫• נסתכל לכן על המעבר המתאים ב‪:M -‬‬
‫– )‪( (q, b1 b2 b3) = (p, c1 c2 c3, L R L‬ה‪ L R L -‬הוא כדוגמה)‬
‫• (נשים לב קודם לשוויון בין חלק מה‪a -‬ים לחלק מה‪ b -‬ים או ה‪ c -‬ים)‬
‫• והמעבר יהיה‬

‫‪‬‬ ‫‪b1‬‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪0‬‬ ‫‪‬‬ ‫‪b1‬‬ ‫‪0‬‬ ‫‪a1‬‬ ‫‪0‬‬ ‫‪‬‬
‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬
‫‪  q b2‬‬ ‫‪2 0 , a2‬‬ ‫‪1 ‬‬ ‫‪ q b2‬‬ ‫‪2 0 , c2‬‬ ‫‪1 , L‬‬
‫‪‬‬ ‫‪0 ‬‬ ‫‪‬‬ ‫‪‬‬
‫‪‬‬ ‫‪b3‬‬ ‫‪0‬‬ ‫‪a3‬‬ ‫‪‬‬ ‫‪b3‬‬ ‫‪0‬‬ ‫‪a3‬‬ ‫‪0‬‬ ‫‪‬‬

‫‪50‬‬

‫‪25‬‬
  b1 0 a1 1
 
  q b2 3 0 , a2 1 ‫• מה לגבי‬
 0 
 b3 0 a3
)‫ הוא (כמו קודם‬M -‫• כאשר המעבר המתאים ב‬
(q, b1 b2 b3) = (p, c1 c2 c3, L R L) –
)...‫ ים‬c ‫ ים או‬b -‫ ים ל‬a -‫• (ונשים לב לקשר בין ה‬
‫• והמעבר יהיה‬
 b1 0 a1 1 
 
  q b2 3 1 , a2 0 , R
 
 b3 0 a3 0 

51

 b1 1 a1 0
 
  q b2 4 0 , a2 0 ‫• ומה לגבי‬
 1 
 b3 0 a3
)‫ הוא (כמו קודם‬M -‫• כאשר המעבר המתאים ב‬
(q, b1 b2 b3) = (p, c1 c2 c3, L R L) –
)... ‫• (ושוב ישנו הקשר‬
‫• והמעבר יהיה‬

 b1 1 a1 0  b1 0 a1 1 
   
  q b 2 4 0 , a2 0    q b 2 4 0 , a2 0 , L 
 1   
 b3 0 a3  b3 1 a3 0 

52

26
 ‫יעילות‬
‫• מקום‪:‬‬
‫– השתמשנו במספר תאים כמו בסרט של ‪ M‬המשתמש‬
‫במספר הגדול ביותר של תאים‪ .‬לכן‪:‬‬
‫))‪spaceM’(x) = O(spaceM(x‬‬
‫• זמן‪:‬‬
‫– כדי לבצע מעבר אחד של ‪:M‬‬
‫• ’‪ M‬הלכה לאורך הסרט שלה הלוך ושוב מספר קבוע של פעמים‪.‬‬
‫– מיעילות המקום נסיק‪timeM’(x) = O(spaceM(x)  timeM(x)) :‬‬
‫– לעיתים נרצה להביע את )‪ timeM’(x‬רק כפונקציה‬
‫של )‪.timeM(x‬‬
‫– נשתמש בכך ש‪spaceM(x)  timeM(x) -‬‬
‫)‪timeM’(x) = O(timeM(x)2‬‬ ‫– ונקבל‬

‫‪53‬‬

‫שקילות בין גרסאות של מ"ט ‪ -‬סיכום‬

‫• נאמר ששני מודלים שקולים פולינומיאלית אם‪:‬‬
‫– כל שפה שניתן להכריע בזמן ))‪ O(t(n‬במודל אחד‪ ,‬ניתן להכריע‬
‫בזמן )‪( O(t(n)k‬עבור קבוע ‪ )k‬במודל השני ולהפך‪.‬‬
‫• ראינו‪:‬‬
‫– מ"ט סטנדרטית‪ ,‬מ"ט עם אפשרות השארות במקום ומ"ט‬
‫מרובת סרטים שקולות פולינומיאלית‪.‬‬
‫• ניתן להראות‪:‬‬
‫– מ"ט חצי אינסופית ומ"ט עם ‪ || = 2‬שקולים פולינומיאלית‬
‫למודלים הנ"ל‪.‬‬
‫– ויתרה מזאת‪:‬‬
‫• מ"ט שקולה פולינומיאלית לכל מודל חישובי סביר (כולל ‪Random‬‬
‫‪ Access Machine‬ושפות תכנות כמו ‪ C‬ו‪.)Java -‬‬

‫‪54‬‬

‫‪27‬‬
 ‫מכונת טיורינג אוניברסלית‬
‫• בחישוביות היו מקרים שהקלט לתוכנית (בשפת ‪ )while‬היה בעצמו‬
‫תוכנית (בשפת ‪.)while‬‬
‫• למשל‪:‬‬
‫– בעיית העצירה‪.‬‬
‫בדומה‪ ,‬הקלט למכונת טיורינג יכול להיות מכונת טיורינג‪.‬‬ ‫•‬
‫בחישוביות נעזרנו בקלטים שהם בעצמם תוכניות כדי להראות (בין‬ ‫•‬
‫היתר)‪:‬‬
‫– שיש שפות שלא ניתנות להכרעה‪.‬‬
‫בסיבוכיות נשתמש במ"ט שהם קלטים (בין היתר) כדי להוכיח משפטי‬ ‫•‬
‫היררכיה‪.‬‬
‫תוצאות לדוגמה ממשפטי ההיררכיה‪:‬‬ ‫•‬
‫– יש שפות שניתן להכריע בזמן )‪ O(n5‬אך לא בזמן )‪. O(n2‬‬
‫– ‪P  EXP‬‬
‫• נקרא למ"ט שמקבלת כקלט מ"ט ‪ M‬וקלט ‪ x‬ומריצה את ‪ M‬על ‪ – x‬מכונה‬
‫אוניברסלית‪.‬‬
‫• כדי שמ"ט ‪ M‬תוכל להופיע כקלט למ"ט‪ ,‬נצטרך לקודד את ‪ M‬כמחרוזת‪.‬‬

‫‪55‬‬

‫מכונת טיורינג אוניברסלית ‪MU‬‬

‫• מה עושה ‪:MU‬‬
‫– מקבלת כקלט קידוד ‪ M, x‬של מכונה ‪ M‬וקלט ‪.x‬‬
‫– מריצה את ‪ M‬על ‪( x‬בדומה ל‪.)Interpreter -‬‬
‫– מחזירה את התוצאה‪.‬‬
‫• נניח שהמכונה בקלט היא )‪.M = (QM, M, M, M‬‬
‫• מה אפשר לומר על הגודל של‪ ,‬למשל‪?M ,‬‬
‫– ‪ M‬אינו בגודל קבוע (ובדומה ‪ QM ,M‬ו‪ .)M -‬לכן‪:‬‬
‫• תווי ‪ M‬לא יופיעו כמו שהם על סרט של ‪.MU‬‬
‫• נשתמש בא"ב }; ‪ U = {0, 1,‬ובעזרתו נקודד כל מ"ט ‪.M‬‬

‫‪56‬‬

‫‪28‬‬
 ‫קידוד הקלט )‪ M‬ו‪)x -‬‬
‫• תהי )‪.M = (QM, M, M, M‬‬
‫• איך נקודד את התווים ב‪ M -‬ו‪? M -‬‬
‫– כמספרים |‪ 1, 2, …, |M‬בייצוג בינארי בעזרת ‪ log |M|‬ביטים‪.‬‬
‫– ‪ M‬חלקית ל‪ M -‬אז אין צורך לטפל בה‪.‬‬
‫• מה עם ‪? QM‬‬
‫– בדומה ‪ -‬כמספרים ‪( 0, 1, 2, …, |QM|– 1‬ונקבע ‪ 2 , 1 , 0‬הם ‪, qaccept , qstart‬‬
‫‪.) qreject‬‬
‫מה לגבי ‪?M‬‬ ‫•‬
‫– תזכורת‪ :‬מעבר ב‪ M -‬נראה כך‪(q, a) = (p, b, R/L) :‬‬
‫– נקודד מעבר כחמישית מספרים ‪( q a p b d‬לפי הקידוד של ‪ M‬ו‪QM -‬‬
‫ו‪ 0/1 -‬עבור ‪)R/L‬‬
‫• ומה עם ‪ M‬כולה‪:‬‬
‫– ‪( <M> = |QM|;|M|;|M|;M‬הגדלים בייצוג בינארי)‪.‬‬
‫• ומה לגבי ‪? x = x1x2…xn‬‬
‫– כל ‪ xi‬הוא תו ב‪( M -‬והחלטנו כבר על הקידוד)‪.‬‬
‫• קידוד הקלט >‪ <M, x‬כולו‪:‬‬
‫– >‪<M, x> = <M>;<x‬‬
‫‪57‬‬

‫איך נבנה את ‪?MU‬‬

‫• איך ‪ MU‬אמורה לפעול‪:‬‬
‫– ‪ MU‬תחקה את ריצת ‪ M‬על ‪.x‬‬
‫• נתאר את ‪ MU‬כמכונה רב סרטית ונשתמש בשקילות שהראנו כדי‬
‫להפוך אותה אח"כ למ"ט סטנדרטית‪.‬‬
‫• מה יהיה בסרטים של ‪?MU‬‬
‫– "סרט המכונה"‪:‬‬
‫• יכיל את הקלט >‪( <M, x‬בקידוד המוסכם)‪.‬‬
‫– "סרט העבודה"‪:‬‬
‫• ישמש לסימלוץ הסרט של ‪( M‬כל תו בקידוד המוסכם)‪.‬‬
‫– "סרט המצב"‪:‬‬
‫• ישמש להחזקת המצב הנוכחי של ‪( M‬בקידוד המוסכם)‪.‬‬
‫• איך ‪ MU‬תסמלץ את ראש המכונה של ‪?M‬‬
‫– הראש של ‪ MU‬יצביע על הביט הראשון של התו המוצבע ע"י ‪.M‬‬
‫• איך ‪ MU‬תחקה צעד של ‪?M‬‬
‫– תחפש בקידוד של ‪ M‬מעבר התלוי במצב ותו הנוכחיים ותבצע אותו‪.‬‬

‫‪58‬‬

‫‪29‬‬
 ‫אתחול‬
‫• מה צריך לאתחל‪:‬‬
‫– סרט העבודה‪:‬‬
‫• להעתיק אליו את ‪x‬‬
‫– סרט המצב‪:‬‬
‫• לכתוב בו ‪0‬‬
‫– מיקום הראשים‪:‬‬
‫• בתחילת הסרטים‬
‫• יעילות זמן‪:‬‬
‫– )|>‪( O(|<M,x‬ליניארי)‬
‫• יעילות מקום‪:‬‬
‫• )|>‪( O(|<M,x‬ליניארי)‬

‫‪59‬‬

‫סימלוץ צעד של ‪M‬‬

‫• חיפוש המעבר הרלוונטי ב‪:M -‬‬
‫– לכל מעבר ‪ q a p b d‬ב‪ M -‬נשווה את ‪ q‬ו‪ a -‬למצב ותו הנוכחיים‪.‬‬
‫• ביצוע מעבר ‪:q a p b d‬‬
‫– ‪ MU‬תכתוב ‪ p‬בסרט המצב‪ b ,‬בסרט העבודה‪ ,‬ותזיז את הראש בסרט‬
‫העבודה בהתאם ל‪. d -‬‬
‫– ובהתאם למצב החדש‪:‬‬
‫• אם ‪ p = 1‬אז ‪ MU‬תקבל‪.‬‬
‫• אם ‪ p = 2‬אז ‪ MU‬תדחה‪.‬‬
‫• אחרת ‪ MU‬תמשיך בסימולציה‪.‬‬
‫• יעילות זמן‪:‬‬
‫– סימולציה של צעד אחד‪:‬‬
‫• )|>‪O(|<M>| + log |QM| + log |M|) = O(|<M‬‬
‫– סה"כ הסימולציה (כולל האתחול)‪:‬‬
‫• )|>‪O(|<M>|  timeM(x) + |<M,x‬‬
‫– סה"כ הסימולציה בהנחה ש‪ M -‬רצה בזמן |>‪|<M,x‬לפחות‪:‬‬
‫• ))‪O(|<M>|  timeM(x‬‬
‫– ועבור מ"ט חד סרטית בהנחה ש‪ M -‬רצה בזמן |>‪|<M,x‬לפחות‪:‬‬
‫• )‪O(|<M>|2  timeM(x)2‬‬

‫‪60‬‬

‫‪30‬‬
 ‫• יעילות מקום‪:‬‬
‫– נחשב את המקום הנדרש בכל אחד מ‪ 3 -‬הסרטים‪:‬‬
‫• סרט המכונה‪:‬‬
‫– )|>‪O(|<M,x‬‬
‫• סרט העבודה‪:‬‬
‫– ))‪O(log |M|  spaceM(x‬‬
‫• סרט המצב‪:‬‬
‫– |‪log |QM‬‬
‫– סה"כ‪:‬‬
‫)|>‪O(log |M|  spaceM(x) + |<M,x‬‬ ‫•‬
‫– סה"כ בהנחה ש‪ M -‬משתמשת במקום |>‪|<M,x‬לפחות‪:‬‬
‫• ))‪O(log |M|  spaceM(x‬‬
‫– ועבור מ"ט חד סרטית בהנחה ש‪ M -‬רצה בזמן |>‪|<M,x‬לפחות‪:‬‬
‫• אותו הדבר‪.‬‬

‫‪61‬‬

‫סיכום‪ :‬קיום ויעילות של מ"ט אוניברסלית‬

‫• משפט‪ :‬קיימת מ"ט אוניברסלית חד סרטית ‪ MU‬עם א"ב‬
‫}; ‪ U = {0, 1,‬אשר על קלט >‪:<M, x‬‬
‫• אם ‪ M‬מקבלת את ‪ x‬אז‪:‬‬
‫– ‪ MU‬מקבלת את >‪<M, x‬‬
‫• אם ‪ M‬דוחה את ‪ x‬אז‪:‬‬
‫– ‪ MU‬דוחה את >‪<M, x‬‬
‫• אם ‪ M‬אינה עוצרת על ‪:x‬‬
‫– אז ‪ MU‬אינה עוצרת על >‪<M, x‬‬
‫• אם ‪ M‬עוצרת על ‪ x‬ורצה בזמן ומקום |>‪|<M,x‬לפחות אז‪:‬‬
‫) ‪timeM U ( M , x )  O(| M |2 timeM ( x) 2‬‬
‫))‪spaceM U ( M , x )  O(log | M | spaceM ( x‬‬

‫‪62‬‬

‫‪31‬‬
 ‫תרגיל‬
‫חשבו חסם עליון (נמוך ככל האפשר) על‬
‫))‪timeM ( M U , ( M , x‬‬
‫‪U‬‬

‫כאשר ‪ MU‬היא מ"ט אוניברסלית חד סרטית כפי‬

‫שהוצגה בכיתה‪.‬‬
‫החסם יוצג כפונקציה של הפרמטרים ‪ M ,MU‬ו‪ x -‬לפי‬
‫הצורך‪.‬‬

‫‪63‬‬

‫דוגמה לטיעון ליכסון‬

‫• נראה דוגמה לשפה (נקרא לה ‪ )K‬שאינה ניתנת‬
‫להכרעה‪.‬‬
‫• מטרות‪:‬‬
‫– השפה ‪ K‬דומה לשפה שנשתמש בה במשפטי‬
‫ההיררכיה‪.‬‬
‫– ההוכחה משתמשת בטיעון ליכסון דומה לטיעון‬
‫שנשתמש בו במשפטי ההיררכיה‪.‬‬

‫‪64‬‬

‫‪32‬‬
 ‫השפה }>‪ K = {<M> | M rejects <M‬אינה כריעה‬
‫• נניח בשלילה ש‪:‬‬
‫– קיימת מ"ט ‪ N‬שמכריעה את ‪.K‬‬
‫– אז לכל קלט >‪ ,<M‬המכונה ‪ N‬מקבלת או דוחה את >‪.<M‬‬
‫• נבדוק מה ‪ N‬עושה כאשר‪:‬‬
‫– ‪ N‬רצה על >‪.<N‬‬
‫• אם ‪ N‬מקבלת את >‪ <N‬אז‪:‬‬
‫– מההגדרה של הכרעת שפה ע"י מ"ט נקבל‪:‬‬
‫• ‪<N>  K‬‬
‫– מהגדרת השפה ‪ K‬נקבל‪:‬‬
‫• ‪<N>  K‬‬
‫– משמעות‪:‬‬
‫• לא ייתכן ש‪ N -‬מקבלת את >‪. <N‬‬
‫• באופן דומה נקבל ש‪:‬‬
‫– לא ייתכן ש‪ N -‬דוחה את >‪.<N‬‬
‫• כלומר‪:‬‬
‫– קיבלנו קלט ש‪ N -‬לא מקבלת ולא דוחה אותו‪ .‬סתירה‪.‬‬
‫‪65‬‬

‫מחלקות סיבוכיות‬
‫• נרצה לחלק שפות למחלקות בהתאם למשאבים‬
‫הנדרשים בכדי לפתור אותן‪.‬‬
‫• המשאבים שראינו‪:‬‬
‫– זמן‬
‫– מקום‬

‫‪66‬‬

‫‪33‬‬
 ‫מחלקות סיבוכיות בסיסיות‬
‫• תהא ‪ f : N  N‬פונקציה‪.‬‬
‫• הגדרה‪ DTime(f) :‬היא מחלקת השפות שניתן להכריען ע"י‬
‫מ"ט סטנדרטית בזמן ))‪.O(f(n‬‬
‫• דוגמה‪ :‬מה המשמעות ש‪?A  DTime(n2) -‬‬
‫‪ .1‬הכרעה‪:‬‬
‫קיימת מ"ט סטנדרטית ‪ M‬שמכריעה את ‪ . A‬כלומר‪:‬‬ ‫•‬
‫אם ‪ x  A‬אז ‪ M‬מקבלת את ‪ . x‬אם ‪ x  A‬אז ‪ M‬דוחה את ‪. x‬‬ ‫–‬
‫‪ .2‬יעילות‪:‬‬
‫• קיים קבוע ‪ c‬כך שלכל *‪: x  ‬‬
‫‪timeM(x) ≤ c  |x|2‬‬
‫• דוגמה לשפה ב‪:DTime(n2) -‬‬
‫– ‪PAL‬‬
‫• הגדרה‪ DSpace(f) :‬היא‬
‫– מחלקת השפות שניתן להכריען ע"י מ"ט סטנדרטית במקום‬
‫))‪.O(f(n‬‬

‫‪67‬‬

‫תכונות המחלקות הבסיסיות‬

‫• יהיו ‪ g‬ו‪ f -‬פונקציות‪.‬‬
‫• מה ניתן לומר על הקשר בין )‪ DTime(g‬ל‪ DTime(f) -‬אם‪:‬‬
‫– )‪?g = O(f‬‬
‫• )‪DTime(g)  DTime(f‬‬
‫– )‪?g = (f‬‬
‫• )‪DTime(g) = DTime(f‬‬
‫• בדומה לגבי )‪ DSpace(g‬ו‪.DSpace(f) -‬‬
‫• נקשור עתה בין מחלקות מקום וזמן‪.‬‬
‫• נשתמש בכך שמכונה ‪ M‬שרצה על קלט ‪ x‬מקיימת‪:‬‬
‫– )‪spaceM(x)  timeM(x‬‬
‫))‪time M (x)  2O(spaceM (x‬‬ ‫– אם ‪ M‬עוצרת על ‪ x‬אז‬
‫• תוצאות‪:‬‬
‫)‪DTime(f)  DSpace(f‬‬
‫))‪DSpace(f)  DTime(2O(f‬‬
‫‪68‬‬

‫‪34‬‬
 ‫סיכום‬
‫‪ .1‬אם )‪ g = O(f‬אז‪:‬‬
‫– )‪ DTime(g)  DTime(f‬ו‪DSpace(g)  DSpace(f) -‬‬
‫‪ .2‬אם )‪ g = (f‬אז‪:‬‬
‫– )‪ DTime(g) = DTime(f‬ו‪DSpace(g) = DSpace(f) -‬‬
‫‪DTime(f)  DSpace(f) .3‬‬
‫‪DSpace(f)  DTime(2O(f)) .4‬‬

‫‪69‬‬

‫משפטי ההיררכיה‬
‫ראינו שאם )‪ g = O(f‬אז )‪DSpace(g)  DSpace(f‬‬ ‫•‬
‫מה קורה אם ‪ g‬קטנה מ‪ f -‬בסדר גודל?‬ ‫•‬
‫)‪g ( n‬‬
‫פורמלית )‪ . g = o(f‬כלומר ‪ 0‬‬ ‫•‬
‫‪n ‬‬
‫)‪f ( n‬‬
‫למשל‪:‬‬ ‫•‬
‫– ‪ g(n) = n3‬ו‪-‬‬
‫– ‪.f(n) = n4‬‬
‫• נראה שאז‪:1‬‬
‫‪( DSpace(g)  DSpace(f) .1‬משפט ההיררכיה במקום)‬
‫• בדוגמה‪:‬‬
‫– )‪DSpace(n3)  DSpace(n4‬‬
‫‪( DTime(g)  DTime(f2) .2‬משפט ההיררכיה בזמן)‬
‫• בדוגמה‪:‬‬
‫– )‪DTime(n3)  DTime(n8‬‬
‫• הוכחות של משפטי ההיררכיה משתמשות במ"ט‬
‫אוניברסלית ובטיעוני ליכסון‪.‬‬
‫‪70‬‬ ‫‪1‬הערה‪ "" :‬מייצג הכלה ממש‬

‫‪35‬‬
 ‫משפט ההיררכיה במקום‬
‫• ניסוח לא מדויק של המשפט‪:‬‬
‫אם )‪ g = o(f‬אזי )‪DSpace(g)  DSpace(f‬‬
‫• אבחנה‪ :‬הכלה חלשה נובעת מכך ש‪:‬‬
‫)‪ g = o(f‬גורר )‪g = O(f‬‬ ‫•‬
‫• מה עוד צריך להראות‪:‬‬
‫– שקיימת שפה ‪ Sf‬כך ש‪:‬‬
‫‪Sf  DSpace(f) .1‬‬
‫‪Sf  DSpace(g) .2‬‬
‫– נוכיח את ‪ 1‬ע"י‪:‬‬
‫• בניית מ"ט‪.‬‬
‫– נוכיח את ‪ 2‬ע"י‪:‬‬
‫• בדומה להוכחה ש‪ K -‬אינה כריעה‪.‬‬

‫‪71‬‬

‫איך נגדיר את ‪?Sf‬‬

‫• נתחיל מהגדרה זהה לשפה ‪:K‬‬
‫}>‪Sf = {<M> | M rejects <M‬‬
‫• מה הבעיה בהגדרה זו‪:‬‬
‫– ‪ Sf‬אינה כריעה ולכן )‪Sf  DSpace(f‬‬
‫• מה חסר בהגדרת ‪?sf‬‬
‫– יעילות המקום של ‪ .M‬ננסה שוב‪:‬‬
‫})|>‪Sf = {<M> | M rejects <M>, spaceM(<M>)  f(|<M‬‬ ‫•‬
‫• מדוע (אינטואיטיבית) ))‪?Sf  DSpace(g(n‬‬
‫– )‪ g = o(f‬ולכן מ"ט שמשתמשת ב‪ O(g(n)) -‬מקום לא תוכל לסמלץ מ"ט‬
‫שרצה במקום )‪.f(n‬‬
‫• מה תהיה הדרך להראות ש‪?Sf  DSpace(f(n)) -‬‬
‫– בעזרת מ"ט אוניברסלית ‪.MU‬‬
‫– אבל תהיה לנו בעיה עם יעילות המקום‪ .‬כי‪:‬‬
‫• על כל תא ש‪ M -‬משתמשת בו‪ MU ,‬צריכה )|‪ O(log |M‬תאים‪.‬‬
‫– אז מה נעשה?‬
‫• נקטין את חסם המקום בהגדרת ‪.Sf‬‬
‫‪‬‬ ‫‪f (| M |) ‬‬
‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬
‫‪72‬‬

‫‪36‬‬
 ‫)‪Sf  DSpace(g‬‬
‫‪‬‬ ‫‪f (| M |) ‬‬
‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬
‫• נניח בשלילה ש‪:‬‬
‫– קיימת מ"ט ‪ N‬שרצה במקום ))‪ O(g(n‬ומכריעה את ‪.Sf‬‬
‫– אז לכל קלט >‪ ,<M‬המכונה ‪ N‬מקבלת או דוחה את >‪.<M‬‬
‫• הערה‪ :‬נשים לב שניתן להניח ש‪ |<N>| -‬גדול כרצוננו‪ .‬מדוע?‬
‫– ניתן למשל להוסיף ל‪ N -‬מצבים שלא עושים כלום‪.‬‬

‫• נבדוק מה ‪ N‬עושה כאשר היא רצה על >‪.<N‬‬

‫– אם ‪ N‬מקבלת את >‪ <N‬אז‪:‬‬
‫• מההגדרה של הכרעת שפה ע"י מ"ט נקבל‪:‬‬
‫– ‪<N>  Sf‬‬
‫• מהגדרת השפה ‪ Sf‬נקבל‪:‬‬
‫– ‪<N>  Sf‬‬
‫• משמעות‪:‬‬
‫– לא ייתכן ש‪ N -‬מקבלת את >‪.<N‬‬

‫‪73‬‬

‫‪‬‬ ‫‪f (| M |) ‬‬

‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬
‫אם ‪ N‬דוחה את >‪ <N‬אז‪:‬‬
‫– מההגדרה של הכרעת שפה ע"י מ"ט נקבל‪:‬‬
‫• ‪<N>  Sf‬‬
‫– מהגדרת השפה ‪ Sf‬נקבל ש‪ <N>  Sf -‬אם‪:‬‬
‫)|‪f (| N ‬‬
‫‪spaceN ( N ) ‬‬
‫| ‪log | N‬‬
‫– נראה בשקף הבא שזה מתקיים עבור |>‪ |<N‬מספיק גדול‪.‬‬
‫– ונקבל‪:‬‬
‫• לא ייתכן ש‪ N -‬דוחה את >‪ <N‬כי אחרת כפי שראינו לעיל‪,‬‬
‫– ‪ <N>  Sf‬וגם‬
‫– ‪.<N>  Sf‬‬

‫• אבל גם לא ייתכן ש‪ N -‬מקבלת את >‪( <N‬מהשקף הקודם)‪.‬‬

‫• סתירה והמשפט הוכח‪.‬‬
‫‪74‬‬

‫‪37‬‬
 ‫)|‪f (| N ‬‬
‫‪spaceN ( N ) ‬‬ ‫טענה‪ :‬עבור |<‪ |>N‬מספיק גדול‬
‫| ‪log | N‬‬
‫הוכחה‪:‬‬
‫– מהעובדה ש‪ N -‬רצה במקום ))‪ O(g(n‬נובע שקיים‬
‫קבוע ‪ c‬כך ש‪spaceN ( N )  c  g (| N |) :‬‬

‫– מהעובדה ש‪ g = o(f) -‬נובע שעבור |<‪ |>N‬מספיק גדול‪:‬‬

‫)|‪f (| N ‬‬ ‫)|‪g (| N ‬‬ ‫‪1‬‬
‫‪c  g (| N |) ‬‬ ‫‪‬‬
‫| ‪log | N‬‬ ‫| ‪f (| N |) c  log | N‬‬

‫– הטענה נובעת משילוב אי השוויון הראשון והאחרון לעיל‪.‬‬

‫‪75‬‬

‫)‪ – Sf  DSpace(f‬תיאור עילי‬

‫‪‬‬ ‫‪f (| M |) ‬‬
‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬
‫• מה צריכה לעשות מ"ט ‪ MU‬כדי להכריע את ‪?Sf‬‬
‫‪ .1‬לוודא ש‪ M -‬דוחה את >‪ .<M‬איך?‬
‫‪ MU‬תריץ את ‪ M‬על >‪ <M‬בדומה למ"ט אוניברסלית‪.‬‬ ‫•‬
‫נשתמש במ"ט רב סרטית ונמיר אותה בסוף לחד סרטית‪.‬‬ ‫•‬
‫אבל עלולה להיות בעיה‪:‬‬ ‫•‬
‫אם ‪ M‬לא עוצרת על >‪ <M‬אז גם ‪ MU‬לא תעצור‪ .‬נטפל בכך בסעיף ‪.3‬‬ ‫–‬
‫‪ .2‬לוודא ש‪ M -‬עומדת בדרישות המקום‪ .‬איך?‬
‫‪ MU‬תשתמש במונה מקום‪.‬‬ ‫•‬
‫‪ .3‬איך ‪ MU‬תטפל בבעיית העצירה של ‪?M‬‬
‫‪ MU‬תשתמש במונה זמן בעזרת החסם ))‪time M (x)  2O(spaceM (x‬‬ ‫•‬
‫עבור מ"ט ‪ M‬שעוצרת על קלט ‪.x‬‬
‫‪ .4‬איפה נשים את שני המונים?‬
‫כל אחד על סרט משלו‪.‬‬ ‫•‬
‫‪76‬‬

‫‪38‬‬
 ‫ישימות במקום‬
‫‪‬‬ ‫‪f (| M |) ‬‬
‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬
‫• במהלך הכרעת ‪ ,Sf‬המכונה ‪ MU‬צריכה לחשב את )‪f(n‬‬
‫(כאשר |>‪ n = |<M‬הוא אורך הקלט)‪ .‬נדרש עבור‪:‬‬
‫– מוני הזמן והמקום‪.‬‬
‫• אם המשאבים הנדרשים לחישוב ‪ f‬יהיו גדולים מדי אז‪:‬‬
‫– ‪ MU‬עלולה לא לעמוד בדרישות היעילות שלה‪.‬‬
‫• לכן נגביל את משפט ההיררכיה במקום לפונקציות ישימות‬
‫במקום‪.‬‬
‫• הגדרה‪ :‬פונקציה ‪ h : N  N‬היא ישימה במקום אם קיימת מ"ט‬
‫אשר על קלט ‪ n‬בייצוג אונרי‪:‬‬
‫‪ ‬מחשבת את )‪ h(n‬בקידוד אונרי‪.‬‬
‫‪ ‬משתמשת ב‪ O(h(n)) -‬מקום‪.‬‬
‫כלומר‪:‬‬ ‫•‬
‫על קלט ‪ ,0n‬המכונה צריכה לחשב )‪ 0h(n‬תוך שימוש ב‪ O(h(n)) -‬תאים‪.‬‬ ‫•‬
‫• כל הפונקציות "הרגילות" (כמו ‪ )2n ,n2 ,n‬הן ישימות במקום‪ .‬ראו‬
‫תרגיל ‪.2‬‬
‫‪77‬‬

‫משפט ההיררכיה במקום – ניסוח מלא‬

‫משפט‪:‬‬
‫– תהא ‪ f‬פונקציה ישימה במקום וכך ש‪.f(n)  n -‬‬
‫– תהא ‪ g‬פונקציה המקיימת )‪.g = o(f‬‬
‫– אזי‪:‬‬
‫• )‪. DSpace(g)  DSpace(f‬‬

‫הוכחה‪:‬‬
‫• ראינו כבר‪:‬‬
‫– )‪Sf  DSpace(g‬‬
‫– תיאור עילי של ההוכחה ש‪Sf  DSpace(f) -‬‬
‫• נשאר לראות‪:‬‬
‫– תיאור מפורט של ההוכחה ש‪Sf  DSpace(f) -‬‬

‫‪78‬‬

‫‪39‬‬
 ‫)‪ – Sf  DSpace(f‬תיאור מפורט‬
‫‪‬‬ ‫‪f (| M |) ‬‬
‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬ ‫•‬
‫‪‬‬ ‫‪log | M | ‬‬
‫)|‪f (| M ‬‬
‫| ‪log | M‬‬ ‫• מונה מקום יאותחל ל‪-‬‬
‫• מתי ואיך נעדכן אותו?‬
‫– בכל פעם ש‪ M -‬כותבת לתא חדש‪ MU ,‬תחסיר ‪ 1‬ממונה המקום‪.‬‬
‫)| ‪f (|  M ‬‬
‫‪cM ‬‬ ‫• מונה זמן יאותחל ל‪-‬‬
‫| ‪log|M‬‬
‫‪2‬‬
‫‪ CM‬הוא הקבוע מהחסם ))‪.timeM (x)  2O(space (x‬‬
‫‪M‬‬

‫במקרה שלנו ‪ cM‬אינו קבוע אך מתקיים )|‪.cM = O(log |M‬‬

‫• איך נעדכן את מונה הזמן?‬
‫– על כל צעד של ‪ MU , M‬תחסיר ‪ 1‬ממונה הזמן‪.‬‬

‫‪79‬‬

‫‪‬‬ ‫‪f (| M |) ‬‬

‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬

‫מה ‪ MU‬תעשה אם אחד המונים ירד מתחת לאפס?‬ ‫•‬

‫מונה מקום‪:‬‬ ‫•‬
‫‪ MU‬תדחה (כי ‪ M‬משתמשת ביותר מקום מהמותר)‪.‬‬ ‫–‬
‫מונה זמן‪:‬‬ ‫•‬
‫‪ MU‬תדחה (כי ‪ M‬אינה עוצרת ולכן אינה דוחה את >‪.)<M‬‬ ‫–‬
‫אחרת יש שתי אפשרויות‪:‬‬ ‫•‬
‫במהלך הרצת ‪ M‬על >‪ <M‬המכונה ‪ M‬תעצור ותקבל את >‪ .<M‬אז‪:‬‬ ‫‪.1‬‬
‫‪ MU‬תדחה את >‪.<M‬‬ ‫–‬
‫במהלך הרצת ‪ M‬על >‪ <M‬המכונה ‪ M‬תעצור ותדחה את >‪ .<M‬אז‪:‬‬ ‫‪.2‬‬
‫‪ MU‬תקבל את >‪.<M‬‬ ‫–‬
‫מכאן ‪ MU‬מכריעה את ‪.Sf‬‬ ‫•‬
‫מה נשאר לוודא?‬ ‫•‬
‫ש‪ MU -‬רצה במקום ()‪.O(f(n‬‬ ‫•‬

‫‪80‬‬

‫‪40‬‬
 ‫יעילות המקום‬
‫‪‬‬ ‫‪f (| M |) ‬‬
‫‪S f   M  | M rejects  M , spaceM ( M ) ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪log | M | ‬‬
‫נסמן |>‪n = |<M‬‬ ‫•‬
‫נראה שיעילות המקום של ‪ MU‬היא ))‪.O(f(n‬‬ ‫•‬
‫נתחיל בניתוח המקום על הסרטים הרגילים וננתח אח"כ‬ ‫•‬
‫את המקום הנדרש עבור מוני הזמן והמקום‪.‬‬
‫ניזכר לשם כך ביעילות המקום של מ"ט אוניברסלית‪:‬‬ ‫•‬
‫)|‪spaceM ( M , x )  O(log | M | spaceM ( x) | M , x ‬‬
‫‪U‬‬

‫)|‪f (| M ‬‬

‫| ‪log | M‬‬
‫• אצלנו ‪ x‬הוא >‪ <M‬ולא נחרוג בסימלוץ ‪ M‬ממקום‬
‫• לכן המקום הנדרש הוא‬
‫)|‪f (| M ‬‬
‫‪O(log | M | ‬‬
‫| ‪log | M‬‬
‫‪ | M |) ‬‬ ‫)‪O ( f ( n)  n‬‬
‫• והיעילות של ))‪ O(f(n‬מתקבלת מההנחה‬
‫– ‪f(n)  n‬‬
‫‪81‬‬

‫יעילות המקום של מוני הזמן והמקום‬

‫• נראה (על הלוח) שהמקום הנדרש הוא‪:‬‬
‫– ))‪.O(f(n‬‬
‫• שאלה‪:‬‬
‫– ומה לגבי העובדה שהשתמשנו במ"ט רבת סרטים?‬
‫• תשובה‪:‬‬
‫– סימולציה של מ"ט רבת סרטים ע"י מ"ט סטנדרטית‬
‫דורשת אותו סדר גודל של מקום‪.‬‬

‫‪82‬‬

‫‪41‬‬
 ‫ניסוח (בלבד) של משפט ההיררכיה בזמן‬
‫משפט‪:‬‬
‫• תהא ‪ f‬פונקציה ישימה בזמן וכך ש‪.f(n)  n -‬‬
‫• תהא ‪ g‬פונקציה המקיימת )‪.g = o(f‬‬
‫• אזי‪:‬‬
‫– )‪.DTime(g)  DTime(f2‬‬

‫הגדרה‪:‬‬
‫• פונקציה ‪ f‬היא ישימה בזמן אם‪:‬‬
‫– קיימת מ"ט רבת סרטים אשר מחשבת את ‪ f‬בקידוד אונרי‬
‫בזמן )‪ .O(f‬כלומר‪ ,‬על קלט ‪ 0n‬היא פולטת )‪ 0f(n‬ורצה בזמן‬
‫))‪.O(f(n‬‬

‫‪83‬‬

‫מחלקות סיבוכיות דטרמיניסטיות גסות‬

‫) ‪P   DTime(n c‬‬ ‫• מחלקת זמן פולינומיאלי‬
‫‪c 1‬‬

‫) ‪PSPACE   DSpace(n c‬‬ ‫• מחלקת מקום פולינומיאלי‬

‫‪c 1‬‬

‫) ‪EXP   DTime(2 n‬‬

‫‪c‬‬
‫• מחלקת זמן אקספוננציאלי‬
‫‪c 1‬‬

‫) ‪EXPSPACE   DSpace(2 n‬‬

‫‪c‬‬

‫• מחלקת מקום אקספוננציאלי‬

‫‪c 1‬‬

‫• ומתקיימות ההכלות החלשות הבאות‪:‬‬

‫– ‪P  PSPACE  EXP  EXPSPACE‬‬
‫• מה לגבי הכלות חזקות?‬
‫– בשקף הבא‪.‬‬
‫‪84‬‬

‫‪42‬‬
 ‫תרגיל‪( P  EXP :‬הכלה ממש)‬
‫• על הלוח‪:‬‬
‫– הוכחה שגויה (מצאו את השגיאה)‪... :‬‬
‫– הוכחה נכונה‪... :‬‬
‫• באופן דומה ניתן להראות‪:‬‬
‫– ‪PSPACE  EXPSPACE‬‬

‫‪85‬‬

‫מחלקות סיבוכיות אי דטרמיניסטיות‬

‫• במ"ט סטנדרטית הגדרנו }‪ . : Q    Q    {L, R‬כלומר‪:‬‬
‫– במצב ‪ q‬כשהראש על ‪ , a‬המכונה מבצעת את המעבר המוגדר ב‪.  -‬‬
‫• מכונה כזאת נקראת מ"ט דטרמיניסטית כי‪:‬‬
‫– פעולת המכונה נקבעת לחלוטין )היא ‪ )determined‬בהינתן קלט ‪. x‬‬
‫• איך נגדיר מ"ט אי דטרמיניסטית?‬
‫– במ"ט אי דטרמיניסטית (מטא"ד) עשויים להיות מספר מעברים אפשריים‬
‫כאשר המכונה במצב ‪ q‬והראש על ‪. a‬‬
‫– למשל ייתכן שיש במטא"ד ‪ M‬מעבר )‪ (q, a) = (p, b, R‬וגם )‪. (q, a) = (p’, b’, L‬‬
‫• אז מה ‪ M‬תעשה אם היא תהיה במצב ‪ q‬עם הראש על ‪? a‬‬
‫– ‪ M‬תבצע את אחד מהמעברים האפשריים‪.‬‬
‫• הבחירה איזה מעבר לבצע נקראת בחירה אי דטרמיניסטית של ‪.M‬‬
‫• רשימת כל הבחירות במהלך הריצה של ‪ M‬על ‪ x‬נקראת תסריט ריצה‬
‫של ‪ M‬על ‪.x‬‬
‫• הערה‪ :‬מ"ט דטרמיניסטית היא מקרה פרטי של מטא"ד‪:‬‬
‫– לכל ‪ q  Q‬ו‪ a   -‬מתקיים ‪|(q, a)| ≤ 1‬‬

‫‪86‬‬

‫‪43‬‬
 ‫הכרעת שפה ע"י מטא"ד‬
‫• מטא"ד )‪ M = (Q, , , ‬מכריעה שפה *‪ A  ‬אם‬
‫מתקיימים ‪ 3‬התנאים הבאים‪:‬‬
‫‪ .1‬לכל *‪ x  ‬המכונה ‪ M‬עוצרת בכל תסריט ריצה על הקלט ‪.x‬‬
‫‪ .2‬אם ‪ :x  A‬אז קיים תסריט ריצה מקבל של ‪ M‬על ‪.x‬‬
‫‪ .3‬אם ‪ :x  A‬אז לא קיים תסריט ריצה מקבל של ‪ M‬על ‪.x‬‬
‫(כלומר בכל תסריט ריצה ‪ M‬דוחה את ‪.)x‬‬
‫• הערה‪ :‬ניתן להחליף את ‪ 2‬ו‪ 3 -‬בתנאי יחיד‪:‬‬
‫– ‪ x  A‬אמ"מ קיים תסריט ריצה מקבל של ‪ M‬על ‪.x‬‬

‫‪87‬‬

‫דיון‬
‫• האם מ"ט דטרמיניסטית היא מודל חישובי פרקטי?‬
‫– כן‪ ,‬מדמה תוכנית בשפת מחשב‪.‬‬
‫• האם מטא"ד היא מודל חישובי פרקטי?‬
‫– לא‪ ,‬אין דרך פרקטית לנחש נכון את המעבר הנכון כשיש מספר‬
‫אופציות‪ .‬זהו מודל תיאורטי בלבד‪.‬‬
‫• אז למה צריך מכונות אי דטרמיניסטיות?‬
‫– השפות והמחלקות שניתן להגדיר בעזרתן מענינות‪.‬‬

‫‪88‬‬

‫‪44‬‬
 ‫השפה ‪SAT‬‬
‫• משתנה בוליאני‪:‬‬
‫– משתנה שערכו אמת )‪ (T‬או שקר )‪.(F‬‬
‫• ליטרל‪:‬‬
‫– משתנה (למשל ‪ )x2‬או שלילתו ( ‪.)x2‬‬
‫• פסוקית (הסגר) בצורת ‪:CNF‬‬
‫– אוסף ליטרלים עם כמתי "או" (‪ )‬ביניהם‪ .‬למשל ) ‪( x2  x1  x3‬‬
‫• נוסחה בצורת ‪:CNF‬‬
‫– פסוקיות ‪ CNF‬שביניהם כמתי "וגם" (‪ .)‬למשל‬
‫) ‪( x1  x2  x3 )  ( x1  x3 )  ( x1  x2  x3‬‬
‫• נוסחה בצורת ‪:kCNF‬‬
‫– נוסחה בצורת ‪ CNF‬שבכל פסוקית בה יש לכל היותר ‪ k‬ליטרלים‪.‬‬

‫‪89‬‬

‫• השמה‪:‬‬
‫– התאמה של ערך ‪ T‬או ‪ F‬לכל משתנה‪)x1, x2, x3) = (T, F, T) .‬‬
‫• השמה מספקת‪:‬‬
‫– השמה שהצבתה למשתני הנוסחה נותנת ערך ‪ T‬לנוסחה‪.‬‬
‫– למשל )‪ )x1, x2, x3) = (T, F, T‬בנוסחה ) ‪( x1  x2  x3 )  ( x1  x3 )  ( x1  x2  x3‬‬
‫– השמה לנוסחה בצורת ‪ CNF‬היא מספקת אמ"מ‬
‫• יש ערך ‪ T‬לליטרל אחד לפחות בכל פסוקית‪.‬‬
‫• נוסחה ספיקה‪:‬‬
‫– נוסחה שקיימת לה השמה מספקת‪.‬‬
‫• השפה ‪:SAT‬‬
‫}‪SAT = { |  is a satisfiable formula in CNF form‬‬
‫• השפה ‪:kSAT‬‬
‫}‪kSAT = { |  is a satisfiable formula in kCNF form‬‬

‫‪90‬‬

‫‪45‬‬
 ‫"ניחוש" במטא"ד‬
‫• כשנרצה להכריע שפה במטא"ד‪ ,‬בד"כ ננצל את אי‬
‫הדטרמיניסטיות לביצוע ניחושים‪.‬‬
‫• הניחוש יהיה לרוב הפתרון לגרסת החיפוש של הבעיה‪.‬‬
‫• למשל‪ ,‬כדי להכריע את ‪ SAT‬המכונה תנחש‪:‬‬
‫– השמה לכל אחד מהמשתנים‪.‬‬
‫• איך מיישמים ניחוש במטא"ד?‬
‫• נראה לדוגמה מטא"ד דו סרטית שמקבלת קלט }‪x  {0, 1‬‬
‫*‬
‫באורך ‪ ,n‬ומנחשת לסרט השני ‪ n‬ביטים‪.‬‬
‫= ))‪(qstart, (0, B‬‬ ‫))‪(qstart, (0, 0), (R, R‬‬ ‫‪.1‬‬
‫= ))‪(qstart, (0, B‬‬ ‫))‪(qstart, (0, 1), (R, R‬‬ ‫‪.2‬‬
‫= ))‪(qstart, (1, B‬‬ ‫))‪(qstart, (1, 0), (R, R‬‬ ‫‪.3‬‬
‫= ))‪(qstart, (1, B‬‬ ‫))‪(qstart, (1, 1), (R, R‬‬ ‫‪.4‬‬
‫= ))‪(qstart, (B, B‬‬ ‫))‪(q1, (B, B), (L, L‬‬ ‫‪.5‬‬
‫בד"כ נסתפק בתיאור עילי‪ .‬למשל‪:‬‬ ‫•‬
‫"המכונה מנחשת ‪ n‬ביטים (כאשר ‪ n‬הוא אורך הקלט)"‪.‬‬ ‫–‬
‫אז מדוע שלא פשוט ננחש האם הקלט בשפה?‬ ‫•‬
‫המכונה עלולה לענות "כן" על קלט שאינו בשפה וזה לא בסדר‪.‬‬ ‫–‬
‫‪91‬‬

‫הכרעת ‪ SAT‬ע"י מטא"ד‬

‫• נבנה מטא"ד ‪ M‬שמכריעה את ‪.SAT‬‬
‫• הקלט ל‪:M -‬‬
‫– נוסחה ‪ ‬בצורת ‪.CNF‬‬
‫• ‪ M‬תבצע‪:‬‬
‫‪ .1‬ניחוש‪:‬‬
‫‪ M‬תנחש השמה למשתני ‪( ‬למשל סדרת ‪ 0‬ים ו‪ 1 -‬ים באורך מספר המשתנים)‬
‫ותכתוב אותה על סרט העבודה (או על סרט נוסף)‪.‬‬
‫‪ .2‬בדיקה‪:‬‬
‫‪ M‬תציב את ההשמה ב‪  -‬ותבדוק האם היא מספקת‪.‬‬ ‫‪.1‬‬
‫אם כן‪:‬‬ ‫‪.2‬‬
‫‪ M‬תקבל את ‪.‬‬
‫אחרת‪:‬‬ ‫‪.3‬‬
‫‪ M‬תדחה את ‪.‬‬

‫‪92‬‬

‫‪46‬‬
 ‫• טענה‪ M :‬מכריעה את ‪.SAT‬‬
‫• הוכחה‪:‬‬
‫– אם ‪:  SAT‬‬
‫• אז קיימת השמה מספקת ל‪. -‬‬
‫• בתסריט הריצה שבו ‪ M‬תנחש השמה כזו‪:‬‬
‫– ‪ M‬תקבל את ‪.‬‬
‫– אם ‪:  SAT‬‬
‫• אז לא קיימת השמה מספקת ל‪. -‬‬
‫• לכן בכל תסריט ריצה הניחוש של ‪:M‬‬
‫– לא יהיה השמה מספקת‪.‬‬
‫• לכן בכל תסריט ריצה ‪ M‬תדחה את ‪.‬‬

‫‪93‬‬

‫יעילות מטא"ד‬
‫• תהי ‪ M‬מטא"ד ו‪ x -‬קלט‪.‬‬
‫• )‪:timeM(x‬‬
‫– מספר הצעדים המירבי בריצת ‪ M‬על ‪ x‬על פני כל‬
‫תסריטי הריצה האפשריים‪.‬‬
‫• )‪:spaceM(x‬‬
‫– מספר התאים המרבי אליהם הגיע ראש המכונה‬
‫בריצת ‪ M‬על ‪ x‬על פני כל תסריטי הריצה האפשריים‪.‬‬

‫‪94‬‬

‫‪47‬‬
 ‫קשר בין זמן ומקום עבור מטא"ד‬
‫• טענה‪ :‬אם מטא"ד ‪ M‬עוצרת על קלט ‪ x‬בכל תסריט‬
‫ריצה אז‪:‬‬
‫)‪spaceM(x)  timeM(x‬‬ ‫–‬
‫))‪time M (x)  2O(spaceM (x‬‬ ‫–‬
‫• כלומר בדיוק כמו עבור מ"ט דטרמיניסטית‪.‬‬
‫• הוכחה‪:‬‬
‫– ההוכחה זהה למקרה של מ"ט דטרמיניסטית‪:‬‬
‫• ספירת מספר הקונפיגורציות‪.‬‬
‫– מדוע מטא"ד שעוצרת אינה יכולה לחזור על קונפיגורציה?‬
‫• כי אחרת יהיה לה תסריט ריצה אינסופי‪.‬‬

‫‪95‬‬

‫יעילות המכונה שמכריעה את ‪SAT‬‬

‫• נסמן |>‪.n = |<‬‬
‫• ניחוש ההשמה‪:‬‬
‫– )‪ O(n‬כי מספר המשתנים הוא )‪O(n‬‬
‫• הצבה ובדיקה‪:‬‬
‫– לכל משתנה‪:‬‬
‫• הצבת ערכו בנוסחה וסימון הפסוקיות שהוא מספק – )‪( O(n‬עם‬
‫מטא"ד רבת סרטים)‪.‬‬
‫– סה"כ לכל המשתנים‪:‬‬
‫• )‪.O(n2‬‬
‫• ובמ"ט סטנדרטית‪:‬‬
‫– )‪ O(n4‬כלומר פולינומיאלי‪.‬‬
‫• מה לגבי מקום?‬
‫‪96‬‬ ‫– פולינומיאלי כי מקום לא עולה על הזמן‪.‬‬

‫‪48‬‬
 ‫מחלקות סיבוכיות א"ד בסיסיות‬
‫• תהה ‪ f : N  N‬פונקציה‪.‬‬
‫• הגדרה ‪:NTime(f) -‬‬
‫– מחלקת השפות שניתן להכריע ע"י מטא"ד (סטנדרטית)‬
‫בזמן ))‪.O(f(n‬‬
‫– כלומר שפה ‪ A  ‬מקיימת )‪ A  NTime(f‬אמ"מ‪:‬‬
‫*‬

‫‪ .1‬קיימת מטא"ד ‪ M‬שמכריעה את ‪.A‬‬

‫‪ .2‬לכל *‪ x  ‬מתקיים ש‪.timeM(x) = O(f(|x|) -‬‬
‫• מה ראינו לגבי ‪:SAT‬‬
‫‪SAT ‬‬ ‫)‪NTime(nc‬‬ ‫– קיים קבוע ‪ c‬כך ש‪-‬‬
‫• הגדרה ‪:NSpace(f) -‬‬
‫– מחלקת השפות שניתן להכריע ע"י מטא"ד (סטנדרטית)‬
‫במקום ))‪.O(f(n‬‬
‫‪97‬‬

‫תכונות‬
‫• לכל ‪ f‬מתקיים‪:‬‬
‫– )‪ DTime(f)  NTime(f‬ו‪DSpace(f)  NSpace(f) -‬‬
‫• אם ‪ f‬ו‪ g -‬מקיימות )‪ g = O(f‬אז‪:‬‬
‫– )‪ NTime(g)  NTime(f‬ו‪NSpace(g)  NSpace(f) -‬‬
‫• אם ‪ f‬ו‪ g -‬מקיימות )‪ g = (f‬אז‪:‬‬
‫– )‪ NTime(g) = NTime(f‬ו‪NSpace(g) = NSpace(f) -‬‬
‫• לכל ‪ f‬מתקיים‪:‬‬
‫– )‪NTime(f)  NSpace(f‬‬
‫– ))‪NSpace(f)  NTime(2O(f‬‬
‫‪98‬‬

‫‪49‬‬
 ‫מחלקות סיבוכיות א"ד גסות‬
‫= ‪NP‬‬ ‫) ‪ NTime(n‬‬
‫‪c 1‬‬
‫‪c‬‬
‫• מחלקת זמן‬
‫פולינומיאלי אי דטרמיניסטי‬

‫= ‪NPSPACE‬‬ ‫) ‪ NSpace(n‬‬
‫‪c 1‬‬
‫‪c‬‬
‫• מחלקת מקום‬
‫פולינומיאלי אי דטרמיניסטי‬
‫‪nc‬‬
‫= ‪NEXP‬‬ ‫‪ NTime(2‬‬
‫‪c 1‬‬
‫)‬ ‫• מחלקת זמן‬
‫אקספוננציאלי אי דטרמיניסטי‬
‫‪nc‬‬
‫= ‪NEXPSPACE‬‬ ‫‪ NSpace(2‬‬ ‫)‬ ‫• מחלקת מקום‬
‫‪c 1‬‬ ‫אקספוננציאלי אי דטרמיניסטי‬

‫• ומתקיימות ההכלות החלשות הבאות‪:‬‬

‫– ‪P  NP  PSPACE  NPSPACE  EXP  NEXP  EXPSPACE  NEXPSPACE‬‬

‫• אבל הראנו‪ P  EXP :‬ולכן‪:‬‬

‫– לפחות אחת מ‪ 3 -‬ההכלות החלשות הראשונות היא הכלה חזקה‪.‬‬
‫‪99‬‬

‫השאלה ‪P = NP‬‬
‫• טענה‪.SAT  NP :‬‬
‫• הוכחה‪:‬‬
‫– ראינו קודם מטא"ד המכריעה את ‪ SAT‬בזמן פולינומיאלי‪.‬‬
‫• מה לגבי אלגוריתם דטרמיניסטי?‬
‫– לא ידוע אלגוריתם דטרמיניסטי המכריע את ‪ SAT‬בזמן‬
‫פולינומיאלי‪.‬‬
‫– אך גם אין הוכחה שאלגוריתם כזה לא קיים‪.‬‬
‫• נראה בהמשך ש‪ SAT -‬היא חלק מקבוצת שפות גדולה‬
‫עם התכונות הבאות‪:‬‬
‫– כל השפות בקבוצה זו שייכות ל‪.NP -‬‬
‫– אם יתברר שאחת השפות בקבוצה שייכת ל‪ P -‬אז ‪.P = NP‬‬
‫‪100‬‬

‫‪50‬‬
 ‫הגדרה אלטרנטיבית ל‪NP -‬‬
‫• הגדרנו את ‪ NP‬תוך שימוש ב‪:‬‬
‫– מ"ט אי‪-‬דטרמיניסטיות‬
‫• נראה הגדרה אלטרנטיבית ל‪ NP -‬המשתמשת ב‪:‬‬
‫– מ"ט דטרמיניסטית‪.‬‬
‫– עד לכל קלט בשפה‪.‬‬
‫• וכמובן נוכיח ש‪:‬‬
‫– ההגדרות שקולות‪.‬‬
‫• לעיתים ההגדרה האלטרנטיבית נוחה יותר לשימוש‪.‬‬
‫‪101‬‬

‫של ‪NP‬‬ ‫הגדרה מקורית‬

‫‪ NP‬היא מחלקת השפות *‪ A  ‬עבורן קיימת‪:‬‬

‫– מ"ט אי‪-‬דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬

‫וכך שלכל *‪ x  ‬מתקיים‪:‬‬
‫‪ x  A‬אמ"מ קיים תסריט ריצה מקבל של ‪ M‬על ‪.x‬‬

‫‪102‬‬

‫‪51‬‬
 ‫הגדרה אלטרנטיבית של ‪NP‬‬

‫‪ NP‬היא מחלקת השפות *‪ A  ‬עבורן קיימים‪:‬‬

‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪ x  ‬מתקיים‪:‬‬
‫‪ x  A‬אמ"מ קיים )|‪ w  {0, 1}p(|x‬כך ש‪M(x, w) = True -‬‬
‫הערות‪:‬‬
‫‪ w‬נקרא עד לשייכות של ‪ x‬לשפה ‪.A‬‬
‫‪ w‬הוא לרוב פתרון לגרסת החיפוש הטבעית של ‪ .A‬ואז ‪ M‬היא‪:‬‬
‫‪103‬‬ ‫מ"ט שמקבלת קלט ‪ x‬ופתרון ‪ w‬ומוודאת את נכונות הפתרון‪.‬‬

‫שקילות ההגדרות‪ :‬אלטרנטיבית ‪ ‬מקורית‬

‫• על הלוח ‪...‬‬

‫‪104‬‬

‫‪52‬‬
 ‫שקילות ההגדרות‪ :‬מקורית ‪ ‬אלטרנטיבית‬
‫• תהי ‪ A  NP‬לפי ההגדרה המקורית‪.‬‬
‫עבור קבוע ‪.k‬‬ ‫‪nk‬‬ ‫• קיימת מטא"ד ‪ M‬המכריעה את ‪ A‬בזמן ‪‬‬
‫• נראה‪:‬‬
‫– מ"ט דטרמיניסטית ’‪ M‬ופולינום ‪ p‬כך ש‪ x  A -‬אמ"מ‬
‫קיים )|‪ w  {0, 1}p(|x‬כך ש‪. M’(x, w) = True -‬‬
‫• מי יהיה העד ‪ w‬עבור ‪? x  A‬‬
‫– העד יהיה תסריט ריצה מקבל של ‪ M‬על ‪. x‬‬
‫• איך נייצג תסריט ריצה בעזרת מחרוזת מ‪?{0, 1} -‬‬
‫– אפשר לייצג מעבר של ‪( M‬למשל) ע"י מספר בין ‪ 1‬ל‪. |M| -‬‬
‫– מספר כזה אפשר לייצג ע"י |‪ log|M‬ביטים‪.‬‬
‫– אפשר לכן לייצג תסריט ריצה של ‪ M‬על ‪ x‬ע"י (נסמן |‪:)n = |x‬‬
‫• ‪ log|M|  nk‬ביטים‪.‬‬
‫• אז מי יהיו ’‪ M‬ו‪:p -‬‬
‫– ’‪: M‬‬
‫• ’‪ M‬תרוץ על קלט ‪ x‬בדומה ל‪ M -‬אך בכל מעבר אי‪-‬דטרמיניסטי של ‪ M’ , M‬תבדוק‬
‫אם המעבר המתאים ב‪ w -‬הוא אחד המעברים האי‪-‬דטרמיניסטיים האפשריים‪.‬‬
‫• אם כן – ’‪ M‬תבצע את המעבר‪ .‬אם לא – ’‪ M‬תדחה את ‪. x‬‬
‫– ‪:p‬‬
‫• ‪p(n) = log|M|  nk‬‬
‫‪105‬‬

‫טיעוני ריפוד‬
‫ניזכר בשפה ‪: SAT‬‬ ‫•‬
‫}‪SAT = { |  is a satisfiable formula in CNF form‬‬
‫האלגוריתם הבא מכריע אותה‪:‬‬ ‫•‬
‫– על קלט ‪ , ‬נבדוק עבור כל השמה אפשרית האם היא מספקת‪.‬‬
‫יעילות‪:‬‬ ‫•‬
‫– )|‪. O(||  2|‬‬
‫– נסמן |‪ n = |‬ונקבל )‪( O(n  2n‬כלומר אקספוננציאלי באורך הקלט)‪.‬‬
‫מה לגבי אלגוריתם פולינומיאלי?‬ ‫•‬
‫– יש כזה אמ"מ ‪( P = NP‬נוכיח זאת בהמשך)‪.‬‬
‫|‪|‬‬ ‫נרפד את ‪: SAT‬‬ ‫•‬
‫} ‪SAT '  { #0 2 |   SAT‬‬
‫אלגוריתם להכרעת ’‪: SAT‬‬ ‫•‬
‫אותו אלגוריתם ובנוסף צריך לוודא שמספר האפסים הוא |‪. 2|‬‬ ‫–‬
‫יעילות‪:‬‬ ‫•‬
‫– אותה יעילות של )|‪ . O(||  2|‬ובנוסף יעילות חישוב |‪. 2|‬‬
‫– חישוב |‪ 2|‬ניתן להיעשות ב‪( O(22||) -‬כי הפונקציה ‪ 2n‬ישימה בזמן)‪.‬‬
‫– סה"כ )|‪. O(22|‬‬
‫|‪|‬‬
‫אז גם כאן היעילות אקספוננציאלית?‬ ‫•‬
‫| ‪n = |  #0 2‬‬ ‫כדי לבדוק זאת נחשב את היעילות כפונקציה של אורך הקלט‬ ‫•‬
‫ונקבל יעילות של‬ ‫•‬
‫– )‪ - O(n2‬פולינומיאלי‪.‬‬

‫מסקנה‪ :‬ריפוד הקלט עשוי לשפר מהותית את יעילות האלגוריתם (כפונקציה של אורך הקלט)‪.‬‬
‫‪106‬‬

‫‪53‬‬
 ‫שימוש בטיעוני ריפוד (‪)padding‬‬
‫• יהיו ’‪ D, E, D’, E‬מחלקות כך ש‪ -‬כך ש‪ D  D’ -‬ו‪.E  E’ -‬‬
‫• דוגמה‪ P  EXP :‬ו‪.NP  NEXP -‬‬
‫• טיעוני ריפודי מאפשרים לנו לעיתים להסיק שאם ‪ D  E‬אז‬
‫– ’‪.D’  E‬‬
‫• דוגמה‪ :‬נראה להלן שאם ‪ NP  P‬אז ‪.NEXP  EXP‬‬
‫• הרעיון הכללי‪:‬‬
‫‪Apad  D‬‬ ‫‪Apad  E‬‬
‫על קלט ‪ x‬ניצור‬
‫= ‪Apad‬‬ ‫)|‪{x#0f(|x‬‬ ‫}‪| x  A‬‬ ‫)|‪ x#0f(|x‬ונשתמש‬
‫ב‪.Apad  E -‬‬
‫’‪A  D‬‬ ‫’‪A  E‬‬
‫‪107‬‬

‫דוגמאות לטיעוני ריפוד‬

‫• משפט‪ :‬אם ‪ EXP  NEXP‬אזי ‪.P  NP‬‬
‫• הוכחה‪ :‬מספיק להראות‬
‫‪NEXP  EXP  NP  P‬‬

‫‪108‬‬

‫‪54‬‬
 ‫‪NEXP  EXP  NP  P‬‬
‫‪Apad  NP‬‬ ‫‪Apad  P‬‬
‫על קלט ‪ x‬ניצור‬
‫}‪Apad = {x#0f(|x|) | x  A‬‬ ‫)|‪ x#0f(|x‬ונשתמש‬
‫ב‪.Apad  P -‬‬
‫‪A  NEXP‬‬ ‫‪A  EXP‬‬
‫‪k‬‬
‫• תהי ‪ MA‬מטא"ד המכריעה את ‪ A‬בזמן ‪2 n‬‬
‫(לכל היותר)‪ .‬כלומר‪ ,‬על קלט ‪ x‬זמן הריצה |‪2| x‬‬
‫‪k‬‬

‫• מה עכשיו? יש להגדיר ‪ Apad‬ולבנות מטא"ד ’‪ M‬שמכריעה אותה‪.‬‬

‫• החלק העיקרי בעבודת ’‪ M‬הוא‪ :‬להריץ את ‪ MA‬על ‪.x‬‬
‫• איך נגדיר את ‪ Apad‬כך שחלק זה ייקח זמן פולינומיאלי‬
‫‪| x|k‬‬
‫באורך הקלט?}‪Apad  {x #02 | x  A‬‬
‫‪109‬‬

‫‪Apad  NP‬‬ ‫‪Apad  P‬‬

‫על קלט ‪ x‬ניצור‬ ‫‪| x|k‬‬
‫‪ x #0‬ונשתמש‬
‫‪k‬‬ ‫‪2‬‬
‫‪Apad  {x#0‬‬ ‫|‪2|x‬‬
‫}‪| x  A‬‬
‫ב‪.Apad  P -‬‬
‫‪A  NEXP‬‬ ‫‪A  EXP‬‬
‫‪Apad‬‬ ‫• בנית ’‪ M‬שמכריעה את‬
‫‪ M’ .1‬תבדוק שהקלט הוא מהצורה הנכונה‪ .‬אחרת תדחה‪.‬‬
‫‪ M’ .2‬תריץ את ‪ MA‬על ‪ x‬ותענה כמוה‪.‬‬
‫• נכונות‪... :‬‬
‫‪| x|k‬‬

‫‪n = | x#02‬‬ ‫|‬ ‫• יעילות‪ :‬נסמן‬

‫‪ 2‬ישימה בזמן‪ .‬וכפונקציה של ‪... :n‬‬ ‫‪ (2| x| ) 2 .1‬מכיוון ש‪-‬‬
‫‪k‬‬
‫‪| x|k‬‬

‫‪| x|k‬‬
‫‪110‬‬
‫‪ 2‬וכפונקציה של ‪... :n‬‬ ‫‪.2‬‬

‫‪55‬‬
 ‫‪Apad  NP‬‬ ‫‪Apad  P‬‬
‫על קלט ‪ x‬ניצור‬ ‫‪| x|k‬‬

‫‪Apad  {x#0‬‬
‫‪|x|k‬‬
‫‪2‬‬
‫}‪| x  A‬‬ ‫‪ x #0 2‬ונשתמש‬
‫ב‪.Apad  P -‬‬
‫‪A  NEXP‬‬ ‫‪A  EXP‬‬
‫• מ‪ Apad  P -‬נסיק כי‪:‬‬
‫‪.nc‬‬ ‫– קיימת מ"ט דטרמיניסטית ’’‪ M‬המכריעה את ‪ Apad‬בזמן‬
‫• נבנה‪:‬‬
‫– מ"ט דטרמיניסטית ‪ M‬המכריעה את ‪ A‬בזמן אקספוננציאלי‪.‬‬
‫– על קלט ‪ x‬המכונה ‪:M‬‬
‫‪k‬‬

‫‪ .1‬תייצר את המחרוזת ‪x #02‬‬

‫|‪|x‬‬

‫‪ .2‬תריץ את ’’‪ M‬על מחרוזת זו ותענה כמוה‪.‬‬

‫• נכונות‪... :‬‬
‫‪111‬‬
‫• יעילות‪... :‬‬

‫תרגילי ריפוד נוספים‬

‫טענה‪ :‬אם )‪ DSpace(n3)  DTime(n5‬אז‬
‫)‪DSpace(n6)  DTime(n10‬‬
‫טענה‪ :‬אם ‪ DSpace(n3)  P‬אז‬
‫‪DSpace(n6)  P‬‬

‫‪112‬‬

‫‪56‬‬
 ‫רדוקציות‪ ,‬קושי ושלמות‬
‫• רדוקציה משפה ‪ A  *A‬לשפה ‪ B  *B‬היא‬
‫פונקציה ‪ f : *A  *B‬המקיימת‪:‬‬
‫‪A‬‬ ‫‪B‬‬ ‫– ‪ x  A‬אמ"מ ‪f(x)  B‬‬

‫‪x‬‬ ‫)‪f(x‬‬

‫’‪x‬‬ ‫(’‪f)x‬‬

‫• רדוקציה פולינומיאלית היא רדוקציה הניתנת לחישוב‬

‫על ידי מ"ט בזמן פולינומיאלי‪ .‬סימון‪A P B :‬‬
‫‪113‬‬

‫דוגמאות‬
‫• יהיה }‪.)A = {0, 1}( A = {00, 101‬‬
‫• נכון‪ ,‬לא נכון או שקול לבעיה פתוחה‪:‬‬
‫– ‪... :A P PAL‬‬
‫– ‪... :PAL P A‬‬
‫• ומה אם ‪ A‬היתה שפה טריוויאלית (שפה שהיא ריקה או‬
‫מכילה את כל המחרוזות ב‪ -‬א"ב)? ‪...‬‬
‫– ‪... :PAL P SAT‬‬
‫– ‪... :SAT P PAL‬‬

‫‪114‬‬

‫‪57‬‬
 ‫תכונות‬
‫‪A P B‬‬ ‫• ‪A P B‬‬
‫• הוכחה‪... :‬‬

‫‪115‬‬

‫טרנזיטיביות של רדוקציות פולינומיאליות‬

‫• משפט‪ :‬אם ‪ A P B‬ו‪ B P C -‬אז ‪A P C‬‬
‫• הוכחה‪ :‬יהיו‬
‫– ‪ f‬רדוקציה פול' מ‪ A -‬ל‪ Mf .B -‬מממשת את ‪ f‬בזמן ‪.n‬‬
‫‪k‬‬

‫– ‪ g‬רדוקציה פול' מ‪ B -‬ל‪ Mg .C -‬מממשת את ‪ g‬בזמן ’‪.nk‬‬

‫– נבנה מ"ט ‪ M‬שמממשת רדוקציה‬
‫‪A‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫פולינומית מ‪ A -‬ל‪.C -‬‬
‫– על קלט ‪ M ,x‬תבצע‪:‬‬
‫• תריץ את ‪ Mf‬על ‪. x‬‬
‫‪x‬‬ ‫‪Mf‬‬ ‫))‪f(x) Mg g(f(x‬‬
‫• תריץ את ‪ Mg‬על הפלט‪.‬‬
‫‪|x|=n‬‬ ‫‪time  nk‬‬ ‫’‪time  nkk‬‬
‫‪|f(x)| nk‬‬ ‫– יעילות‪ :‬נראה בעזרת הציור‪.‬‬
‫’‪x‬‬ ‫(’‪f)x‬‬ ‫((’‪g)f)x‬‬ ‫– נכונות‪ :‬להשלים‪.‬‬

‫‪116‬‬

‫‪58‬‬
 ‫סגירות לרדוקציות פולינומיאליות‬
‫• מחלקה ‪ D‬סגורה לרדוקציות פולינומיאליות אם‪:‬‬
‫– לכל שתי שפות ‪ A‬ו‪ B -‬המקיימות ‪ B  D‬ו‪A P B -‬‬
‫מתקיים ‪.A  D‬‬
‫• האם המחלקות הגסות שראינו (‪ PSPACE ,NP ,P‬ו‪-‬‬
‫‪ )EXP‬סגורות לרדוקציות פולינומיאליות?‬
‫– תשובה‪ :‬כן‬
‫• נוכיח עבור ‪...EXP‬‬

‫‪117‬‬

‫רדוקציות בין ‪ SAT‬ו‪3SAT -‬‬

‫• טענה‪ SAT P 3SAT :‬וגם ‪3SAT P SAT‬‬
‫• הוכחה‪:‬‬
‫– ‪... :3SAT P SAT‬‬
‫– ‪:SAT P 3SAT‬‬
‫• תהיה ‪ ‬הנוסחה בקלט‪ .‬נבנה ’‪ ‬בצורת ‪ 3CNF‬כך‪:‬‬
‫– ‪’ = ‬‬
‫– כל עוד קיימת ב‪ ' -‬פסוקית עם יותר מ‪ 3 -‬ליטרלים‪:‬‬
‫» תהיה )‪ t = (t1  t2  …  tk‬פסוקית כזו‪.‬‬
‫» נוסיף לנוסחה משתנה חדש ‪ z‬ונשתמש בו כך‪:‬‬
‫• נחליף את ‪ t‬ב‪(t1  t2  z )  (t3  ...  tk  z ) -‬‬
‫– נחזיר את '‪.‬‬
‫• נכונות‪... :‬‬
‫• יעילות‪... :‬‬
‫‪118‬‬

‫‪59‬‬
 ‫קושי ושלמות למחלקה‬
‫• תהה ‪ D‬מחלקת סיבוכיות‪.‬‬
‫• הגדרות‪:‬‬
‫– שפה ‪ A‬היא ‪–D‬קשה או קשה ל‪( D -‬תחת רדוקציות‬
‫פולינומיאליות) אם‪:‬‬
‫• לכל ‪ B  D‬מתקיים ‪.B P A‬‬
‫– שפה ‪ A‬היא ‪ –D‬שלמה (או שלמה ב‪ )D -‬אם‪:‬‬
‫• ‪ A‬היא ‪–D‬קשה ו‪.A  D -‬‬
‫• משפט קוק‪-‬לוין‪:‬‬
‫– ‪ SAT‬היא ‪-NP‬קשה‪.‬‬
‫• הוכחה‪:‬‬
‫– בשבוע הבא‪.‬‬
‫• תוצאה‪:‬‬
‫– ‪ SAT‬היא ‪-NP‬שלמה‪.‬‬
‫‪119‬‬

‫תכונות חשובות‬
‫טענה ‪ :1‬אם ‪ A‬היא ‪–D‬קשה ו‪ A P B -‬אז ‪ B‬היא ‪–D‬קשה‪.‬‬ ‫•‬
‫תוצאה‪ 3SAT :‬היא ‪-NP‬קשה (ולכן גם ‪-NP‬שלמה)‪.‬‬ ‫•‬
‫טענה ‪ :2‬אם ‪ A  E‬היא ‪–D‬קשה ו‪ E -‬סגורה לרדוקציות‬ ‫•‬
‫פולינומיאליות אז ‪.D  E‬‬
‫תוצאות‪:‬‬ ‫•‬
‫‪ .1‬אם איזושהי שפה ‪-NP‬קשה היא ב‪ P -‬אז ‪.P = NP‬‬
‫‪ SAT  P .2‬אמ"מ ‪P = NP‬‬
‫‪ .3‬אם שפה ‪ A‬היא ‪-EXP‬קשה אז ‪A  P‬‬

‫‪120‬‬

‫‪60‬‬
 ‫בעיית החתך המקסימלי (‪)Max-Cut‬‬
‫• חתך בגרף לא מכוון )‪ G = (V, E‬הוא‪:‬‬
‫– חלוקה של ‪ V‬לשתי קבוצות זרות )‪.(S, V – S‬‬
‫• גודל חתך הוא מספר הקשתות ‪(u, v)  E‬‬
‫כך ש‪:‬‬
‫– ‪ u  S‬ו‪. v  V – S -‬‬
‫• השפה ‪:Max-Cut‬‬
‫} ‪ G‬גרף לא מכוון המכיל חתך שגודלו לפחות ‪(G, k) | k‬‬
‫• נראה‪:‬‬
‫– ‪ Max-Cut‬היא ‪-NP‬שלמה‪.‬‬
‫• מה לגבי השפה ‪?Min-Cut‬‬
‫} ‪ G‬גרף לא מכוון המכיל חתך שגודלו לכל היותר ‪{(G, k) | k‬‬
‫• את ‪ Min-Cut‬ניתן להכריע בזמן פולינומיאלי בעזרת‬
‫אלגוריתם ל‪( Max-Flow -‬נוותר על הפרטים)‪.‬‬
‫‪121‬‬

‫‪ Max-Cut‬היא ‪-NP‬שלמה‬
‫• ‪... :Max-Cut  NP‬‬
‫• להוכחת קשיות ‪ Max-Cut‬ל‪ NP -‬ניעזר בשפה ‪.3NAE‬‬
‫• הגדרות‪:‬‬
‫– ספיקות במובן ‪ :)NAE-satisfiable( NAE‬נוסחה בצורת ‪ CNF‬היא‬
‫ספיקה במובן ‪ )Not All Equal( NAE‬אם‪:‬‬
‫• קיימת השמה כך שבכל פסוקית יש ליטרל עם ערך ‪ T‬וליטרל עם ערך ‪. F‬‬
‫– השפה ‪:3NAE‬‬
‫} ‪3NAE = { |  is a formula in 3CNF form which is NAE-satisfiable‬‬
‫• נשתמש בכך ש‪:‬‬
‫– ‪ 3NAE‬היא ‪-NP‬קשה (ראו בתרגיל בית ‪.)3‬‬
‫• מספיק לכן להראות ש‪3NAE P Max-Cut -‬‬
‫‪122‬‬

‫‪61‬‬
 ‫הרדוקציה‬
‫• הקלט לרדוקציה‪:‬‬
‫– נוסחה ‪ ‬בצורת ‪.3CNF‬‬
‫• הפלט הנדרש‪:‬‬
‫– גרף לא מכוון ‪ G‬ומספר טבעי ‪.k‬‬
‫• וכך ש‪:‬‬
‫– ‪ ‬ספיקה במובן ‪ NAE‬אמ"מ יש בגרף חתך בגודל ‪.k‬‬
‫• נניח שבכל פסוקית ב‪  -‬יש ‪ 3‬ליטרלים בדיוק‬
‫ושאין בפסוקית ליטרלים מנוגדים‪.‬‬
‫– הנחה זו היא ללא הגבלת הכלליות‪ .‬מדוע? ‪...‬‬

‫‪123‬‬

‫)‪ = (x1  x2  x3)  (x1  x2  x3)  (x1  x2  x3‬‬

‫נסמן ב‪ n -‬את מספר המשתנים ב‪ ,  -‬ב‪ m -‬את מספר‬
‫הפסוקיות וב‪ x1, …, xn -‬את המשתנים עצמם‪.‬‬
‫‪x1‬‬ ‫‪x1‬‬ ‫הפלט יהיה )‪ (G, 2m+n‬כאשר ‪ G‬הוא‪:‬‬
‫קדקודים‪:‬‬
‫• קדקוד לכל משתנה וקדקוד לכל שלילה של משתנה‪.‬‬
‫‪x2‬‬ ‫‪x2‬‬ ‫סה"כ ‪ 2n‬קדקודים‪.‬‬
‫קשתות‪:‬‬
‫• קשת ממשתנה לשלילתו‪.‬‬
‫• נקרא לקשתות אלו "קשתות המשתנים"‪.‬‬
‫‪x3‬‬ ‫‪x3‬‬ ‫• מספר קשתות המשתנים‪:‬‬
‫• ‪.n‬‬
‫• לכל פסוקית ב‪ , -‬יהיו ‪ 3‬קשתות בין שלושת‬
‫קדקודי הפסוקית (משולש)‪.‬‬
‫• נקרא לקשתות אלו "קשתות הפסוקיות"‪.‬‬
‫• מספר קשתות הפסוקיות‪:‬‬
‫• ‪. 3m‬‬
‫• הערה‪ :‬הגרף המתקבל בד"כ אינו גרף פשוט‪.‬‬
‫יעילות‪ :‬פולינומיאלית‪.‬‬
‫נכונות‪ :‬בשקפים הבאים‪.‬‬

‫‪124‬‬

‫‪62‬‬
 ‫‪(G, 2m+n)  Max-Cut    3CNF‬‬
‫• קיימת ל‪  -‬השמה מספקת במובן ‪.NAE‬‬
‫• נסמן ב‪ S -‬את קבוצת קדקודי ‪ G‬שערכם ‪ T‬בהשמה‪.‬‬
‫• נראה שגודל החתך )‪ (S, V–S‬הוא ‪:2m+n‬‬
‫– ערכם בהשמה של הקדקודים ב‪ V-S -‬הוא‪:‬‬
‫• ‪.F‬‬
‫– לכן קשתות החתך הן בדיוק הקשתות בין קדקודים שערכם‬
‫בהשמה הוא ‪ T‬לבין אלו שערכם בהשמה הוא ‪.F‬‬
‫– מספר קשתות המשתנים בחתך‪:‬‬
‫• ‪( n‬כל הקשתות)‪.‬‬
‫– מספר קשתות הפסוקיות בחתך‪:‬‬
‫• כל אחת מהפסוקיות ספיקה במובן ‪ NAE‬ולכן יש בה ליטרל אחד עם‬
‫ערך ‪ T‬ושניים עם ערך ‪ F‬או ההפך‪.‬‬
‫• לכן מתוך ‪ 3‬הקשתות של פסוקית‪:‬‬
‫– השתיים שמחברות קדקודים עם ערכים הפוכים הן בחתך‪ .‬סה"כ‪:‬‬
‫» ‪.2m‬‬

‫‪125‬‬

‫‪  3CNF  (G, 2m+n)  Max-Cut‬‬

‫• קיים ב‪ G -‬חתך )‪ (S, V-S‬בגודל ‪ 2m+n‬לפחות‪ .‬נראה ש‪:‬‬
‫– ‪ ‬ספיקה במובן ‪.NAE‬‬
‫• ננתח מאילו קשתות החתך מורכב‪:‬‬
‫– הרדוקציה הוסיפה ל‪ G -‬משולש בגין כל פסוקית‪.‬‬
‫– מספר הקשתות שמשולש יכול לתרום לחתך הוא‪:‬‬
‫• ‪ 0‬או ‪. 2‬‬
‫– לכן כל הפסוקיות יחד יכולות לתרום לחתך לכל היותר‪:‬‬
‫• ‪ 2m‬קשתות‪.‬‬
‫– בנוסף יש רק עוד ‪ n‬קשתות בגרף (קשתות המשתנים)‪.‬‬
‫– לכן‪ ,‬כדי להגיע לחתך בגודל ‪ 2m+n‬חייב להתקיים ש‪:‬‬
‫• כל קשתות המשתנים ו‪ 2 -‬קשתות מכל פסוקית הן בחתך‪.‬‬
‫• השמה מספקת ל‪(  -‬במובן ‪:)NAE‬‬
‫– ניתן ערך ‪ T‬לליטרלים ב‪ S -‬וערך ‪ F‬לליטרלים ב‪.V-S -‬‬
‫• ההשמה חוקית‪... :‬‬
‫• ההשמה מספקת‪... :‬‬
‫‪126‬‬

‫‪63‬‬
 ‫אלגוריתמי קירוב‬
‫• בהרבה מקרים אנו מעוניינים למצוא את הפתרון האופטימלי לבעיה ולא רק‬
‫להכריע אותה‪.‬‬
‫• גרסת האופטימיזציה של ‪: Max-Cut‬‬
‫– בהינתן גרף לא מכוון ‪ G‬יש למצוא את החתך הגדול ביותר ב‪. G -‬‬
‫האם קיים אלגוריתם פולינומיאלי לבעיה זו?‬ ‫•‬
‫– אם כן אז ניתן להכריע באמצעותו את גרסת ההכרעה‬
‫של ‪ Max-Cut‬ולכן ‪. P = NP‬‬
‫• אז מה אפשר בכל זאת לעשות?‬
‫– נראה בשקף הבא אלגוריתם פולינומיאלי שמוצא חתך שגודלו לפחות ½ ממספר‬
‫הקשתות‪.‬‬
‫משמעות‪ :‬אמנם קשה למצוא חתך מכסימלי‪ ,‬אך קל למצוא חתך שגודלו‬ ‫•‬
‫לפחות ½ מגודל החתך המכסימלי‪.‬‬
‫אלגוריתמים שמוצאים פתרון מקורב לבעיות אופטימיזציה נקראים אלגוריתמי‬ ‫•‬
‫קירוב‪.‬‬
‫במקרה זה האלגוריתם משיג יחס קירוב של ½‪ .‬כלומר‪ ,‬גודל הפתרון‬ ‫•‬
‫שהאלגוריתם מוצא הוא לפחות ½ מגודל הפתרון האופטימלי‪.‬‬
‫בבעיות מקסימיזציה (כמו ‪ )Max-Cut‬נרצה יחס קירוב ‪ 1 ‬שהוא‪:‬‬ ‫•‬
‫– גדול ככל הניתן‪.‬‬
‫בבעיות מינימיזציה (כמו בעיית הסוכן הנוסע) נרצה יחס קירוב ‪ 1 ‬שהוא‪:‬‬ ‫•‬
‫– קטן ככל הניתן‪.‬‬

‫‪127‬‬

‫אלגוריתם פולינומיאלי המקבל כקלט גרף )‪G = (V,E‬‬

‫ומוצא בו חתך שגודלו לפחות |‪½|E‬‬
‫• על קלט גרף )‪:G = (V, E‬‬
‫– נתחיל מחתך כלשהו‪.‬‬
‫– כל עוד קיים בגרף קדקוד ‪ v‬שהעברתו מצד אחד של החתך‬
‫לצד השני מגדילה את החתך‪ ,‬נעביר את ‪ v‬לצד השני של‬
‫החתך‪.‬‬
‫– החתך שהתקבל הוא הפלט‪.‬‬
‫• יעילות האלגוריתם‪:‬‬
‫– יעילות כל איטרציה‪... :‬‬
‫– מספר האיטרציות ‪... :‬‬
‫• ניתוח גודל החתך שמתקבל‪:‬‬
‫– על הלוח ‪...‬‬

‫‪128‬‬

‫‪64‬‬
 EXPCOM ‫תרגיל – הוכחת קושי של השפה‬
EXPCOM = {<M, x, 0t>| M(x) = True. timeM(x)  2t}
:‫תרגיל‬
.‫קשה‬-EXP ‫ היא‬EXPCOM –
... :‫הוכחה‬

129

‫שלמה‬-NP ‫ היא‬SAT
‫שלמה‬-NP ‫ היא‬SAT :Cook-Levin ‫• משפט‬

130

65
 ‫תרגום נוסחה בוליאנית לצורת ‪CNF‬‬
‫• בהוכחת המשפט נצטרך לתרגם נוסחאות בוליאניות לצורת ‪.CNF‬‬
‫• הצורה הכללית ביותר של נוסחה בוליאנית‪:‬‬
‫‪x‬‬
‫‪1‬‬ ‫‪x‬‬ ‫‪2‬‬ ‫‪x‬‬ ‫‪3‬‬ ‫‪f‬‬ ‫• אבחנה (טריוויאלית)‪:‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫– ‪ f(x1, x2, x3) = 1‬אמ"מ‪:‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫• לכל שורה שערך ה‪ f -‬שלה הוא ‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪ x1, x2, x3‬שונים מערכי השורה‪.‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫• נבטא זאת בעזרת ‪:CNF‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫) ‪( x1  x2  x3 )  ( x1  x2  x3 )  ( x1  x2  x3‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫• כלומר על ‪ f‬עם ‪ m‬משתנים נקבל‪:‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫– נוסחה שקולה בצורת ‪ CNF‬שגודלה‪:‬‬
‫• ‪m  2m‬‬
‫– זמן הבניה‪:‬‬
‫• )‪O(m  2m‬‬
‫• בהוכחת קוק‪-‬לוין נשתמש בכך רק עבור ‪ m‬קבוע‪ .‬היעילות תהיה‪:‬‬
‫– )‪O(1‬‬
‫‪131‬‬

‫משפט ‪Cook-Levin‬‬
‫• צ"ל‪-NP SAT :‬קשה‪ ,‬כלומר אם ‪ B  NP‬אז ‪.B ≤p SAT‬‬
‫• תהא ‪ ,B  NP‬אזי קיים פולינום ‪ p‬ומכונת טיורינג ‪M‬‬
‫שרצה בזמן פולינומי וכך ש‪:‬‬
‫– לכל *‪ x  Σ‬מתקיים ‪ x  B‬אם ורק אם‬
‫קיים )|‪ w  {0,1}p(|x‬כך ש‪.M(x,w) = True -‬‬
‫• לשם פשטות ההוכחה נניח גם‪:‬‬
‫– ‪ M‬חצי אינסופית‪.‬‬
‫– אם ‪ M‬עוצרת במצב מקבל אז מתקיים בנוסף‪:‬‬
‫• התא הראשון בסרט מכיל ‪.B‬‬
‫• ראש המכונה הוא על תא זה‪.‬‬

‫‪132‬‬

‫‪66‬‬
 ‫ייצוג ריצת ‪ M‬על )‪(x, w‬‬
‫• ניתן לייצג את ריצת ‪ M‬על )‪ (x, w‬ע"י טבלה ‪.TM,x‬‬
‫הקונפיגורציה ההתחלתית‬ ‫• בשורה הראשונה של ‪- TM,x‬‬

‫‪x1‬‬ ‫‪x2‬‬ ‫‪xn‬‬ ‫‪w1‬‬ ‫)|‪Wp(|x‬‬ ‫‪B‬‬ ‫‪...‬‬ ‫‪B‬‬

‫• מה חסר?‬
‫• נוסיף את מיקום הראש והמצב לכל תא‪.‬‬
‫‪x1‬‬ ‫‪x2‬‬ ‫‪xn‬‬ ‫‪w1‬‬ ‫)|‪wp(|x‬‬ ‫‪B‬‬ ‫‪...‬‬ ‫‪B‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪qs‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬

‫‪133‬‬

‫• בשורה השניה של ‪ TM,x‬תהיה קונפיגורציה שמתקבלת‬

‫מהקונפיגורציה הראשונה ע"י טבלת המעברים‬
‫וכך הלאה‪.‬‬ ‫•‬
‫מספר השורות הוא זמן הריצה של ‪ M‬על )‪(x, w‬‬ ‫•‬
‫הוא חסום ע"י )|‪ ,q(|x‬כאשר ‪ q‬פולינום‪.‬‬ ‫•‬
‫נדאג שמספר השורות יהיה בדיוק )|‪ q(|x‬ע"י שכפול‬ ‫•‬
‫שורות שיש בהם ‪ qaccept‬או ‪.qreject‬‬
‫מה יהיה מספר העמודות?‬ ‫•‬
‫– גם )|‪ q(|x‬כי מקום חסום ע"י הזמן‪.‬‬

‫‪134‬‬

‫‪67‬‬
 ‫‪1‬‬ ‫‪2‬‬ ‫)|‪q(|x‬‬

‫‪1‬‬ ‫‪x1‬‬ ‫‪x2‬‬ ‫‪xn‬‬ ‫‪w1‬‬ ‫)|‪Wp(|x‬‬ ‫‪B‬‬ ‫‪...‬‬ ‫‪B‬‬

‫‪2‬‬

‫)|‪q(|x‬‬

‫איך נבטא בעזרת ‪ TM,x‬את התנאי ‪?x  B‬‬

‫‪ x  B‬אמ"מ ניתן לתת ערכים לתאי ‪ TM,x‬כך ש‪:‬‬
‫– שורה ‪ 1‬מכילה קונפיגורציה התחלתית חוקית‬
‫– שורה ‪ i‬מתקבלת מהשורה ה‪ i-1 -‬ע"י טבלת המעברים‪.‬‬
‫– ולבסוף )‪TM,x [q(|x|),1] = (B, 1, qaccept‬‬
‫‪135‬‬

‫ייצוג ‪ TM,x‬בבינארי‬
‫ניתן לייצג כל תא ב‪ TM,x -‬ע"י מספר קבוע של ביטים‪.‬‬ ‫•‬
‫דוגמה‪ :‬נניח ש‪  = {0, 1, 2, 3, 4, 5} -‬וש‪Q = {0 .. 9} -‬‬ ‫•‬
‫כאשר ‪ 5 ,2 ,1 ,0‬מייצגים ‪ qreject ,qaccept ,qstart‬ו‪.B -‬‬
‫נייצג את התווים והמצבים בבינרי על פי ערכם‪.‬‬ ‫•‬
‫אז ייצוג תא דורש ‪ 3 + 1 + 4 = 8‬ביטים‪ .‬ובאופן כללי‪:‬‬ ‫•‬
‫‪ log   1  log Q ‬כלומר ‪ k‬ביטים‪ ,‬עבור קבוע ‪.k‬‬

‫‪136‬‬

‫‪68‬‬
 ‫מה לגבי הרדוקציה?‬
‫• צריך להראות ‪B P SAT‬‬
‫• כלומר‪:‬‬
‫– קלט‪x :‬‬
‫– פלט‪ :‬נוסחה ‪ x‬בצורת ‪CNF‬‬
‫– יעילות בניית הנוסחה‪ :‬פולינומי ב‪|x| -‬‬
‫– נכונות‪:‬‬
‫‪ x‬ספיקה אמ"מ ‪x  B‬‬

‫‪137‬‬

‫בניית ‪x‬‬
‫• תנאי הנכונות‪ x :‬ספיקה אמ"מ ‪.x  B‬‬
‫• ובעזרת ‪ x :TM,x‬ספיקה אמ"מ‬
‫ניתן לתת ערכים בינריים לתאי ‪ TM,x‬כך ש‪:‬‬
‫‪ .I‬ערכי השורה הראשונה של ‪ TM,x‬מתאימים לקונפיגורציה‬
‫התחלתית של ‪ M‬על ‪.x‬‬
‫‪ .II‬ערכי השורה ה‪ i -‬של ‪ TM,x‬מתקבלים מהשורה ה‪ i-1 -‬ע"י‬
‫מעבר מ‪.M -‬‬
‫‪TM,x [q(|x|),1] = (B, 1, qaccept) .III‬‬
‫• הרעיון‪ x :‬תייצג את ‪TM,x‬‬
‫משתנים)‬ ‫)| ‪k  q (| x‬‬ ‫– איך נייצג כל ביט ב‪ :TM,x -‬על ידי משתנה (סה"כ‬
‫‪2‬‬

‫– נסמן את המשתנים עבור ]‪ TM,x[i,j‬ב‪-‬‬

‫‪xi1, j ,..., xik, j‬‬
‫– משמעות השמה למשתני ‪ :x‬מתן ערכים בינריים לתאי ‪TM,x‬‬
‫– נדאג שהשמה תהיה מספקת אמ"מ‪ :‬תנאים ‪ III ,II ,I‬מתקיימים‬
‫‪138‬‬

‫‪69‬‬
 ‫טיפול בתנאי ‪ – I‬הקונפיגורציה ההתחלתית‬
‫‪x1‬‬ ‫‪x2‬‬ ‫‪xn‬‬ ‫‪w1‬‬ ‫)|‪wp(|x‬‬ ‫‪B‬‬ ‫‪...‬‬ ‫‪B‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪qs‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬

‫ניזכר בדוגמה‪Q = {0 .. 9} , = {0, 1, 2, 3, 4, 5} :‬‬ ‫•‬

‫כאשר ‪ 5 ,2 ,1 ,0‬מייצגים ‪ qreject ,qaccept ,qstart‬ו‪.B -‬‬
‫מספר המשתנים הדרוש לכל תא ב‪3+1+4 = 8 :TM,x -‬‬ ‫•‬
‫נבנה תחילה נוסחה עבור ]‪.TM,x[1,1‬‬ ‫•‬
‫זו נוסחה מעל המשתנים ‪x11,1 ,..., x18,1‬‬ ‫•‬
‫הנוסחה צריכה לקיים שהשמה מספקת אותה אמ"מ‬ ‫•‬
‫ההשמה נותנת ערך נכון ל‪.TM,x[1,1] -‬‬
‫נניח ש‪ .x1 = 3 -‬אילו השמות נותנות ערך נכון ל‪?TM,x[1,1] -‬‬ ‫•‬
‫• תשובה‪ :‬רק ההשמה ‪.011 1 0000‬‬
‫• איך ניצור נוסחה שאך ורק השמה זו מספקת אותה?‬
‫‪139‬‬

‫• שאלה כללית יותר‪ :‬איך ניצור נוסחה שהשמות‬

‫‪x1‬‬ ‫‪x‬‬
‫‪2‬‬ ‫‪x‬‬ ‫‪f‬‬ ‫נתונות (ורק הן) מספקות אותה?‬
‫‪3‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫– בעזרת נוסחה בוליאנית כללית‪.‬‬

‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫• היכן ראינו נוסחה כזאת?‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫– בתרגום נוסחה בוליאנית ל‪.CNF -‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫– מהן ההשמות שמספקות‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫את הנוסחה שממול?‬
‫• כל השורות שבהן ‪.f = 1‬‬

‫‪140‬‬

‫‪70‬‬
 ‫‪x1‬‬ ‫‪x2‬‬ ‫‪xn‬‬ ‫‪w1‬‬ ‫)|‪wp(|x‬‬ ‫‪B‬‬ ‫‪...‬‬ ‫‪B‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪qs‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬ ‫‪q‬‬

‫• נחזור לדוגמה‪ :‬מה מספר השורות בנוסחה בוליאנית עבור ]‪28 ? TM,x[1,1‬‬
‫• מה ערך הפונקציה בכל אחת מהשורות?‬
‫– בשורה ‪( 011 1 0000‬ורק בה) יהיה ‪. 1‬‬
‫• מה לגבי ]‪( TM,x[1,2‬נניח למשל ‪ ?)x2 = 6‬בשורות **** ‪(110 0‬ורק בהן) יהיה ‪. 1‬‬
‫• ומה לגבי ]‪( T[1, n+1‬התא של ‪?)w1‬‬
‫– בשורות **** ‪ 000 0‬ו‪( 001 0 **** -‬ורק בהן) יהיה ‪. 1‬‬

‫• מה יעילות תרגום נוסחה כזו ל‪( CNF -‬ל‪ k -‬שאינו בהכרח ‪?)8‬‬
‫– )‪ O(k  2k‬שזה )‪ O(1‬כי ‪ k‬קבוע‬
‫• באופן כללי‪ :‬לכל תא בשורה ‪ 1‬של ‪ TM,x‬ניתן בזמן קבוע ליצור נוסחה בצורת‬
‫‪ CNF‬שהשמה מספקת אותה אמ"מ ההשמה נותנת ערך נכון לתא‪.‬‬
‫• אז איך ניצור נוסחה שתבטא את כל שורה ‪? 1‬‬
‫– ‪ AND‬בין )|‪ q(|x‬נוסחאות התאים של שורה ‪ . 1‬זו נוסחת ‪ CNF‬כנדרש !‬
‫– מה גודל הנוסחה? )|‪O(q(|x‬‬

‫‪141‬‬

‫טיפול בתנאי ‪ – II‬ערכי שורה מתקבלים‬

‫מהשורה הקודמת ע"י טבלת המעברים‬
‫• נסתכל על תא ]‪.TM,x[i, j‬‬
‫• מה תא זה מייצג?‬
‫– בצעד ה‪ i -‬של ‪:M‬‬
‫• תוכן המקום ה‪ j -‬בסרט‪.‬‬
‫• האם ראש המכונה הוא על המקום ה‪ j -‬בסרט‪.‬‬
‫• המצב (אם הראש הוא על המקום ה‪ j -‬בסרט)‪.‬‬
‫• באילו תאים אחרים תלוי ]‪?TM,x[i,j‬‬
‫– ]‪ TM,x[i-1,j] ,TM,x[i-1,j-1‬ו‪.TM,x[i-1,j+1] -‬‬
‫– מינוח‪ :‬נקרא להם התאים הקובעים עבור ]‪.TM,x[i,j‬‬
‫• איך ניתן לבטא את התלות כנוסחה בוליאנית?‬
‫– בעזרת נוסחה בוליאנית בעלת ‪ 4k‬משתנים (סדר המשתנים יהיה‬
‫למשל לפי המיקום בטבלה – מלמעלה למטה ומשמאל לימין)‪.‬‬

‫‪142‬‬

‫‪71‬‬
 ‫נוסחה בוליאנית המביעה את התלות בין ]‪TM,x[i,j‬‬
‫לבין ]‪ TM,x[i-1,j] ,TM,x[i-1,j-1‬ו‪.TM,x[i-1,j+1] -‬‬
‫• מה מספר השורות בנוסחה? ‪24k‬‬
‫• נסתכל על שורות מהצורה‬
‫****‪abc0**** def0**** ghi0**** jklm‬‬
‫• מה יהיה הערך של שורות כאלו?‬
‫– ‪ 1‬אם מתקיימים כל התנאים הבאים‪:‬‬
‫• אין חריגה מערכי ‪ ‬באף אחד מהתאים‪.‬‬
‫• ‪m=0‬‬
‫• ‪def = jkl‬‬
‫– ‪ 0‬אחרת‪.‬‬

‫‪143‬‬

‫• נסתכל עתה על שורות מהצורה‬

‫‪abc1nopq def0**** ghi0**** jkl1rstu‬‬
‫• מה יהיה הערך של שורות כאלו?‬
‫– ‪ 1‬אם מתקיימים כל התנאים הבאים‪:‬‬
‫אין חריגה מערכי ‪ ‬באף אחד מהתאים‪.‬‬ ‫•‬
‫אין חריגה מערכי ‪ Q‬בתא הראשון והאחרון‪.‬‬ ‫•‬
‫‪def = jkl‬‬ ‫•‬
‫יש ב‪ M -‬מעבר )‪M(nopq, abc) = (rstu, ***, R‬‬ ‫•‬
‫– ‪ 0‬אחרת‪.‬‬
‫• בדומה ניתן לחשב את הערך של כל שורה אחרת בנוסחה‪.‬‬
‫• יעילות תרגום הנוסחה ל‪:CNF -‬‬
‫– )‪ O(k  24k‬שזה‪:‬‬
‫• )‪ O(1‬כי ‪ k‬קבוע‬
‫• מה לגבי שאר התאים בטבלה?‬
‫– ניצור נוסחאות כנ"ל עבור כל התאים בטבלה ונבצע ‪ AND‬ביניהן‪.‬‬
‫• סה"כ יעילות הטיפול בתנאי ‪:2‬‬
‫– )|‪O(q2(|x‬‬

‫‪144‬‬

‫‪72‬‬
 ‫טיפול בתנאי ‪:III‬‬
‫)‪TM,x [q(|x|),1] = (B, 1, qaccept‬‬

‫• כבר ראינו מורכבים מזה‪...‬‬

‫‪145‬‬

‫נכונות ויעילות‬
‫• נכונות הרדוקציה‪:‬‬
‫– ‪ x  B‬אמ"מ‬
‫• ניתן לתת ערכים בינאריים לכל תאי ‪ TM,x‬כך ש‪:‬‬
‫השורה הראשונה מייצגת קונפיגורציה התחלתית חוקית‪.‬‬ ‫‪.I‬‬
‫השורה ה‪ i -‬מתקבלת מהשורה ה‪ i-1 -‬ע"י מעבר של ‪. M‬‬ ‫‪.II‬‬
‫)‪. TM,x[q(|x|), 1] = (qaccept, 1, B‬‬ ‫‪.III‬‬
‫– אמ"מ‬
‫• קיימת השמה למשתני ‪ x‬המספקת לכל תא של ‪ TM,x‬את חלק הנוסחה‬
‫של ‪ x‬המתאים לתא זה‪.‬‬
‫– אמ"מ‬
‫• קיימת השמה מספקת ל‪. x -‬‬
‫• יעילות הרדוקציה‪:‬‬
‫– החלק היקר ביותר היה טיפול בתנאי ‪ II‬ודרש )|‪ O(q2(|x‬כלומר‬
‫זמן פולינומיאלי‪.‬‬
‫‪146‬‬

‫‪73‬‬
 ‫תרגילים‬
‫האם הטענה נכונה‪ ,‬שגויה או שקולה לבעיה פתוחה?‬
‫‪ .1‬קיים ‪ k‬טבעי עבורו )‪.SAT  DTime(nk‬‬
‫‪ .2‬קיים ‪ k‬טבעי עבורו )‪.NP  DTime(nk‬‬

‫‪147‬‬

‫ההיררכיה הפולינומיאלית‬
‫• ההיררכיה הפולינומיאלית‪:‬‬
‫– סדרה אינסופית של מחלקות בין ‪ P‬ל‪.PSPACE -‬‬
‫– ‪ P‬היא ברמה ‪ 0‬של ההיררכיה‪.‬‬
‫– ‪ NP‬ו‪( coNP -‬מוגדרת להלן) הן יחדיו ברמה ‪ 1‬של‬
‫ההיררכיה‪ .‬נקראות גם ‪ 1‬ו‪( 1 -‬בהתאמה)‪.‬‬
‫– ברמה הבאה של ההיררכיה ‪ 2‬ו‪ .2 -‬וכך הלאה‪.‬‬
‫‪NP‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫…‬

‫‪P‬‬ ‫‪PH‬‬ ‫‪PSPACE‬‬

‫‪coNP‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫…‬

‫‪148‬‬ ‫מקרא‪ :‬חץ מסמן ‪‬‬

‫‪74‬‬
 ‫מחלקות משלימות‬
‫• שפה משלימה‪ :‬אם ‪ A‬היא שפה‪ ,A  * ,‬אז‬
‫השפה המשלימה ל‪ A -‬היא‬
‫‪A  {w  Σ* | w  A}  Σ* - A‬‬
‫• מחלקה משלימה‪ :‬עבור מחלקת שפות ‪,C‬‬
‫המחלקה המשלימה היא }‪coC  {A | A  C‬‬
‫• המחלקה ‪ :coNP‬מחלקת השפות המשלימות‬
‫לשפות ב‪ .NP -‬למשל‬
‫‪SAT‬‬ ‫•‬
‫• ‪3 - Col‬‬
‫‪149‬‬

‫תכונות‬
‫• משפט‪ :‬תהיינה ‪ A‬ו‪ B -‬שפות ו‪ D -‬ו‪ E -‬מחלקות של‬
‫שפות‪ .‬אזי‬
‫‪AA‬‬ ‫‪.1‬‬
‫‪A P B‬‬ ‫‪ A ≤P B‬אמ"מ‬ ‫‪.2‬‬
‫‪A  D  A  coD‬‬ ‫‪.3‬‬
‫‪co(coD) = D‬‬ ‫‪.4‬‬
‫‪ D  E‬אמ"מ ‪coD  coE‬‬ ‫‪.5‬‬
‫‪( D = coD  D  coD‬ו‪)D = coD  coD  D -‬‬ ‫‪.6‬‬
‫‪ A‬קשה ל‪ D -‬אמ"מ ‪ A‬קשה ל‪coD -‬‬ ‫‪.7‬‬
‫‪ D‬סגורה לרדוקציות פולינומיאליות אמ"מ ‪ coD‬סגורה‬ ‫‪.8‬‬
‫לרדוקציות פולינומיאליות‪.‬‬
‫כל המחלקות הדטרמיניסטיות (למשל ‪ PSPACE ,P‬ו‪)EXP -‬‬ ‫‪.9‬‬
‫סגורות למשלים (כלומר ‪ EXP=coEXP ,P = coP‬וכ"ו)‪.‬‬
‫‪150‬‬ ‫הוכחות על הלוח‬

‫‪75‬‬
 ‫מה לגבי ‪ NP‬ו‪?coNP -‬‬
‫• האם ‪?NP = coNP‬‬
‫– ננסה להראות ‪ NP  coNP‬בדומה לדרך שבה הראינו‬
‫ש‪:P  coP -‬‬
‫• יהיה ‪ .A  NP‬עלינו להראות ש‪ A  coNP -‬כלומר ש‪A  NP -‬‬
‫• תהיה ‪ M‬מטא"ד המכריעה את ‪( A‬בזמן פולינומיאלי)‪ .‬נבנה ’‪ M‬הפועלת כמו‬
‫‪ M‬ועונה ההפך ממנה‪.‬‬
‫עלינו להראות ש‪ M’ -‬מכריעה את ‪A‬‬

‫• אם ‪ x  A‬אז ‪ x  A‬ולכן כל תסריט ריצה של ‪ M‬על ‪ x‬מסתיים ב‪reject -‬‬

‫מכאן שכל תסריט ריצה של ’‪ M‬על ‪ x‬מסתיים ב‪.accept -‬‬
‫‪ o‬האם זה בסדר? ‪...‬‬

‫• אם ‪ x  A‬אז ‪ x  A‬ולכן קיים תסריט ריצה של ‪ M‬על ‪ x‬שמסתיים ב‪accept -‬‬

‫ומכאן שקיים תסריט ריצה של ’‪ M‬על ‪ x‬שמסתיים ב‪.reject -‬‬
‫‪ o‬האם זה בסדר? ‪...‬‬
‫• והשאלה האם ‪ NP = coNP‬היא אכן בעיה פתוחה‪.‬‬

‫‪151‬‬

‫תכונות נוספות‬
‫טענה ‪P  NP  coNP :1‬‬ ‫•‬
‫הוכחה‪... :‬‬ ‫•‬
‫טענה ‪ :2‬אם ‪ P = NP‬אז ‪NP = coNP‬‬ ‫•‬
‫הוכחה‪... :‬‬ ‫•‬
‫טענה ‪ A  NP-hard :3‬אמ"מ ‪A  coNP - hard‬‬ ‫•‬
‫הוכחה‪ :‬תכונה ‪7‬‬ ‫•‬
‫טענה ‪ :4‬אם ‪ SAT  coNP‬אז ‪NP = coNP‬‬ ‫•‬
‫הוכחה‪:‬‬ ‫•‬
‫– לפי תכונה ‪ 6‬מספיק להראות ‪ NP  coNP‬ואכן ‪...‬‬
‫בדומה‪ :‬אם ‪ SAT  NP‬אז ‪NP = coNP‬‬
‫• הכללה‪ :‬ניתן להחליף את ‪ SAT‬ב‪ -‬כל שפה ‪-NP‬קשה‪.‬‬
‫‪152‬‬

‫‪76‬‬
 ‫קשיות גם ל‪ NP -‬וגם ל‪coNP -‬‬
‫• קבוצה בלתי תלויה (קב"ת) בגרף‪:‬‬
‫– קבוצת קדקודים שאין ביניהם קשתות‪.‬‬
‫• השפה ‪:)Independent Set( IS‬‬
‫– שפת הזוגות )‪ (G, k‬כך שהגרף ‪ G‬מכיל קב"ת בגודל ‪.k‬‬
‫• השפה ‪:MAX-IS‬‬
‫– שפת הזוגות >‪ <G, k‬כך ש‪ G -‬מכיל קב"ת בגודל ‪ k‬ואינו‬
‫מכיל קב"ת גדולה יותר‪.‬‬
‫• משפט‪:‬‬
‫– ‪ MAX-IS‬קשה גם ל‪ NP -‬וגם ל‪coNP -‬‬
‫• תוצאה‪:‬‬
‫– אם ‪ NP  coNP‬אז‬
‫• ‪ MAX-IS  NP‬ו‪.MAX-IS  coNP -‬‬

‫‪153‬‬

‫דיון – מה קורה כאן‬

‫נראה תחילה מי האיברים של ‪ MAX-IS‬ושל ‪: MAX - IS‬‬
‫‪:(G, k)  MAX-IS‬‬
‫• יש ב‪ G -‬קב"ת בגודל ‪ k‬אבל לא בגודל ‪.k+1‬‬
‫‪: (G, k )  MAX - IS‬‬
‫• אין ב‪ G -‬קב"ת בגודל ‪ k‬או יש בגודל ‪.k+1‬‬
‫אז מדוע ככל הנראה‪:‬‬
‫‪:MAX-IS  NP .1‬‬
‫• כי בהינתן )‪ (G, k‬לא ברור איך ניתן בזמן פולינומיאלי להראות‬
‫קיום עד לכך שאין קב"ת בגודל ‪.k+1‬‬
‫‪MAX - IS  NP‬‬ ‫‪ MAX-IS  coNP .2‬כלומר‬
‫• כי בהינתן )‪ (G, k‬לא ברור איך ניתן בזמן פולינומיאלי להראות‬
‫קיום עד לכך שאין קב"ת בגודל ‪.k‬‬
‫‪154‬‬

‫‪77‬‬
 ‫‪ MAX-IS‬קשה ל‪ NP -‬ו‪coNP -‬‬
‫• קשיות ל‪:coNP -‬‬
‫– נראה ‪... IS P MAX- IS‬‬
‫• קשיות ל‪ :NP -‬נראה רדוקציה מ‪ SAT -‬ל‪ .IS -‬אותה‬
‫רדוקציה היא גם רדוקציה מ‪ SAT -‬ל‪.MAX-IS -‬‬
‫• תהי ‪ ‬נוסחה בצורת ‪ CNF‬עם ‪ m‬פסוקיות‪.‬‬
‫• פלט הרדוקציה הוא הזוג >‪ G .<G, m‬מוגדר‬
‫בשקף הבא‪.‬‬

‫‪155‬‬

‫– נעבוד עם הדוגמה‪( x1  x2  x3 )  ( x1  x2  x3 )  ( x1  x3 ) :‬‬

‫– קדקודים‪:‬‬
‫• קדקוד לכל ליטרל בכל פסוקית (כלומר אם פסוקית מכילה ‪r‬‬
‫ליטרלים יהיו עבורה ‪ r‬קדקודים)‪.‬‬
‫– קשתות‪:‬‬
‫‪ .a‬קשת בין כל שני ליטרלים של אותה פסוקית (כלומר‬
‫הליטרלים של פסוקית בת ‪ r‬קדקודים יהוו קליקה בגודל ‪.)r‬‬
‫‪ .b‬קשת בין קדקוד של כל ליטרל לכל הקדקודים של שלילת‬
‫הליטרל‪.‬‬

‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x1‬‬ ‫‪x3‬‬

‫‪156‬‬

‫‪78‬‬
 ‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x1‬‬ ‫‪x3‬‬

‫• נכונות (יעילות – תרגיל)‪:‬‬

‫– אם ‪:  SAT‬‬
‫• קיימת השמה כך שבכל פסוקית קיים ליטרל עם ערך ‪True‬‬
‫(דוגמה‪.)x1 = 1, x2 = 1, x3 = 0 :‬‬
‫• מכל פסוקית נבחר קדקוד אחד שמתאים לליטרל כזה‪.‬‬
‫קיבלנו ‪ m‬קדקודים‪ .‬נראה שהם מהווים קב"ת‪:‬‬
‫– אין ביניהם קשתות חומות משום שהם מפסוקיות שונות‪.‬‬
‫– אין ביניהם קשתות אדומות משום שלכל הליטרלים אותו ערך (‪)True‬‬
‫ולכן אין ביניהם ליטרל ושלילתו‪.‬‬
‫• אבחנה‪ G  MAX-IS :‬כי אין ב‪ G -‬קב"ת גדולה מ‪.m -‬‬

‫‪157‬‬

‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x1‬‬ ‫‪x3‬‬

‫– אם ‪( G  IS‬אבחנה‪ :‬אם ‪ G  MAX-IS‬אז ‪:)G  IS‬‬

‫• קיימת קב"ת בגודל ‪( m‬דוגמה‪ :‬הקדקודים הירוקים)‪ .‬נשים‬
‫לב‪:‬‬
‫אין בקב"ת קדקוד של ליטרל ושלילתו (בזכות הקשתות‬ ‫‪.1‬‬
‫האדומות)‪.‬‬
‫יש בקב"ת קדקוד אחד בדיוק מכל פסוקית (בזכות הקשתות‬ ‫‪.2‬‬
‫החומות ומכיוון שהקב"ת בגודל ‪.)m‬‬
‫• נשים ל‪ m -‬הליטרלים המתאימים ערך ‪( True‬וערכים כרצוננו‬
‫לשאר המשתנים)‪.‬‬
‫• בגלל ‪ 1‬זו השמה חוקית‪ .‬בגלל ‪ 2‬כל הפסוקיות מסופקות‪.‬‬

‫‪158‬‬

‫‪79‬‬
 ‫הגדרה אלטרנטיבית ל‪coNP -‬‬
‫• הגדרה אלטרנטיבית ל‪( NP -‬ראינו)‪ NP :‬היא‬
‫מחלקת השפות *‪ A  ‬עבורן קיימים‪:‬‬
‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪:x  ‬‬
‫‪x  A  w  {0,1} p (| x|) .M ( x, w)  True‬‬
‫• ומכאן‪:‬‬
‫}‪x  A  w  {0,1‬‬ ‫)|‪p (| x‬‬
‫‪.M ( x, w)  False‬‬
‫• ההגדרה האלטרנטיבית ל‪ coNP -‬מתקבלת ע"י‪:‬‬
‫– הפיכת התשובה של המכונה ‪( M‬ועם אותו פולינום ‪.)p‬‬
‫‪159‬‬

‫הגדרה אלטרנטיבית ל‪( coNP -‬סיכום)‪:‬‬

‫• ‪ coNP‬היא מחלקת השפות *‪ A  ‬עבורן קיימים‪:‬‬
‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪:x  ‬‬
‫‪x  A  w  {0,1} p (| x|) .M ( x, w)  True‬‬

‫‪160‬‬

‫‪80‬‬
 ‫שימוש בהגדרה האלטרנטיבית של ‪coNP‬‬
‫• דוגמה‪ :‬נוכיח בעזרת ההגדרה האלטרנטיבית של‬
‫‪ NP‬ש‪. IS coNP -‬‬
‫• הוכחה‪:‬‬
‫– נבנה מ"ט דטרמיניסטית ‪ M‬שעל קלט )‪((G, k), w‬‬
‫• אם ‪ w‬אינה קב"ת בגודל ‪k‬‬
‫– ‪ M‬תקבל‪.‬‬
‫• אחרת‬
‫– ‪ M‬תדחה‪.‬‬

‫‪161‬‬

‫הרמות הראשונות של ההיררכיה‬

‫הפולינומיאלית‬
‫• רמה ‪ :0‬המחלקה ‪( P‬אפס כמתים בהגדרת‬
‫המחלקה)‪.‬‬
‫• רמה ‪ :1‬המחלקות ‪ NP‬ו‪( coNP -‬כמת אחד‬
‫בהגדרת המחלקות)‪.‬‬

‫‪162‬‬

‫‪81‬‬
 ‫רמה ‪2 - 2‬‬
‫• הגדרה‪ 2 :‬היא מחלקת השפות *‪ A  ‬עבורן‬
‫קיימים‪:‬‬
‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪ x  ‬מתקיים‪:‬‬
‫‪x  A  u  {0,1} p (| x|) .v  {0,1} p (| x|) .M ( x, u , v)  True‬‬
‫כלומר‪:‬‬
‫‪x  A  u  {0,1} p (| x|) .v  {0,1} p (| x|) .M ( x, u , v)  True‬‬
‫‪x  A  u  {0,1} p (| x|) .v  {0,1} p (| x|) .M ( x, u , v)  False‬‬
‫‪163‬‬

‫האם ‪?MAX-IS  2‬‬

‫• תזכורת ‪ -‬השפה ‪:MAX-IS‬‬
‫– שפת הזוגות >‪ <G, k‬כך ש‪:‬‬
‫‪ G .1‬מכיל קב"ת בגודל ‪.k‬‬
‫‪ G .2‬אינו מכיל קב"ת בגודל ‪.k+1‬‬
‫• ראינו‪:‬‬
‫– ‪ MAX-IS‬קשה גם ל‪ NP -‬וגם ל‪coNP -‬‬
‫– וקיבלנו שכתוצאה מכך אם ‪ NP  coNP‬אז‬
‫• ‪ MAX-IS  NP‬ו‪.MAX-IS  coNP -‬‬
‫• מה לגבי שייכות ‪ MAX-IS‬לרמות גבוהות יותר של‬
‫ההיררכיה הפולינומיאלית?‬
‫– קל לבטא את תנאי ‪ 1‬בעזרת‪:‬‬
‫• כמת ‪.‬‬
‫– קל לבטא את תנאי ‪ 2‬בעזרת‪:‬‬
‫• כמת ‪.‬‬
‫‪164‬‬

‫‪82‬‬
 ‫‪MAX-IS  2‬‬
‫נבנה מכונה ‪ M‬כך‪:‬‬
‫• קלט‪:‬‬
‫– גרף >‪ <G, k‬ושתי קבוצות קדקודים ‪ u‬ו‪. v -‬‬
‫• ‪ M‬תקבל אמ"מ שני התנאים הבאים מתקיימים‪:‬‬
‫‪ u‬היא קב"ת בגודל ‪. k‬‬ ‫‪.1‬‬
‫‪ v‬אינה קב"ת בגודל ‪. k+1‬‬ ‫‪.2‬‬
‫נכונות‪:‬‬
‫• ‪:<G, k>  MAX-IS‬‬
‫– אז קיימת קב"ת ‪ x‬בגודל ‪ x . k‬מקיימת את תנאי ‪. 1‬‬
‫– כמו כן כל קבוצת קדקודים אינה קב"ת בגודל ‪ k+1‬ולכן מקיימת את תנאי ‪. 2‬‬
‫– לכן עבור ‪ u = x‬ולכל ‪ v‬מתקיים ‪ M((G, k), u, v) = True‬כנדרש‪.‬‬
‫• ‪:<G, k>  MAX-IS‬‬
‫– אז יש שתי אפשרויות‪:‬‬
‫• אין ב‪ G -‬קב"ת בגודל ‪. k‬‬
‫– אז לכל ‪ u‬תנאי ‪ 1‬אינו מתקיים‪ .‬לכן לכל ‪ u‬ולכל ‪ v‬מתקיים ‪( M((G, k), u, v) = False‬שזה חזק יותר‬
‫מהנדרש)‪.‬‬
‫• יש ב‪ G -‬קב"ת ‪ y‬בגודל ‪. k+1‬‬
‫– ‪ y‬אינה מקיימת את תנאי ‪ . 2‬לכן לכל ‪ u‬ועבור ‪ v = y‬מתקיים ‪. M((G, k), u, v) = False‬‬

‫‪165‬‬

‫רמה ‪2 - 2‬‬

‫• הגדרה‪2 = co2 :‬‬
‫• הגדרה חלופית‪ 2 :‬היא מחלקת השפות *‪A  ‬‬
‫עבורן קיימים‪:‬‬
‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪ x  ‬מתקיים‪:‬‬
‫‪x  A  u  {0,1} p (| x|) .v  {0,1} p (| x|) .M ( x, u , v)  True‬‬

‫‪166‬‬

‫‪83‬‬
 ‫‪MAX-IS  2‬‬
‫– נבנה מכונה ‪ M‬כך‪:‬‬
‫• קלט‪ :‬גרף >‪ <G, k‬ושתי קבוצות קדקודים ‪ u‬ו‪.v -‬‬
‫• ‪ M‬תקבל אמ"מ שני התנאים הבאים מתקיימים‪:‬‬
‫‪ u‬אינה קב"ת בגודל ‪. k+1‬‬ ‫‪.1‬‬
‫‪ v‬היא קב"ת בגודל ‪. k‬‬ ‫‪.2‬‬
‫נכונות‪ :‬להשלים‪.‬‬

‫‪167‬‬

‫נושאים על הלוח‬
‫• משפט ‪ NP :1‬ו‪ coNP -‬מוכלות ב‪2  2 -‬‬
‫• הוכחה‪ :‬נראה הכלה אחת‪ .‬יהיה ‪ .A  NP‬נוכיח ‪A  2‬‬
‫– קיימים ‪ M‬ו‪ p -‬כך ש‪x  A  u{0,1}p(|x|).M(x,u)=True -‬‬
‫)‪ (x, u, v‬המכונה ’‪M‬‬ ‫– נבנה ’‪ M‬כך‪ :‬על קלט‬
‫• מריצה את ‪ M‬על )‪ (x,u‬ועונה כמו ‪( M‬כלומר מתעלמת מ‪.)v -‬‬
‫– ונקבל‪x  A  u{0,1}p(|x|).v{0,1}p(|x|).M’(x,u,v)=True :‬‬
‫• משפט ‪ :2‬אם ‪ NP = coNP‬אז ‪NP = coNP = 2 = 2‬‬
‫– תוצאה‪ :‬אם ‪ P = NP‬אז ‪P = NP = coNP = 2 = 2‬‬
‫• הכללה‪ :‬אם ‪ i = i‬אז ‪i = i = i+1 = i+1‬‬
‫‪168‬‬
‫• הוכחת משפט ‪ :2‬נראה ‪( 2  NP‬בשקף הבא)‬

‫‪84‬‬
 ‫אם ‪ NP = coNP‬אז ‪2  NP‬‬
‫יהיה ‪ .A ‬אז קיימים ‪ M‬ו‪ p -‬כך ש‪:‬‬
‫• ‪x  A  u{0,1}p(|x|).v{0,1}p(|x|).M (x,u,v)=T‬‬
‫נגדיר שפה‬
‫}‪A’ = {(x, u) | v{0,1‬‬‫)|‪p(|x‬‬ ‫• }‪.M (x,u,v)=T‬‬
‫אז‬
‫‪x  A  u{0,1}p(|x|).(x,u)  A’ (1‬‬
‫‪A’  coNP (2‬‬

‫אבל ‪ NP = coNP‬כלומר ‪.A’  NP‬‬

‫לכן קיימים ’‪ M‬ו‪ q -‬כך ש‪:‬‬
‫• ‪(x,u)  A’  w{0,1}q(|(x,u)|).M’ (x,u,w) =T‬‬
‫מ‪ 1 -‬נקבל‪:‬‬
‫}‪x  A  u{0,1‬‬‫)|‪p(|x‬‬ ‫}‪. w{0,1‬‬ ‫))|‪q(|x|+p(|x‬‬ ‫• ‪.M’(x,u,w)=T‬‬
‫נסמן ))‪ q’(n) = p(n) + q(n + p(n‬ונקבל‬
‫• ‪x  A  w’{0,1}q’(|x|).M’(x,w’)=T‬‬
‫‪169‬‬
‫כלומר ‪.A  NP‬‬

‫‪2-SAT‬‬
‫• הגדרה‪ 2-SAT :‬היא שפת הנוסחאות‬
‫הבוליאניות )‪  = (x1, …, xn, y1, …, yn‬כך ש‪:‬‬
‫– כל השמה למשתנים ‪ x1, …, xn‬ניתן להרחיב להשמה מספקת‬
‫ל‪. -‬‬
‫• טענה‪2-SAT  2 :‬‬
‫• הוכחה‪ :‬נבנה מ"ט ‪ M‬שעל קלט )‪(, u, v‬‬
‫– תסתכל על ‪ u‬כהשמה ל‪ x1, …, xn -‬ועל ‪ v‬כהשמה ל‪y1, …, yn -‬‬
‫ותקבל אמ"מ‬
‫• ההשמה מספקת‪.‬‬
‫– נכונות‪... :‬‬
‫• משפט‪ 2-SAT :‬היא ‪ 2‬שלמה‪.‬‬
‫• ההוכחה דומה לזו של משפט ‪.Cook-Levin‬‬
‫‪170‬‬

‫‪85‬‬
 ‫הגדרת ‪i‬‬
‫• ‪ i‬מוגדרת עם ‪ i‬כמתים ומתחילה ב‪ . -‬פורמלית‪:‬‬
‫• ‪ i‬היא מחלקת השפות *‪ A  ‬עבורן קיימים‪:‬‬
‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪ x  ‬מתקיים ‪ x  A‬אמ"מ‪:‬‬
‫‪v1  {0,1} p (| x|) .v2  {0,1} p (| x|) ...Qvi  {0,1} p (| x|) .M ( x, v1..., vi )  True‬‬
‫כאשר ‪ Q‬הוא הכמת ‪ ‬עבור ‪ i‬אי זוגי ו‪  -‬עבור ‪ i‬זוגי‪.‬‬

‫‪171‬‬

‫הגדרת ‪i‬‬
‫• ‪ i‬מוגדרת עם ‪ i‬כמתים ומתחילה ב‪ . -‬פורמלית‪:‬‬
‫• ‪ i‬היא מחלקת השפות *‪ A  ‬עבורן קיימים‪:‬‬
‫– פולינום ‪p‬‬
‫– מ"ט דטרמיניסטית ‪ M‬הרצה בזמן פולינומיאלי‬
‫וכך שלכל *‪ x  ‬מתקיים ‪ x  A‬אמ"מ‪:‬‬
‫‪v1  {0,1} p (| x|) .v2  {0,1} p (| x|) ...Qvi  {0,1} p (| x|) .M ( x, v1..., vi )  True‬‬
‫כאשר ‪ Q‬הוא הכמת ‪ ‬עבור ‪ i‬אי זוגי ו‪  -‬עבור ‪ i‬זוגי‪.‬‬

‫‪172‬‬

‫‪86‬‬
 ‫הגדרת ‪ PH‬ותכונות ההיררכיה הפולינומיאלית‬
‫• ‪ :PH‬איחוד כל מחלקות ההיררכיה הפולינומיאלית‪:‬‬
‫‪PH    i‬‬
‫‪i 0‬‬ ‫• תכונות‪:‬‬
‫הוכחה‪... :‬‬ ‫‪ .1‬לכל ‪ i  1‬מתקיים ‪ i = coi‬ו‪i = coi -‬‬
‫הוכחה‪... :‬‬ ‫‪ .2‬לכל ‪ i  1‬מתקיים ‪i  i  i+1  i+1‬‬
‫‪ PH ‬הוכחה‪... :‬‬ ‫‪‬‬ ‫‪i‬‬ ‫‪.3‬‬
‫‪i0‬‬
‫‪ .4‬המחלקה ‪ PH‬סגורה למשלים (‪ )PH = coPH‬הוכחה‪... :‬‬
‫‪ .5‬לכל ‪ i  1‬מתקיים ‪ i‬ו‪ i -‬סגורות לרדוקציות‬
‫פולינומיאליות‪ .‬ההוכחה קצת מסורבלת – נוותר‪.‬‬
‫• תוצאה‪ :‬גם ‪ PH‬סגורה לרדוקציות פולינומיאליות‪ .‬הוכחה‪... :‬‬
‫‪173‬‬

‫בעיות פתוחות וקריסת ההיררכיה‬

‫הפולינומיאלית‬
‫• בעיה פתוחה‪ :‬האם קיים ‪ i‬שעבורו ‪i = i‬‬
‫– עבור ‪ i = 1‬השאלה היא האם ‪NP = coNP‬‬
‫• ההשערה המקובלת‪:‬‬
‫– לא קיים ‪ i‬כזה‬
‫‪( i  i  i+1  i+1‬הכלה ממש)‬ ‫– לכל ‪ i‬מתקיים‬
‫• קריסת ההיררכיה הפולינומיאלית‪:‬‬
‫– אם קיים ‪ i‬שעבורו ‪( i = i+1‬או ‪ )i = i‬אז ניתן‬
‫להראות ‪PH = i‬‬
‫– נקרא‪ :‬קריסת ההיררכיה הפולינומיאלית לרמה ‪.i‬‬

‫‪174‬‬

‫‪87‬‬
 ‫שלמות ב‪  PH -‬קריסת ‪PH‬‬
‫• משפט‪ :‬אם קיימת שפה שלמה ל‪ PH -‬אז‬
‫– ‪ PH‬קורסת (לאיזושהי רמה ‪.)i‬‬
‫• הוכחה‪... :‬‬

‫‪175‬‬

‫‪88‬‬