חישוביות - מחברת הרצאות

‫חישוביות‬
‫מחברת סיכום מתוך ההרצאות של דורון מור‬

‫אוניברסיטת אריאל ‪2022‬‬
‫‪ || 1‬חישוביות‬
‫חישוביות ‪ -‬מחברת הרצאות‬

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

‫‪https://dorazaria.github.io/‬‬
‫‪:‬‬ ‫מוזמנים לעקוב אחרי 😊‬

‫‪LinkedIn: https://www.linkedin.com/in/dor-azaria/‬‬
‫‪GitHub: https://github.com/DorAzaria‬‬
‫דור עזריה‬
‫חלק א' ‪ -‬חישוביות‬

‫‪3‬‬ ‫מבוא לקורס‬
‫‪5‬‬ ‫מכונת טיורינג‬
‫‪21‬‬ ‫מכונת טיורינג אוניברסלית‬
‫‪24‬‬ ‫המחלקות ‪ R‬ו‪RE-‬‬
‫‪43‬‬ ‫רדוקציות‬
‫‪59‬‬ ‫שפות שלמות‬
‫‪63‬‬ ‫משפט רייס‬
‫‪74‬‬ ‫בעיית העצירה החסומה ‪BHP -‬‬
‫‪78‬‬ ‫מכונות טיורינג אי‪-‬דטרמיניסטיות‬
‫‪94‬‬ ‫תרגילים ‪ -‬חישוביות‬
‫חלק ב' ‪ -‬סיבוכיות‬

‫‪97‬‬ ‫מבוא לסיבוכיות‬
‫‪104‬‬ ‫המחלקות ‪ P‬ו‪NP-‬‬
‫‪131‬‬ ‫רדוקציה פולינומית‬
‫‪137‬‬ ‫שפות ‪ NP‬שלמות‬
‫‪139‬‬ ‫בעיית הספיקות ‪ -‬השפה ‪SAT‬‬
‫‪156‬‬ ‫דוגמאות לשפות ‪-NP‬שלמות‬
‫‪183‬‬ ‫בעיות חיפוש למול בעיות הכרעה‬
‫מבוא לקורס‬
‫חישוביות‬
‫בעיות שניתן לפתור על ידי מחשב‪ .‬תורת החישוביות היא הבסיס למדעי המחשב‪ ,‬והיא עוסקת במודלים לחישוב‬
‫ובפונקציות הניתנות לחישוב במסגרתם‪ .‬השאלה הבסיסית בתורת החישוביות היא‪ :‬מה מחשבים יכולים‬
‫לחשב‪ ,‬ומה לא? בניגוד להנחה נפוצה‪ ,‬ישנן פונקציות שאי אפשר לחשב‪ .‬בעיית העצירה מהווה דוגמה‬
‫לפונקציה שכזו‪ :‬ניתן להוכיח כי אין תוכנית היכולה לקבל כקלט תוכנית כלשהי וקלט לאותה התוכנית‪ ,‬ולהכריע‬
‫האם התוכנית תעצור‪.‬‬
‫סיבוכיות‬
‫נחלק את עולם הבעיות שלנו לכמה מחלקות לפי סיבוכיות זמן הריצה שלהן‪( .‬או יעילות)‪.‬‬
‫במדעי המחשב‪ ,‬סיבוכיות (באנגלית‪ )Complexity :‬היא כלי מדד מתמטי של משאבי המערכת הנחוצים‬
‫לפתרון בעיה נתונה באמצעות מחשב‪ .‬המשאב העיקרי הנבחן הוא זמן הריצה‪ ,‬כלומר נבחן משך הזמן הנחוץ‬
‫לשם ביצוע האלגוריתם‪ .‬משאב נוסף הוא הזיכרון הנחוץ לשם ביצוע האלגוריתם‪ .‬ניתן להביא בחשבון משאבים‬
‫נוספים‪ ,‬כגון כמה מעבדים נחוצים לשם פתרון הבעיה בעיבוד מקבילי‪ .‬התורה החוקרת סיבוכיות קרויה תורת‬
‫הסיבוכיות‪ .‬ענף הסיבוכיות נבדל מענף החישוביות‪ ,‬שבו נבחנת השאלה האם ניתן בכלל לפתור בעיה נתונה‪,‬‬
‫בלא קשר לכמות המשאבים הנחוצה‪.‬‬
‫מודל חישובי‬
‫מודל חישובי הוא מכונה תיאורטית עם רכיבים מסוימים (למשל‪ :‬גודל זיכרון‪ ,‬א"ב‪ ,‬סרט קלט)‪ .‬כשנדבר על‬
‫מודלים חישוביים‪ ,‬נדבר על אלגוריתם כללי לפתרון הבעיה‪ .‬באוטומטים ראינו מודלים חישוביים כגון אס"ד‪,‬‬
‫אסל"ד ואוטומט מחסנית‪ .‬בקורס זה המודל החישובי העיקרי יהיה מכונת טיורינג‪.‬‬
‫פסוקים‬
‫(‬ ‫( )‬ ‫)‬
‫נעסוק בפסוק שהוא פונקציה בוליאנית בצורת ‪ CNF‬כמו למשל‪. 𝑥1 ∨ 𝑥‾2 ∨ 𝑥4 ∧ 𝑥2 ∨ 𝑥‾3 ∨ 𝑥4 :‬‬
‫"השמה מספקת" לפסוק מגדירה האם יש דרך להציב ערכי ‪ T/F‬בכל המשתנים האלה כדי שנקבל ‪.TRUE‬‬
‫פסוק ‪CNF‬‬
‫פסוק הוא ‪ CNF‬אם הפסוק כולו הוא "וגם" של הרבה פסוקים אחרים (פסוקיות)‪.‬‬
‫כל פסוקית היא "או" של ליטרלים (משתנים אטומיים כמו למשל ‪ T‬או ‪.)F‬‬
‫נשים לב ‪ -‬השמה מספקת לפסוק ‪ ⇔ CNF‬היא מספקת כל פסוקית בו‪.‬‬
‫סוגי בעיות‬
‫ישנם שני סוגים של בעיות‪:‬‬
‫‪ .1‬בעיית קיימות ‪ -‬אנחנו רוצים לדעת אם קיים פתרון‪.‬‬
‫‪ .2‬בעיית חיפוש ‪ -‬אנחנו רוצים לדעת מה הפתרון‪.‬‬
‫אנו נעסוק בעיקר בבעיות הקיימות‪.‬‬
‫פתירות של בעיה‬
‫פתירות של בעיה היא ביחס למודל חישובי כלשהו‪ ,‬למשל מחשב או בן אדם (דף ועט)‪.‬‬
‫בעיות לא פתירות ‪ -‬הכוונה שאין פתרון כללי לבעיה‪ .‬כלומר‪ ,‬אם האלגוריתם מצליח לפתור מקרה פרטי בבעיה‬
‫זה לא אומר שקיים פתרון כללי‪.‬‬
‫בעיות פתירות ניתן לסווג ל‪"-‬קשות" או "קלות"‪ .‬הסיווג נקבע לפי זמן הריצה המינימלי לפתרון הבעיה‪.‬‬
‫זמן הריצה הוא פונקציה של אורך הקלט‪ .‬למשל עבור פסוק עם 𝑛 משתנים‪ ,‬זמן הריצה הוא )𝑛(𝑂‪.‬‬
‫בעיה קשה‬ ‫בעיה קלה‬
‫בעיה היא קשה אם כל אלגוריתם צריך זמן‬ ‫בעיה היא קלה אם קיים אלגוריתם שיודע‬
‫הגדרה‬
‫ריצה לפחות אקספוננציאלי בגודל הקלט‪.‬‬ ‫לפתור את הבעיה בזמן ריצה פולינומי‪.‬‬
‫יש להוכיח שלא קיים אף אלגוריתם פולינומי‬ ‫מספיק להראות קיימות של אלגוריתם בעל‬
‫שיטתיות‬
‫שיפתור אותה‪.‬‬ ‫זמן ריצה פולינומי ולהוכיח את זמן הריצה‪.‬‬
‫אלגוריתם שפותר בעיה מסויימת בזמן ריצה‬ ‫בעיית המסלול הטוב ביותר ‪ -‬נפתור בעזרת‬
‫𝑛‬ ‫‪3‬‬
‫דוגמה כללית‬
‫לפחות ) ‪( 𝑂(2‬אקספוננציאלי)‪.‬‬ ‫אלגוריתם ‪ Floyd-Warshall‬ב‪ 𝑂(𝑛 )-‬שאכן‬ ‫ולא מספקת‬
‫ולא קיים אלגוריתם יותר יעיל מזה‪.‬‬ ‫בזמן ריצה פולינומי‪.‬‬
‫ייצוג בעיה על ידי שפה‬

‫מכונות טיורינג תקבל כקלט קידוד > 𝑋 < של האובייקט 𝑋 עליו היא עובדת‪.‬‬
‫אובייקט 𝑋 יכול להיות גרף‪ ,‬פסוק‪ ,‬פולינום ועוד‪ ..‬והקידוד של כל אובייקט מסומן ב‪.< 𝑋 >-‬‬
‫לדוגמה ‪ -‬עבור בעיית קשירות של גרף 𝑋‪ ,‬מכונת הטיורינג 𝑀 תקבל כקלט את קידוד הגרף > 𝑋 < ואז תפעל‬
‫על הקידוד הזה‪.‬‬
‫מכונת טיורינג‬
‫מבוא‬
‫מכונת טיורינג (‪ )Turing Machine‬הוא מודל שהציע אלן טיורינג (אבי מדעי המחשב) טרם המצאת המחשב‪.‬‬
‫המכונה מתוארת באופן דמיוני כסרט אינסופי של תאים וראש קריאה בעל זיכרון סופי היכול לקרוא את תוכנו של‬
‫התא שמעליו הוא ממוקם‪ ,‬לכתוב באותו התא וכן לנוע ימינה או שמאלה על הסרט‪ .‬המכונה מקבלת את הקלט‬
‫שלה באמצעות הסרט‪ ,‬עליו היא יכולה גם לכתוב‪ ,‬ולזוז כרצונה לכל נקודה על גביו‪.‬‬
‫מכונת טיורינג (מ"ט) מתארת בצורה פורמלית‪-‬מתמטית‪ ,‬כיצד ניתן לבצע פעולות חישוביות שונות כגון זיהוי‬
‫מילים השייכות לשפה פורמלית‪ ,‬ביצוע פעולות חיפוש ומיון בקלט ועוד‪ ,‬והיא למעשה האוטומט החזק ביותר‬
‫לביצוע חישובים‪ ,‬ולמעשה לעיתים המושג "חישוב" מוגדר על סמך פעולות הניתנות לביצוע באמצעות מ"ט‪.‬‬
‫התזה של צ'רץ'‪-‬טיורינג קובעת שכל חישוב או אלגוריתם בר‪-‬ביצוע‪ ,‬ניתן לתרגם למכונת טיורינג‪ .‬מבחינה זו‪,‬‬
‫מכונת טיורינג שקולה לכל מחשב‪.‬‬
‫רכיבי מכונת טיורינג‬

‫(‬ ‫)‬
‫מכונת טיורינג 𝑀 היא שביעייה ‪ 𝑀 = 𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬כאשר‪:‬‬
‫● 𝑄 היא קבוצה סופית של מצבים כלשהם‪.‬‬
‫● ‪ 𝑞0‬מצב התחלתי‪.‬‬
‫● 𝑄 ⊆ 𝐹 הינה קבוצת המצבים הסופיים‪ .‬המכונה רצה עד שמגיעה למצב סופי 𝐹 ∈ 𝑞‪ ,‬במצב זה‬
‫המכונה תחליט אם המילה התקבלה או לא התקבלה‪.‬‬
‫● ‾𝑏 נקרא "‪ "blank‬המסמן תא ריק בסרט (לפי הגדרה ‪ .)𝑏‾ ∉ Σ‬אפשר לכתוב ‾𝑏 גם באמצע הקלט‪.‬‬
‫● ‪ Σ ⊆ Γ‬הינה א"ב הקלט‪( .‬בדר"כ }‪.)Σ = {0, 1‬‬
‫● ‪ Γ‬הינה א"ב עבודה (בדר"כ }‾𝑏 ‪.)Γ = {0, 1,‬‬
‫● ‪ δ‬היא פונקציית המעברים המוגדרת כך‪.δ: (𝑄\𝐹) × Γ → 𝑄 × Γ × {𝐿, 𝑆, 𝑅} :‬‬
‫כלומר‪ ,‬הפונקציה קוראת‪( :‬מצב לא סופי ‪,‬אות מהסרט) ועוברת ל‪( :‬מצב‪ ,‬אות מהסרט‪ ,‬צעד)‪.‬‬
‫● הקבוצה }𝑅 ‪ {𝐿, 𝑆,‬מכילה פעולות הזזה של הראש‪.𝐿 = 𝐿𝑒𝑓𝑡, 𝑆 = 𝑆𝑡𝑎𝑦, 𝑅 = 𝑅𝑖𝑔ℎ𝑡 :‬‬
‫תכונות מכונת טיורינג‬

‫‪ .1‬מ"ט 𝑀 תעצור כשתגיע למצב סופי ‪ -‬אחרת‪ ,‬עלולה לרוץ עד אינסוף‪.‬‬
‫‪ .2‬פלט המכונה‪ :‬הוא מילה * ‪ 𝑦 ∈ Γ‬שהיא רצף כל התווים על הסרט שמשמאל לראש‪.‬‬
‫‪ .3‬בקורס הזה‪ ,‬האינדקס של התא הראשון של הסרט הוא "‪ "1‬ולא "‪ "0‬כמו במערכים מוכרים בתכנות‪.‬‬
‫‪ .4‬אם מ"ט 𝑀 לא עצרה על 𝑥‪ ,‬אזי הפלט שלה לא מוגדר‪ .‬זה מאפשר חישוב של פונקציות "לא מלאות"‪,‬‬
‫כלומר פונקציות שלאוו דווקא מוגדרות לכל קלט‪.‬‬
‫‪ .5‬ישנן מכונות טיורינג המחשבות‪:‬‬
‫○ פונקציות ‪ -‬נתמקד בפלט של המכונה‪.‬‬
‫○ שפות ‪ -‬נתמקד במצב 𝐹 ∈ 𝑞 בו סיימנו (כאשר 𝑞 הוא מצב מקבל או מצב דוחה‪/‬מגעיל)‪.‬‬
‫כלומר‪ ,‬לא מעניין אותנו מה מכיל הפלט ‪ -‬העיקר שהגענו למצב סופי‪.‬‬
‫‪ .6‬נסמן את הפונקציה של מ"ט 𝑀 בתור )𝑥(𝑀𝑓‪.‬‬
‫דוגמת בנייה למכונה המזהה שפה‬

‫(‬ ‫)‬
‫בנו מכונת טיורינג ‪ 𝑀 = 𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬המזהה את השפה‪.𝑥1 ∈ {0, 1} * :‬‬
‫פתרון משולב עם הסבר‪ :‬אנחנו רוצים לוודא שהתו האחרון הוא "‪ "1‬ואז המילה מתקבלת‪.‬‬
‫אנחנו נקרא את המילה לאורך הסרט עד שנגיע ל‪ 𝑏‾-‬הראשון ואז נחזור תא אחד אחורה ונקבע ש‪:‬‬
‫● אם כתוב בתא הזה "‪ "1‬אז נעבור למצב מקבל 𝐹 ∈ 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪.‬‬
‫● אם כתוב בתא הזה "‪ "0‬אז נעבור למצב דוחה 𝐹 ∈ 𝑡𝑐𝑒𝑗𝑒𝑟𝑞‪.‬‬
‫אנחנו נכתוב טבלת מעברים עבור המכונה 𝑀 שמזהה את השפה ‪:𝑥1‬‬
‫● השורה הירוקה הם תווים ‪ γ ∈ Γ‬שנמצאים בתוך התאים של הסרט שאותו אנחנו קוראים‪.‬‬
‫● העמודה הצהובה הם מצבים לא סופיים 𝐹\𝑄 כלשהם שנטייל בהם במהלך הריצה‪.‬‬
‫לפי ההגדרה של ‪ ,δ‬היא מקבלת מצב נוכחי ואות קריאה ומחזירה לנו‪( :‬צעד הזזה לראש‪ ,‬אות כתיבה‪ ,‬מצב)‪.‬‬
‫‪Γ‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‾𝑏‬
‫𝐹\𝑄‬
‫‪𝑞0‬‬ ‫)𝑅 ‪(𝑞0, 0,‬‬ ‫)𝑅 ‪(𝑞1, 1,‬‬ ‫)𝑆 ‪(𝑞𝑟𝑒𝑗𝑒𝑐𝑡, 0,‬‬
‫‪𝑞1‬‬ ‫)𝑅 ‪(𝑞0, 0,‬‬ ‫)𝑅 ‪(𝑞1, 1,‬‬ ‫)𝑆 ‪(𝑞𝑎𝑐𝑐𝑒𝑝𝑡, 1,‬‬
‫המצב ‪ 𝑞0‬אומר שהתא האחרון מכיל ‪ 0‬ו‪ 𝑞1-‬אומר שהתא האחרון מכיל ‪ .1‬לכן‪ ,‬כשנקרא את ה‪ 𝑏‾-‬הראשון ממצב‬
‫‪ 𝑞1‬אז נשלח למצב מקבל 𝑡𝑝𝑒𝑐𝑐𝑎𝑞 ואם נקרא את ה‪ 𝑏‾-‬הראשון ממצב ‪ 𝑞0‬אז נשלח למצב דוחה 𝑡𝑐𝑒𝑗𝑒𝑟𝑞‪.‬‬
‫פונקציה של מכונת טיורינג‬

‫לכל מ"ט 𝑀 הפונקציה שלה מוגדרת כך‪.𝑓𝑀: Σ *→ Γ * :‬‬
‫לכל מילה * ‪ 𝑤 ∈ Σ‬הפונקציה )𝑤(𝑀𝑓 הינו הפלט של המכונה 𝑀 בריצתה על הקלט 𝑤‪.‬‬
‫מכיוון שמ"ט לא תמיד עוצרת‪ ,‬הפונקציה 𝑀𝑓 לא תמיד מלאה‪.‬‬
‫תזכורת ‪ -‬פונקציה מלאה היא פונקציה שמוגדרת לכל קלט‪.‬‬
‫דוגמה ‪ - 1‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫המכונה 𝑀 מקבלת 𝑥 ורושמת 𝑥‪ 0‬כלומר 𝑥‪.𝑓𝑀(𝑥) = 0‬‬
‫רעיון הבנייה‪ :‬נרשום ‪ 0‬בהתחלה‪ ,‬ובכל צעד נזכור האם לכתוב ‪ 0‬או ‪ .1‬בשונה מהדוגמה הקודמת עם השפה‪,‬‬
‫כאן אין לנו עניין של מקבל או דוחה אלא מעניין אותנו הפלט של הפונקציה‪ .‬אנחנו צריכים לסיים כשאנחנו‬
‫מגיעים ל‪ 𝑏‾-‬הראשון‪ ,‬ובדרך צריכים לדחוף כל תא צעד ימינה (‪ )shift right‬ולכתוב "‪ "0‬בתא הראשון‪.‬‬
‫לכן‪ ,‬התפקיד של המצבים ‪ 𝑞0, 𝑞1‬ישמשו אותנו כדי לדעת מה לכתוב בתא הבא בסרט בכל צעד (הזזה)‪.‬‬
‫(‬ ‫)‬
‫פורמלית‪.𝑀 = 𝑄 = {𝑞0, 𝑞1, 𝑞𝑒𝑛𝑑}, 𝑞0, 𝐹 = {𝑞𝑒𝑛𝑑}, Γ = {0, 1, 𝑏‾}, Σ = {0, 1}, 𝑏‾, δ :‬‬
‫אנחנו נכתוב טבלת מעברים עבור המכונה 𝑀 שמזהה את הפונקציה 𝑥‪.𝑓𝑀(𝑥) = 0‬‬
‫● השורה הירוקה הם תווים ‪ γ ∈ Γ‬שבתוך התאים של הסרט שאותו אנחנו קוראים‪.‬‬
‫● העמודה הצהובה הם מצבים לא סופיים 𝐹\𝑄 כלשהם שנטייל בהם במהלך הריצה‪.‬‬
‫לפי ההגדרה של ‪ ,δ‬היא מקבלת מצב נוכחי ואות לקריאה ומחזירה לנו‪( :‬צעד הזזה לראש‪ ,‬אות כתיבה‪ ,‬מצב)‪.‬‬
‫‪Γ‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‾𝑏‬
‫𝐹\𝑄‬
‫‪𝑞0‬‬ ‫)𝑅 ‪(𝑞0, 0,‬‬ ‫)𝑅 ‪(𝑞1, 0,‬‬ ‫)𝑅 ‪(𝑞𝑒𝑛𝑑, 0,‬‬
‫‪𝑞1‬‬ ‫)𝑅 ‪(𝑞0, 1,‬‬ ‫)𝑅 ‪(𝑞1, 1,‬‬ ‫)𝑅 ‪(𝑞𝑒𝑛𝑑, 1,‬‬
‫● למשל‪ ,‬אם )𝑅 ‪ δ(𝑞0, 0) = (𝑞0, 0,‬זה אומר שאם קראנו בסרט את האות ‪ 0‬ואנחנו במצב ‪ 𝑞0‬אז בתא‬
‫הבא מימין אנחנו צריכים לכתוב ‪ 0‬ולכן נשאר במצב ‪ 𝑞0‬ונזיז את הראש הקורא‪/‬כותב ימינה )𝑅( לתא‬
‫הבא בסרט‪.‬‬
‫● למשל‪ ,‬אם )𝑅 ‪ δ(𝑞0, 𝑏‾) = (𝑞𝑒𝑛𝑑, 0,‬זה אומר שאם קראנו בסרט את האות ‾𝑏 ממצב ‪ 𝑞0‬אז נכתוב‬
‫בתא הזה "‪ "0‬ואז נעבור למצב מסיים 𝑑𝑛𝑒𝑞‪ ,‬ונזוז ימינה )𝑅( לתא הבא‪ .‬אנחנו לא נשארים )𝑆( כיוון‬
‫שלפי ההגדרה‪ ,‬המילה שחוזרת מהפונקציה היא רצף התווים משמאל לראש ולכן אנחנו צריכים לזוז‬
‫צעד אחד ימינה לאחר שכתבנו את ה‪ "0"-‬כדי שנוכל להחזיר גם אותו‪.‬‬

‫בנו מכונת טיורינג 𝑀 שמחשבת את הפונקציה ‪.𝑓𝑀(𝑤) = ε‬‬
‫(‬ ‫)‬
‫פתרון‪ :‬יהי מכונת טיורינג ‪.𝑀 = 𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬‬
‫לא משנה איזה קלט * ‪ 𝑤 ∈ Σ‬הפונקציה 𝑀𝑓 תקבל‪ ,‬היא תמיד תחזיר את המילה הריקה‪.‬‬
‫לכן‪ ,‬אנחנו לא צריכים לעבור על המילה של הקלט כי הפונקציה תמיד מחזירה ערך אחד ויחיד‪.ε :‬‬
‫אנחנו נקבל כקלט את * ‪ 𝑤 ∈ Σ‬ונעבור ישר למצב סופי 𝐹 ∈ 𝑑𝑛𝑒𝑞‪.‬‬
‫הסבר‪ :‬אמרנו שלפי הגדרה‪ ,‬כש‪ 𝑀-‬מחשבת פונקציה‪ ,‬היא צריכה להחזיר את כל רצף התאים שמשמאל לראש‬
‫הכותב‪/‬קורא‪ .‬בתחילת הריצה‪ ,‬הראש תמיד מתחיל כשהוא מצביע על התא הראשון‪ ,‬לכן אם לא נזיז אותו בכלל‬
‫אז נחזיר את כל מה שמשמאלו‪ ,‬מכיוון שאין כלום משמאל אז זה אומר שנחזיר כלום כלומר ‪ ε‬כנדרש לפונקציה‪.‬‬

‫בנו מכונת טיורינג 𝑀 שהולכת תמיד ימינה מבלי לעצור‪ .‬מהי הפונקציה של המכונה שבניתם?‬
‫(‬ ‫)‬
‫פתרון‪ :‬יהי מכונת טיורינג ‪.𝑀 = 𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬‬
‫לא משנה איזה קלט * ‪ 𝑤 ∈ Σ‬אנחנו מקבלים‪ ,‬תמיד צריך ללכת ימינה ולא לעצור‪.‬‬
‫אם המכונה בריצה אינסופית (לא עוצרת לעולם) אז קבוצת המצבים הסופיים ∅ = 𝐹‪.‬‬
‫קבוצת המצבים 𝑄 מכילה רק מצב אחד }‪.𝑄 = {𝑞0‬‬
‫ומכיוון שהמכונה תמיד זזה ימינה מבלי לעצור‪ ,‬פונקציית המעברים מוגדרת כלולאה עצמית על המצב ‪𝑞0‬‬
‫כאשר ראש הסרט תמיד זז ימינה‪.δ(𝑞0, σ) = (𝑞0, σ, 𝑅) :‬‬
‫הפונקציה )𝑤(𝑀𝑓 של המכונה 𝑀 לא מוגדרת לכל קלט * ‪.𝑤 ∈ Σ‬‬

‫|𝑤|‬
‫‪.𝑓(𝑤) = 1‬‬ ‫בנו מכונת טיורינג 𝑀 המחשבת את הפונקציה‬
‫(‬ ‫)‬
‫פתרון‪ :‬יהי מכונת טיורינג ‪ .𝑀 = 𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬הפונקציה 𝑓 מקבלת קלט * ‪ 𝑤 ∈ Σ‬וממירה את 𝑤‬
‫למילה של אחדות באורך |𝑤|‪ .‬נגדיר קבוצת מצבים סופיים }𝑑𝑛𝑒𝑞{ = 𝐹 וקבוצת מצבים }𝑑𝑛𝑒𝑞 ‪.𝑄 = {𝑞0,‬‬
‫א"ב עבודה מוגדר בצורה הבאה‪. Γ = Σ ∪ {1} :‬‬
‫פונקציית המעברים של המכונה מוגדרת באופן הבא‪:‬‬
‫● לכל ‪ σ ∈ Σ‬מתקיים‪.δ(𝑞0, σ) = (𝑞0, 1, 𝑅) :‬‬
‫● עבור ‪ 𝑏‾ ∈ Γ‬מתקיים‪. δ(𝑞0, 𝑏‾) = (𝑞𝑒𝑛𝑑, 𝑏‾, 𝑆) :‬‬
‫דוגמה רצינית ‪ -‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫בנו מכונת טיורינג 𝑀 המחשבת את ‪ 𝑓𝑀(𝑥) = 𝑥 + 1‬כאשר 𝑥 נתון בייצוג בינארי‪.‬‬
‫רעיון הפתרון‪:‬‬
‫‪ .1‬נתחיל במצב ‪ ,𝑞0‬כדי לטפל במצב של הרחבת המחרוזת (‪ )Carry‬נדחוף סימון חדש ‪ $‬בתא הראשון‪.‬‬
‫‪1‬‬ ‫‪0‬‬
‫‪ .2‬נבצע ‪ Shift Right‬ל‪ 𝑥-‬אם קראנו ‪ 0‬נעבור למצב 𝑅𝑆𝑞 ואם קראנו ‪ 1‬נעבור למצב 𝑅𝑆𝑞‪.‬‬
‫‪ .3‬כשנסיים להזיז את 𝑥 ימינה‪ ,‬נעבור למצב 𝑑𝑑𝑎𝑞 שמטפל בפעולת החיבור ‪ :1 +‬נטייל שמאלה כל עוד‬
‫התא מכיל את המספר ‪ ,1‬ונחליף כל תא כזה ב‪ 0-‬עד כאשר בתא‪:‬‬
‫‪ .a‬נראה ‪ $‬אז נחליף אותו ל‪ 1-‬ואז נעבור למצב 𝑅𝑞 שמזיז את הראש ימינה עד שנפגוש את ה‪𝑏‾-‬‬
‫הראשון כדי להוציא את המספר החדש כפלט‪.‬‬
‫‪ .b‬נראה ‪ 0‬אז נשנה את התא הזה ל‪ ,1-‬אם נפגשנו ב‪ 0-‬זה אומר שאנחנו לא מרחיבים את‬
‫המחרוזת‪ ,‬כלומר ה‪ $-‬נשאר בתא הראשון וזה לא פלט תקין‪ .‬לכן נרצה לעשות ‪:shift left‬‬
‫𝑏‬ ‫‾‬
‫נעבור למצב ‪ 𝑞1‬שיקח אותנו ימינה עד ל‪ 𝑏‾-‬הראשון שיעביר אותנו ל‪.𝑞𝑆𝐿-‬‬ ‫‪.i‬‬
‫‪0‬‬
‫נזוז צעד אחד שמאלה (המספר הימני ביותר)‪ ,‬אם הוא ‪ 0‬נעבור למצב 𝐿𝑆𝑞 ואחרת‬ ‫‪.ii‬‬
‫‪1‬‬
‫נעבור למצב 𝐿𝑆𝑞 עד כאשר נפגוש את ה‪ ,$-‬נדרוס אותו במספר לפי המצב הנתון‪.‬‬
‫נעבור למצב 𝑅𝑞 שמזיז את הראש ימינה עד שנפגוש את ה‪ 𝑏‾-‬הראשון כדי להוציא את‬ ‫‪.iii‬‬
‫המספר החדש כפלט‪.‬‬
‫פתרון‪ :‬נבנה טבלת מעברים שתמדל את הבעיה‪:‬‬
‫דוגמת סימולציה‪:‬‬
‫קונפיגורציות‬
‫קונפיגורציה היא מעיין תמונת מצב במהלך ריצת המכונה ‪ -‬לפני או אחרי השלמה של פעולת חישוב ב‪.δ-‬‬
‫ניתן לתאר את ריצת מכונת טיורינג על ידי סדרת קונפיגורציות‪.‬‬
‫קונפיגורציה 𝑐 היא שלשה )𝑖 ‪ 𝑐 = (α, 𝑞,‬כאשר‪:‬‬
‫● * ‪ α ∈ Γ‬הוא מחרוזת תוכן הסרט‪( .‬עד ה‪ 𝑏‾-‬הראשון שהחל ממנו הכל רק ‾𝑏‪ ,‬לא כולל)‪.‬‬
‫● 𝑄 ∈ 𝑞 הוא המצב הנוכחי‪.‬‬
‫● ‪ 𝑖 ∈ ℕ‬הוא מיקום הראש הקורא כותב‪( .‬אינדקס)‪.‬‬
‫לדוגמה‪ :‬תוכן הסרט הוא ‪ ,α = 1001𝑏‾011‬המצב 𝑞 ומיקום הראש הכותב ‪ 𝑖 = 5‬ולכן ‾𝑏 = ‪.α𝑖 = α5‬‬
‫תוכן הסרט ‪α‬‬

‫בקונפיגורציה )𝑖 ‪ 𝑐 = (α, 𝑞,‬תוכן הסרט * ‪ α ∈ Γ‬הוא קצת מורכב‪ ,‬מכיוון שבקונפיגורציה הראשונה ‪𝑐0‬‬
‫מדובר על הקלט של המכונה‪ ,‬אבל עם התקדמות המכונה‪ ,‬ייתכן ויהיה כתוב שם תוכן שונה לחלוטין‪.‬‬
‫כלומר‪ ,‬ייתכן שנרחיב את תוכן הסרט במהלך הריצה ולכן צריך שיטה שתקבע לנו את התוכן באופן "דינמי"‪.‬‬
‫אז איך נקבע מה יהיה תוכן הסרט ‪- ?α‬‬
‫● נסמן ב‪ 𝑇-‬את מספר הצעדים שמ"ט 𝑀 ביצעה עד כה על הקלט 𝑥‪.‬‬
‫● נסמן ב‪ 𝑡-‬את האינדקס של התא הימני ביותר בו ביקרנו בסרט‪.‬‬
‫● מכיוון שבכל פעם אנחנו זזים רק צעד אחד ימינה אז מתקיים 𝑇 ≤ 𝑡‪.‬‬
‫● לכן‪ ,‬תוכן הסרט ‪ α‬יכיל את ה‪ 𝑚𝑎𝑥{𝑡, |𝑥|}-‬התאים הראשונים של הסרט‪.‬‬
‫הסבר‪ :‬מה שמעניין אותנו בסרט זה‪ :‬או הקלט או התא הכי ימני שנפגשנו בו במהלך ריצת המכונה‪.‬‬
‫מכיוון שהסרט הוא אינסופי‪ ,‬אנחנו לא צריכים את כל ה‪ 𝑏‾-‬האינסופיים איתנו ולכן הגדרנו את 𝑇 ‪ 𝑡,‬כדי "לתפוס"‬
‫את התאים הרלוונטים בלבד עבור תוכן הסרט שעלול להשתנות במהלך הריצה‪.‬‬
‫בנוסף‪ ,‬אורך תוכן הסרט הוא לא מספר קבוע כיוון שניתן לכתוב עליו במהלך הריצה ולהרחיב אותו‪.‬‬
‫סוגי קונפיגורציות‬
‫קונפיגורציה התחלתית היא )‪ 𝑐0 = (𝑥, 𝑞0, 1‬כאשר 𝑥 היא המילה אותה קיבלנו כקלט‪.‬‬
‫עבור 𝑢 תוכן הסרט הנוכחי ו‪ 𝑖-‬הוא מיקום הראש הנוכחי אז‪:‬‬

‫● קונפיגורציה מקבלת היא )𝑖 ‪.𝑐 = (𝑢, 𝑞𝑎𝑐𝑐𝑒𝑝𝑡,‬‬
‫● קונפיגורציה דוחה‪/‬מגעילה היא )𝑖 ‪.𝑐 = (𝑢, 𝑞𝑟𝑒𝑗𝑒𝑐𝑡,‬‬
‫● קונפיגורציה עוצרת (סופית) היא )𝑖 ‪ 𝑐 = (𝑢, 𝑞𝑎𝑐𝑐𝑒𝑝𝑡,‬או )𝑖 ‪ 𝑐 = (𝑢, 𝑞𝑟𝑒𝑗𝑒𝑐𝑡,‬או עם 𝐹 ∈ 𝑞 כלשהו‪.‬‬
‫צעד חישוב‬
‫צעד חישוב במכונת טיורינג המתחיל ב‪ 𝑐 = (α, 𝑞, 𝑖) -‬יבוצע בצורה הבאה‪:‬‬
‫אם )𝑑 ‪ δ(𝑞, α𝑖) = (𝑝, 𝑏,‬אז‪:‬‬
‫● נעבור ממצב 𝑞 למצב 𝑝‪.‬‬
‫● האות 𝑖‪ α‬יוחלף באות * ‪.𝑏 ∈ Γ‬‬
‫● המיקום של הראש (האינדקס) יוחלף לפי ההזזה }𝑅 ‪.𝑑 ∈ {𝐿, 𝑆,‬‬
‫אם נזוז שמאלה 𝐿 = 𝑑 אזי מעדכנים את המיקום לפי }‪( 𝑚𝑎𝑥{1 , 𝑖 − 1‬כיוון שלא ניתן לזוז שמאלה יותר‬
‫מהתא הראשון של הסרט ‪ -‬אינדקס מספר ‪ ,1‬כי הסרט חסום משמאל)‪.‬‬
‫רצף צעדי חישוב‬

‫רצף צעדי חישוב הם סדרת קונפיגורציות שעוברים עליהם במהלך ריצת מכונת טיורינג‪.‬‬
‫הגדרה‪ :‬חישוב של מ"ט 𝑀 על הקלט 𝑥 היא סדרת קונפיגורציות ‪ 𝑐0, 𝑐1,..., 𝑐𝑛−1‬המקיימת‪:‬‬
‫‪ .1‬נסמן ב‪ 𝑐0-‬את הקונפיגורציה ההתחלתית‪.‬‬
‫‪ .2‬לכל ‪ 𝑖 > 0‬מתקיים‪.𝑐𝑖−1 ⊢𝑀 𝑐𝑖 :‬‬
‫‪ .3‬אם קיימת קונפיגורציה סופית )𝑖 ‪ 𝑐 = (α, 𝑞,‬אז היא האחרונה בסדרה והפלט של 𝑀 על הקלט 𝑥‬
‫מוגדרת להיות ]‪( .α[1... 𝑖 − 1‬כי אמרנו שהפלט מוגדר ברצף התאים משמאל לראש הקורא‪/‬כותב)‪.‬‬
‫‪ .4‬אם הסדרה לא מכילה קונפיגורציה סופית‪ ,‬אזי הסדרה היא אינסופית והפלט של 𝑀 על הקלט 𝑥 לא‬
‫מוגדר‪ .‬במקרה זה נסמן כי הפלט הוא ⊥= )𝑥(𝑀𝑓‪.‬‬
‫תרגיל סדרת קונפיגורציה‬

‫|𝑤|‬
‫‪.𝑓(𝑤) = 1‬‬ ‫עבור המכונה מדוגמה ‪ 4‬של בנייה למכונת טיורינג המחשבת פונקצייה‬
‫תארו את ריצתה על הקלט ‪ 1101011‬על ידי סדרת קונפיגורציות‪:‬‬
‫פתרון‪:‬‬
‫)‪(1101011, 𝑞0, 1) ⊢𝑀 (1101011, 𝑞0, 2) ⊢𝑀 (1101011, 𝑞0, 3‬‬
‫)‪⊢𝑀(1111011, 𝑞0, 4) ⊢𝑀 (1111011, 𝑞0, 5) ⊢𝑀(1111111, 𝑞0, 6‬‬
‫)‪⊢𝑀(1111111, 𝑞0, 7) ⊢𝑀 (1111111, 𝑞0, 8) ⊢𝑀(1111111, 𝑞𝑒𝑛𝑑, 8‬‬
‫דוגמת סימולציה של מכונת טיורינג עם קונפיגורציות‬

‫נניח שאנחנו במכונה 𝑀 המחשבת את הפונקציה 𝑥 · ‪ 𝑓𝑀(𝑥) = 0‬כאשר ‪.𝑥 = 1001‬‬
‫נתונה טבלת המעברים של הפונקציה‪:‬‬
‫‪Γ‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‾𝑏‬
‫𝐹\𝑄‬
‫‪𝑞0‬‬ ‫)𝑅 ‪(𝑞0, 0,‬‬ ‫)𝑅 ‪(𝑞1, 0,‬‬ ‫)𝑅 ‪(𝑞𝑒𝑛𝑑, 0,‬‬
‫‪𝑞1‬‬ ‫)𝑅 ‪(𝑞0, 1,‬‬ ‫)𝑅 ‪(𝑞1, 1,‬‬ ‫)𝑅 ‪(𝑞𝑒𝑛𝑑, 1,‬‬
‫הקונפיגורציה ההתחלתית היא )‪.𝑐0 = (1001, 𝑞0, 1‬‬
‫כעת מכיוון ש‪ α[1] = 1 :‬אז נעבור ל‪ 𝑞1-‬אבל כיוון שאנחנו‬

‫צריכים לשרשר "‪ "0‬בתחילת המחרוזת אז נדרוס את התא הראשון ‪ α[1] = 0‬לכן‪𝑐1 = (0001, 𝑞1, 2) :‬‬
‫(דרסנו את ה‪ "1"-‬בהתחלה ושמנו במקומו את "‪.)"0‬‬
‫מכיוון שבתא ‪ α[2] = 0‬אז נעבור למצב ‪ 𝑞0‬אך לפני שנעבור‪ ,‬בגלל שאנחנו נמצאים במצב ‪ 𝑞1‬אז נדרוס‬
‫‪ α[2] = 1‬ואז נעבור למצב ‪ .𝑞0‬לכן‪.𝑐2 = (0101, 𝑞0, 3) :‬‬
‫כעת בתא ‪ α[3] = 0‬ומכיוון שאנחנו במצב ‪ 𝑞0‬אז נשאר באותו המצב‪ ,‬נכתוב ‪ α[3] = 0‬ונזוז צעד ימינה‪.‬‬
‫לכן )‪.𝑐3 = (0101, 𝑞0, 4‬‬
‫מכיוון שבתא ‪ α[4] = 1‬אז נעבור למצב ‪ 𝑞1‬אך לפני שנעבור‪ ,‬בגלל שאנחנו נמצאים במצב ‪ 𝑞0‬אז נדרוס‬
‫‪ α[4] = 0‬ואז נעבור למצב ‪ .𝑞1‬לכן‪.𝑐4 = (0100, 𝑞1, 5) :‬‬
‫כעת‪ ,‬מכיוון ש‪ α[5] = 𝑏‾ :‬אז לפי טבלת המעברים‪ ,‬אם אנחנו במצב ‪ 𝑞1‬אז נדרוס ‪ α[5] = 1‬ואז נעבור למצב‬
‫הסופי 𝑑𝑛𝑒𝑞‪ .‬כלומר‪.𝑐6 = (01001, 𝑞𝑒𝑛𝑑, 6) :‬‬
‫שקילות מודלים‬
‫לכל מודל 𝐴 של מכונת חישוב‪ ,‬נגדיר את 𝐴𝐹 להיות קבוצת כל הפונקציות הניתנות לחישוב על ידי מכונה כלשהי‬
‫מהמודל 𝐴‪ .‬אז בהינתן שני מודלים שונים 𝐵 ‪ 𝐴,‬נאמר שם שקולים אם"ם 𝐵𝐹 = 𝐴𝐹‪.‬‬
‫● מסקנה‪ :‬כדי להוכיח ששני מודלים שקולים‪ ,‬צריך להוכיח שהקבוצות של הפונקציות המתאימות לשני‬
‫המודלים שוות‪( .‬בהכלה דו כיוונית)‪.‬‬
‫דוגמה‪ :‬תהי שפה }𝑟𝑒𝑏𝑚𝑢𝑛 𝑒𝑚𝑖𝑟𝑝 𝑎 𝑓𝑜 𝑛𝑜𝑖𝑡𝑎𝑡𝑛𝑒𝑠𝑒𝑟𝑝𝑒𝑟 𝑦𝑟𝑎𝑛𝑖𝑏 𝑠𝑖 𝑝 | * }‪. 𝑃 = {𝑝 ∈ {0, 1‬‬
‫למדנו כי 𝐴𝐹𝑁 ≡ 𝐴𝐹𝐷 אבל לא שקול ל‪( 𝑃𝐷𝐴-‬אוטומט מחסנית)‪.‬‬
‫למדנו כי 𝐴𝐷𝑃 שקול לדח"ה (כלומר לשפות חסרות הקשר)‪ ,‬אבל מתברר שדח"ה לא שקול למכונת טיורינג‪.‬‬
‫באוטומטים למדנו שהשפה 𝑃 היא לא ח"ה אבל מכונת טיורינג יכולה לעשות את זה כי היא שקולה למחשב‬
‫מודרני ובמחשב קיימים אלגוריתמים שיודעים איך לפענח את השפה 𝑃 (נחלק בכל הראשוניים עד השורש)‪.‬‬
‫שקילות מכונות טיורינג‬

‫שתי מכונות טיורינג ‪ 𝑀1, 𝑀2‬יקראו שקולות אם לכל קלט * ‪ 𝑥 ∈ Σ‬התוצאה של שתי המכונות זהה‪.‬‬
‫● אם )𝑥(‪ 𝑀1‬מוגדר אז גם )𝑥(‪ 𝑀2‬מוגדר ושווה ל‪.𝑀1(𝑥)-‬‬
‫● אם )𝑥(‪ 𝑀1‬לא מוגדר אז גם )𝑥(‪ 𝑀2‬לא מוגדר‪.‬‬
‫● )𝑥( 𝑀𝑓 = )𝑥( 𝑀𝑓‪ .‬כלומר‪ ,‬אם הפלט של האחד לא מוגדר אז גם הפלט של השני לא מוגדר‪.‬‬
‫‪1‬‬ ‫‪2‬‬
‫יכולים להיות קלטים שהפלט לא מוגדר עליהם כמו למשל "פונקציות לא מלאות"‪.‬‬
‫דוגמה‪ :‬מכונת טיורינג זריזה‪ ,‬שבה מותר גם לזוז שני צעדים לכל כיוון ולא רק אחד‪.‬‬
‫רעיון ההוכחה‪ :‬כיוון אחד ‪ -‬אם יש לנו מ"ט רגילה אז היא גם זריזה פשוט לא השתמשה ב‪ 2-‬ימינה או ‪ 2‬שמאלה‪.‬‬
‫כיוון שני ‪ -‬אם יש לנו מ"ט זריזה‪ ,‬אפשר לבנות לה מ"ט רגילה עם עוד ‪ 2‬מצבים חדשים 𝐿𝑞 ‪ 𝑞𝑅,‬במסעי ‪.ε‬‬
‫איך מוכיחים שקילות מודלים בתכל'ס?‬

‫⇐ כיוון ראשון‪ :‬ניקח מכונה 𝐴𝑀 (כללית) מהמודל הראשון 𝐴‪ ,‬ונמיר אותה למכונה שקולה 𝐵𝑀 מהמודל השני 𝐵‪.‬‬
‫כלומר‪ ,‬נדאג שהפונקציה אותה המכונה החדשה מחשבת‪ ,‬זהה לפונקציה של המכונה הראשונה‪.‬‬
‫⇒ כיוון שני‪ :‬אותו הדבר רק הפוך‪( .‬ניקח מכונה מהמודל השני ונמיר למכונה שקולה מהמודל הראשון)‪.‬‬
‫הערה‪ :‬בדרך כלל אחד הכיוונים יהיה קל להוכיח והשני ידרוש מעט עבודה‪.‬‬
‫תזת צ'רץ'‪-‬טיורינג‬
‫התזה‪ :‬כל מודל כללי וסביר שקול למכונת טיורינג‪.‬‬
‫● כללי = הכוונה למודל חזק לפחות כמו מכונת טיורינג‪.‬‬
‫● סביר = הכוונה למודל שלא מכיל רכיבים אינסופיים‪.‬‬
‫שאלה‪ :‬אבל למכונת טיורינג יש רכיב אינסופי שהוא הסרט האינסופי‪.‬‬
‫תשובה‪ :‬המשמעות מבחינתנו של הסרט האינסופי‪ ,‬היא רק שבמהלך הריצה של מכונת טיורינג לא יקרה מצב‬
‫שחסר מקום אחסון‪ .‬בפועל‪ ,‬כל כמות של תווים שנוכל לכתוב על גבי הסרט היא תמיד סופית‪.‬‬
‫כלומר‪ ,‬אם נתייחס לאורך המילה כקבוע‪ ,‬תמיד נשתמש באורך סרט סופי אבל לא חסום‪.‬‬
‫שינויים אפשריים למכונת טיורינג‬

‫מה אפשר לשנות במכונת טיורינג? במהלך הקורס נעשה שינויים במכונה שיגידו לנו האם המודל החדש חזק‬
‫מדי או שהוא מודל ששקול לטיורינג רגיל‪.‬‬
‫‪ .1‬אפשר להוסיף מספר קבוע של סרטים אינסופיים‪( .‬במ"ט רגילה יש סרט אחד)‪.‬‬
‫‪ .2‬אפשר לגרום לסרט להיות אינסופי לשני הכיוונים‪.‬‬
‫‪ .3‬ניתן לעשות שינויים קלים בקבוצת הצעדים האפשריים‪.‬‬
‫‪ .4‬אפשר להוסיף מספר קבוע של ראשים קוראים‪/‬כותבים‪.‬‬
‫‪ .5‬אפשר להוסיף כל שינוי שלא כולל רכיב אינסופי‪.‬‬
‫מכונת טיורינג מרובת סרטים‬

‫עד עכשיו הגדרנו מודל יחיד של מכונת טיורינג‪.‬‬
‫נציג מכונה בעלת 𝑘 סרטים (עבור ‪.)𝑘 ≥ 1‬‬
‫● לכל סרט יש ראש קורא‪-‬כותב משלו‪.‬‬
‫● בתחילת הריצה‪ ,‬הקלט רשום בסרט מספר‬
‫‪ 1‬ושאר הסרטים ריקים (מלאים ב‪.)𝑏‾-‬‬
‫● פונקציית המעברים מוגדרת‪:‬‬
‫𝑘‬ ‫𝑘‬ ‫𝑘‬
‫}𝑅 ‪.δ: 𝑄' × Γ → 𝑄 × Γ × {𝐿, 𝑆,‬‬
‫● הפלט מוגדר להיות תוכן הסרט הראשון‬
‫בזמן העצירה‪.‬‬
‫הוכחת שקילות מ"ט רגילה עם מ"ט דו‪-‬סרטית‬

‫נסמן ב‪ 𝐹𝑀-‬את קבוצת הפונקציות שניתנות לחישוב במ"ט רגילה (עם סרט יחיד)‪.‬‬
‫נסמן ב‪ 𝐹 2-‬את קבוצת הפונקציות שניתנות לחישוב במ"ט דו‪-‬סרטית (עם ‪ 2‬סרטים)‪.‬‬
‫𝑀‬
‫𝐹‪.‬‬ ‫‪2‬‬ ‫נרצה להוכיח כי 𝑀𝐹 =‬
‫𝑀‬
‫𝐹 ⊆ 𝑀𝐹 ‪ -‬מ"ט רגילה היא בפרט מ"ט דו‪-‬סרטית רק שאינה מבצעת שימוש בסרט השני‪.‬‬ ‫‪2‬‬ ‫⇐ כיוון ראשון‬
‫𝑀‬
‫‪2‬‬
‫תהא )‪ 𝑀 = (𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬מ"ט רגילה‪ .‬נתאר את )‾‪ 𝑀 = (𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬מ"ט דו‪-‬סרטית‪.‬‬
‫אם )𝑚 ‪ δ(𝑞, σ) = (𝑞', σ',‬אז )𝑆 ‪.δ‾(𝑞, σ, τ) = (𝑞', σ', 0, 𝑚,‬‬

‫‪2‬‬
‫בעצם 𝑀 עושה אותו הדבר כמו 𝑀 ופשוט לא משתמשת בסרט השני‪.‬‬
‫‪2‬‬
‫𝐹 ‪ -‬תהא )‪ 𝑀 = (𝑄 2, 𝑞0, 𝐹 2, Γ 2, Σ 2, 𝑏‾ 2, δ 2‬מ"ט בעלת ‪ 2‬סרטים‪.‬‬ ‫‪2‬‬ ‫⇒ כיוון שני 𝑀𝐹 ⊆‬
‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬
‫‪2‬‬
‫נראה שלמ"ט רגילה )𝑀‪ 𝑀 = (𝑄𝑀, 𝑞0, 𝐹𝑀, Γ𝑀, Σ𝑀, 𝑏‾𝑀, δ‬יש את אותו "כח" כמו מכונה 𝑀‪.‬‬
‫‪. Σ𝑀 = Σ‬‬ ‫‪2‬‬ ‫𝑄 = 𝑀𝑄‪ .‬הא"ב‬ ‫‪2‬‬ ‫נתאר את 𝑀 ‪ -‬מ"ט רגילה המחשבת את אותה הפונקציה‪ :‬קבוצת המצבים‬
‫𝑀‬ ‫𝑀‬
‫הא"ב עבודה מוגדרת כך‪.Γ𝑀 = {0, 1, 𝑏‾ 2} ∪ {$1, $2, 0&, 1& , 𝑏‾&} :‬‬
‫𝑀‬
‫‪ α1 ∈ Γ‬נכתב לסרט של 𝑀 החל מה‪ 𝑏‾-‬הראשון‪ ,‬כשבסופו נצרף את האות‬ ‫‪2‬‬ ‫● תוכן הסרט ה‪: 1-‬‬
‫𝑀‬
‫המיוחדת ‪ .$1‬אם הראש של הסרט ה‪ 1-‬מצביע על האות }‾𝑏 ‪ σ ∈ {0, 1,‬אז בסרט של 𝑀 נסמנו &‪.σ‬‬
‫‪ α2 ∈ Γ‬נכתב לסרט של 𝑀 החל מה‪ 𝑏‾-‬הראשון‪ ,‬כשבסופו נצרף את האות‬ ‫‪2‬‬ ‫● תוכן הסרט ה‪: 2-‬‬
‫𝑀‬
‫המיוחדת ‪ .$2‬אם הראש של הסרט ה‪ 2-‬מצביע על האות }‾𝑏 ‪ σ ∈ {0, 1,‬אז בסרט של 𝑀 נסמנו &‪.σ‬‬
‫‪2‬‬
‫כאשר המכונה הדו‪-‬סרטית 𝑀 תבצע שינויים (הזזת הראש וכתיבה‪/‬קריאה) ב‪ 2-‬הסרטים שלה‪ ,‬אנחנו נעדכן‬
‫בהתאם גם בסרט היחיד של 𝑀 באמצעות הסימונים המיוחדים שהוספנו לה‪.‬‬
‫את התיאור הפורמלי של השינויים האלה אנחנו לא נכתוב כי זה הרבה עבודה‪.‬‬
‫דוגמה ויזואלית (לא חלק מההוכחה)‪:‬‬

‫נעתיק תחילה את תוכן הסרט הראשון‬
‫‪2‬‬
‫של 𝑀 לתחילת הסרט של 𝑀‪ .‬לאחר‬
‫מכן נסמן עם ‪ $1‬שאומר לנו "שכאן"‬
‫נגמר תוכן הסרט הראשון‪ .‬לאחר מכן‬
‫נעתיק גם את תוכן הסרט השני ל‪ 𝑀-‬וגם‬
‫לו נוסיף בסוף את ‪ .$2‬הראש של הסרט‬
‫‪2‬‬
‫הראשון של 𝑀 הצביע על תא מספר ‪ 3‬ולכן נסמן בתא ‪ 3‬של 𝑀 את &‪ .0‬באותו אופן עבור סרט מספר ‪.2‬‬
‫הוכחת שקילות מ"ט רגילה עם מ"ט ‪-k‬סרטית‬

‫נסמן ב‪ 𝐹𝑀-‬את קבוצת הפונקציות שניתנות לחישוב במ"ט רגילה (עם סרט יחיד)‪.‬‬
‫נסמן ב‪ 𝐹 𝑘-‬את קבוצת הפונקציות שניתנות לחישוב במ"ט 𝑘‪-‬סרטית (עם 𝑘 סרטים)‪.‬‬
‫𝑀‬
‫𝐹‪.‬‬ ‫𝑘‬ ‫נרצה להוכיח כי 𝑀𝐹 =‬
‫𝑀‬
‫לא נוכיח כאן באופן מלא כי זה דומה להוכחת השקילות בין מ"ט רגילה לבין מ"ט דו‪-‬סרטית שכבר הוכחנו‪.‬‬
‫𝐹 ⊆ 𝑀𝐹 ‪ -‬מ"ט רגילה היא בפרט מ"ט 𝑘‪-‬סרטית שמבצעת שימוש רק בסרט אחד בלבד‪.‬‬ ‫𝑘‬ ‫⇐ כיוון ראשון‬
‫𝑀‬
‫ההמשך דומה כמו שעשינו עם הדו‪-‬סרטית‪.‬‬
‫𝑘‬
‫𝐹 ‪ -‬תהא )𝑘 ‪ 𝑀 = (𝑄 𝑘, 𝑞0, 𝐹 𝑘, Γ 𝑘, Σ 𝑘, 𝑏‾ 𝑘, δ‬מ"ט בעלת 𝑘 סרטים‪.‬‬ ‫𝑘‬ ‫⇒ כיוון שני 𝑀𝐹 ⊆‬
‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬ ‫𝑀‬
‫עובד באותו האופן כמו שהוכחנו עבור הדו‪-‬סרטית עם שינוי קל שמעביר אותנו לכל 𝑘 כללי וקבוע‪:‬‬
‫𝑘‬
‫לכל סרט ]𝑘 ‪( 𝑖 ∈ [1,‬בסדר עולה) של המכונה 𝑀 נפעל בצורה הבאה‪:‬‬
‫● תוכן הסרט ה‪ α ∈ Γ 𝑘 : 𝑖-‬נכתב לסרט של 𝑀 החל מה‪ 𝑏‾-‬הראשון‪ ,‬כשבסופו נצרף את האות המיוחדת‬
‫𝑖‬ ‫𝑀‬
‫𝑖‪ .$‬אם הראש של הסרט ה‪ 𝑖-‬מצביע על האות }‾𝑏 ‪ σ ∈ {0, 1,‬אז בסרט של 𝑀 נסמנו &‪ σ‬בהתאם‪.‬‬
‫𝑘‬
‫כאשר המכונה ה‪ 𝑘-‬סרטית 𝑀 תבצע שינויים (הזזת הראש וכתיבה‪/‬קריאה) ב‪ 𝑘-‬הסרטים שלה‪ ,‬אנחנו נעדכן‬
‫בהתאם גם בסרט היחיד של 𝑀 באמצעות הסימונים המיוחדים שהוספנו לה‪.‬‬
‫את התיאור הפורמלי של השינויים האלה אנחנו לא נכתוב כי זה הרבה עבודה‪.‬‬
‫דוגמה ‪ -‬מ"ט דו‪-‬סרטית‬

‫נתאר מילולית מ"ט דו‪-‬סרטית שמחשבת את הפונקציה 𝑥𝑥 = )𝑥(𝑓‪.‬‬
‫נתונים ‪ 2‬סרטים‪ ,‬לפי הגדרת המכונה‪ ,‬בראשון קיים תוכן 𝑥 והשני ריק (כולו ‪.)blank‬‬
‫אנו יודעים גם שהסרט הראשון במכונה כזאת תכיל את הפלט שלנו ולכן נרצה לכתוב לתוכה את התשובה‪.‬‬
‫‪ .1‬כתוב את הסימן המיוחד ‪ $‬בתחילת הסרט השני‪.‬‬
‫‪ .2‬עבור על 𝑥 בסרט ‪ 1‬והעתק אותו במקביל לסרט ‪.2‬‬
‫‪ .3‬החזר את הראש בסרט ‪ 2‬לתחילת ה‪ 𝑥-‬באמצעות הסימן המיוחד ‪.$‬‬
‫‪ .4‬העתק את 𝑥 מסרט ‪ 2‬להמשך סרט ‪.1‬‬
‫‪ .5‬החזר את כל התוכן שנמצא משמאל לראש של סרט ‪.1‬‬
‫מכונת טיורינג עם קבוצת מצבים אינסופית‬

‫נגדיר מודל אינסופי * 𝑀 הזהה למכונת טיורינג הרגילה אבל שקבוצת המצבים יכולה להיות אינסופית‪.‬‬
‫טענה‪ :‬המודל לא שקול למכונת טיורינג‪.‬‬
‫הסבר‪ :‬כל פונקציה הינה רשימה אינסופית של מחרוזות‪ .‬אזי‪ ,‬בהינתן פונקציה כלשהי‪ ,‬ניתן לשמור את כל‬
‫המחרוזות המתאימות באינסוף המצבים הנתונים לנו‪ .‬בנוסף אמרנו שלפי התזה של טיורינג‪ ,‬כל הרכיבים‬
‫צריכים להיות סופיים‪ ,‬אבל הרכיב "קבוצת המצבים" היא אינסופית ולכן מראש היא לא שקולה למ"ט רגילה‪.‬‬
‫דוגמה למודל אינסופי‪ :‬קבוצה המצבים של * 𝑀 היא }‪.𝑄 = {𝑞ε, 𝑞0, 𝑞1, 𝑞00, 𝑞01, 𝑞10, 𝑞11,....‬‬
‫כל מצב כזה "זוכר" את הפלט שמתאים לו‪ ,‬כאשר נקרא את המילה נוכל לעבור בין המצבים לפי המילה‬
‫שקראנו‪ .‬ולבסוף‪ ,‬כאשר נגיע לרווח הראשון (‪ )blank‬נדע שסיימנו לקרוא את המילה ונחזיר את הפלט שהמצב‬
‫שהגענו אליו זוכר‪ .‬כלומר‪ ,‬נחזור לתחילת הסרט ונכתוב את הפלט המתאים‪.‬‬
‫מכונת טיורינג זריזה‬

‫מכונה זו מוגדרת בדומה למכונת טיורינג רגילה‪ ,‬רק שאפשר לבצע בה גם שני צעדים ימינה ושני צעדים‬
‫שמאלה‪ .‬פונקציית המעברים שלה מוגדרת כך‪.δ: (𝑄\𝐹) × Γ → 𝑄 × Γ × {𝐿𝐿, 𝐿, 𝑆, 𝑅, 𝑅𝑅} :‬‬
‫טענה‪ :‬מודל מכונת טיורינג זריזה שקול למודל מכונת טיורינג רגילה‪.‬‬
‫רעיון ההוכחה‪ :‬על מנת להוכיח שקילות מודלים‪ ,‬ניקח מכונה הפועלת במודל אחד ונראה מכונה שקולה לה‬
‫במודל השני‪ ,‬ולהיפך‪( .‬כמו שעשינו בשקילות מודלים באוטומטים)‪.‬‬
‫הוכחה‪:‬‬
‫⇐ כיוון ראשון‪ :‬תהי 𝑀 מכונת טיורינג רגילה‪ .‬נבנה מכונת טיורינג זריזה '𝑀 שתחשב את אותה הפונקציה ש‪𝑀-‬‬
‫מחשבת‪ .‬נשים לב ש‪ 𝑀-‬מתאימה למודל של מ"ט זריזה‪ ,‬פשוט לא משתמשת באפשרויות 𝑅𝑅 ו‪ ,𝐿𝐿-‬לכן נוכל‬
‫לבחור 𝑀 = '𝑀‪.‬‬
‫⇒ כיוון שני‪ :‬תהי '𝑀 מכונת טיורינג זריזה‪ ,‬נבנה מ"ט 𝑀 רגילה שתחשב את אותה הפונקציה ש‪ 𝑀'-‬מחשבת‪,‬‬
‫כלומר שהיא תמדל את התוסף של 𝑅𝑅 ‪ .𝐿𝐿,‬נגדיר אותה כך‪.𝑀 = (𝑄, 𝑞 , 𝐹, Γ, Σ, 𝑏‾, δ) :‬‬
‫‪0‬‬
‫את רוב הרכיבים אין צורך לשנות מלבד ‪.𝑄, δ‬‬
‫המוטיבציה שלנו היא "לזכור" כשהמכונה הזריזה '𝑀 רוצה לזוז שני צעדים באותו כיוון‪ ,‬ותיישם זאת‪.‬‬
‫עבור קבוצת המצבים‪ ,‬על כל מצב '𝑄 ∈ 𝑖𝑞 במכונה הזריזה נוסיף לו ‪ 2‬מצבים חדשים 𝑅𝑖𝑞 ‪ 𝑞𝑖𝐿,‬במכונה‬
‫הרגילה‪ .‬כלומר נגדיר כך‪:‬‬
‫𝑅𝑄 ∪ 𝐿𝑄 ∪ '𝑄 = ‪𝑄 :‬‬
‫}'𝑄 ∈ 𝑖𝑞 | 𝐿𝑖𝑞{ = ‪𝑄𝐿:‬‬
‫}'𝑄 ∈ 𝑖𝑞 | 𝑅𝑖𝑞{ = ‪𝑄𝑅:‬‬
‫עבור פונקציית המעברים ‪:δ‬‬
‫● בכל פעם שפונקציית המעברים של הזריזה '‪ δ‬משתמשת ב‪ 𝐿, 𝑅, 𝑆-‬אז נגדיר את הפונקציה‪:‬‬
‫)𝑎 ‪δ(𝑞, 𝑎): = δ'(𝑞,‬‬

‫● בכל פעם שפונקציית המעברים של הזריזה '‪ δ‬משתמשת ב‪ 𝐿𝐿, 𝑅𝑅-‬אז נגדיר את הפונקציה‪:‬‬
‫)𝐿 ‪δ'(𝑞, 𝑎) = (𝑞𝑖, 𝑏𝑖, 𝐿𝐿) → δ(𝑞𝑖, 𝑎) = (𝑞𝑖𝐿, 𝑏𝑖,‬‬
‫)𝑅 ‪δ'(𝑞, 𝑎) = (𝑞𝑖, 𝑏𝑖, 𝑅𝑅) → δ(𝑞𝑖, 𝑎) = (𝑞𝑖𝑅, 𝑏𝑖,‬‬
‫וכך "נזכור" את ההזזה הנוספת שיש לנו להשלים‪.‬‬
‫ההשלמה תעשה כך‪ :‬לכל 𝑖𝑞 ולכל 𝑎 נבצע‪:‬‬
‫)𝐿 ‪δ(𝑞𝑖𝐿, 𝑎) = (𝑞𝑖, 𝑎,‬‬
‫)𝑅 ‪δ(𝑞𝑖𝑅, 𝑎) = (𝑞𝑖, 𝑎,‬‬
‫תרגיל בית ‪ -‬שקילות מכונות‬

‫תהי מ"ט '𝑀 בעלת הכיוונים‪ {𝑆, 𝑅𝑖𝑔ℎ𝑡, 𝑅𝑒𝑠𝑒𝑡} :‬כאשר 𝑡𝑒𝑠𝑒𝑅 מחזירה את הראש לתא הראשון (‪.)1‬‬
‫האם '𝑀 שקולה למ"ט 𝑀 רגילה?‬
‫הכוונה‪ :‬כדי להפריך‪ ,‬מספיקה שפה אחת שניתן להכריע בעזרת אחת מהן ולא בעזרת השנייה‪.‬‬
‫כדי להוכיח‪ ,‬יש להראות איך מבצעים 𝑡𝑓𝑒𝐿 במודל החדש‪.‬‬
‫הוכחה דו כיוונית‪:‬‬
‫⇐ כיוון ראשון '𝑀𝐹 ⊆ 𝑀𝐹‪ :‬תהי 𝑀 מכונת טיורינג רגילה‪ .‬נבנה מכונת טיורינג '𝑀 שתחשב את אותה הפונקציה‬
‫ש‪ 𝑀-‬מחשבת‪ .‬קבוצת המצבים }𝑡𝑓𝑒𝐿𝑞{ ∪ 𝑀𝑄 = '𝑀𝑄‪ ,‬קבוצת המצבים הסופיים '𝑀𝐹 = 𝑀𝐹 וגם '𝑀‪.Σ𝑀 = Σ‬‬
‫א"ב עבודה יתואר באופן הבא‪.Γ𝑀' = {0, 1, 𝑏‾} ∪ {0&, 1&, 𝑏‾&} :‬‬
‫הראש הכותב של הסרט של 𝑀 שמצביע על האות 𝑀‪ σ ∈ Γ‬יוחלף באותו מקום בסרט של '𝑀 עם הסימון &‪.σ‬‬
‫● כאשר 𝑀 מפעיל צעד 𝑡𝑓𝑒𝐿 אז נכתוב בתא שלאחר ההזזה את &‪ .σ‬נעבור ב‪ 𝑀' -‬למצב 𝑡𝑓𝑒𝐿𝑞 שמבצע‬
‫𝑡𝑒𝑠𝑒𝑅 לראש ואז יבצע חיפוש מימין 𝑡‪ 𝑅𝑖𝑔ℎ‬עד שיפגוש את התא שמסומן ב‪ σ&-‬ואז נעבור ממצב‬
‫𝑡𝑓𝑒𝐿𝑞 לאותו מצב ש 𝑀 נמצא בו‪.‬‬
‫● כאשר 𝑀 מפעיל צעד 𝑡‪ 𝑅𝑖𝑔ℎ‬או 𝑆 אז '𝑀 יפעל באופן שווה כי הפעולות האלו קיימות גם בו‪.‬‬
‫⇒ כיוון שני 𝑀𝐹 ⊆ ‪ :𝐹𝑀,‬תהי '𝑀 מ"ט החדשה‪ .‬נבנה מ"ט 𝑀 רגילה שתחשב את אותה הפונקציה ש‪𝑀'-‬‬
‫מחשבת‪ .‬כל הרכיבים שווים מלבד פונקציית המעברים וקבוצת המצבים }𝑡𝑒𝑠𝑒𝑅𝑞{ ∪ '𝑀𝑄 = 𝑀𝑄‪.‬‬
‫● כאשר '𝑀 מפעיל צעד 𝑡𝑒𝑠𝑒𝑅‪ ,‬נעבור ב‪ 𝑀-‬למצב 𝑡𝑒𝑠𝑒𝑅𝑞 שמזיז את הראש עם צעדי 𝑡𝑓𝑒𝐿 עד שנגיע‬
‫לתחילת הסרט‪ .‬כשנגיע להתחלה‪ ,‬נעבור ממצב 𝑡𝑒𝑠𝑒𝑅𝑞 לאותו המצב ש‪ 𝑀'-‬נמצא בו‪.‬‬
‫● כאשר '𝑀 מפעיל צעד 𝑡‪ 𝑆, 𝑅𝑖𝑔ℎ‬אז נפעל באופן בשווה גם במודל 𝑀‪.‬‬
‫השוואה בין מ"ט לבין אוטומטים פשוטים‬

‫ראינו שמ"ט הוא מודל חזק יותר משפות ח"ה ולכן גם משפות רגולריות‪.‬‬
‫𝑛 𝑛‬
‫בקורס אוטומטים למדנו כי השפה }‪ 𝐿 = {0 1 | 𝑛 > 0‬לא רגולרית ולכן לא ניתן לבנות לה אוטומט‬
‫𝐴𝐹𝑁 ‪ 𝐷𝐹𝐴,‬וכו'‪ ...‬בנוסף למדנו שאפשר לבנות לשפה הזאת אוטומט מחסנית ששקול לדח"ה (שפות ח"ה)‪.‬‬
‫אם כך‪ ,‬בהכרח אפשר לבנות מודל ממ"ט שמקבל את השפה הזאת כי מ"ט חזק יותר משפות ח"ה‪.‬‬
‫נתאר מ"ט המכריעה את השפה 𝐿‪ ,‬אנחנו נתאר כמקובל במבחנים של הקורס‪ :‬באמצעות פסואדו‪-‬קוד‪.‬‬
‫למה פסאודו‪-‬קוד? ‪ -‬כי הוא ניתן לחישוב על ידי מחשב ⇐ ניתן לחישוב על ידי מכונת טיורינג‪.‬‬
‫𝑛 𝑛‬
‫פסאודו‪-‬קוד‪ :‬מכונת טיורינג המכריעה את }‪.𝐿 = {0 1 | 𝑛 > 0‬‬
‫𝑚 𝑛‬
‫בדוק כי המילה מהצורה ‪ 0 1‬כאשר 𝑚 ≠ 𝑛‪ ,‬אחרת ‪ -‬דחה‪.‬‬ ‫‪1‬‬
‫סמן את האות הראשונה של המילה ב‪.𝑥-‬‬ ‫‪2‬‬
‫הזז את הראש ימינה עד שתגיע ל‪ 1-‬הראשון וסמן אותו ב‪ - 𝑦-‬אם לא נמצא "‪ "1‬כזה‪ ,‬דחה‪.‬‬ ‫‪3‬‬
‫לולאה‪ :‬חזור שמאלה עד לתא שמימין ל‪ 𝑥-‬הימני ביותר ותקבע‪:‬‬ ‫‪4‬‬
‫אם התא הזה מכיל את המספר ‪ 0‬אז סמנו ב‪ 𝑥-‬וחזור לשלב ‪.3‬‬ ‫‪4.1‬‬
‫אם התא הזה מסומן ב‪ 𝑦-‬אז זוז ימינה עד לסוף המילה‪.‬‬ ‫‪4.2‬‬
‫אם נפגשת ב‪ "1"-‬במהלך הריצה ימינה עד לסוף המילה ‪ -‬דחה‪.‬‬ ‫‪4.2.1‬‬
‫קבל‪.‬‬ ‫‪5‬‬
‫● בשלב ‪ - 4.1‬אם סימנו את ‪ 0‬ב‪ 𝑥-‬ועברנו לשלב ‪ 3‬ולא מצאנו "‪ "1‬מתאים עבורו זה אז |‪ |0| > |1‬ונדחה‪.‬‬
‫● בשלב ‪ - 4.2.1‬אם התא הזה מסומן ב‪ y-‬זה אומר שסיימנו לסמן את כל האפסים ב‪ 𝑥-‬ולכן נותר לנו רק‬
‫לבדוק ש‪ …|0| = |1| :‬אם במהלך הריצה ימינה לסוף המילה נפגשנו ב‪ 1-‬אז |‪ |0| < |1‬ונדחה‪.‬‬
‫דוגמה ויזואלית‪:‬‬
‫מכונת טיורינג אוניברסלית‬

‫קידודים‬
‫קלט למכונת טיורינג הוא מחרוזת של סימנים * ‪ .𝑥 ∈ Σ‬נרצה אלגוריתמים שיעבדו על מכונות טיורינג‪ ,‬גרפים‪,‬‬
‫מטריצות‪ ,‬פולינומים ועוד ולכן נרצה לבחור קידוד > 𝑋 < לאובייקט 𝑋‪.‬‬
‫מכונת טיורינג אוניברסלית‬

‫מכונת טיורינג אוניברסלית היא המחשב‬
‫המודרני של היום‪ .‬עד עכשיו‪ ,‬חשבנו על מכונת‬
‫טיורינג 𝑀 כעל ייצוג של אלגוריתם ‪ -‬במחשב‬
‫"אמיתי"‪ ,‬המקבילה שלה היא תוכנה‪ .‬מכונת‬
‫טיורינג אוניברסלית 𝑈 היא‪ ,‬אם כן‪ ,‬גם כן תוכנה‬
‫‪ -‬אבל תוכנה מסוג מיוחד‪" :‬מערכת הפעלה"‪.‬‬
‫הקלט של מכונת טיורינג אוניברסלית 𝑈 הוא‬
‫קידוד של מכונת טיורינג כלשהו‪ ,𝑀 ,‬וקלט כלשהו‪ .𝑥 ,‬מה שהמכונה האוניברסלית 𝑈 עושה הוא ל”הריץ” את 𝑀‬
‫על 𝑥 (כלומר‪ ,‬לבצע סימולציה או "סימלוץ" של 𝑀 על 𝑥 ולענות כמוהו)‪.‬‬
‫נרצה לבנות מכונת טיורינג כללית שתוכל לבצע את המשימה של כל מכונת טיורינג אחרת‪.‬‬
‫כלומר‪ ,‬יהיו לנו כל מיני מכונות 𝑀 שמריצות אלגוריתמים‪ ,‬אנחנו נרצה מכונה כללית 𝑈 שתפעיל אותם‪.‬‬
‫מכונת טיורינג אוניברסלית 𝑈 צריכה לקבל קידוד של מכונה 𝑀 ואת הקלט * ‪ 𝑥 ∈ Σ‬עבור 𝑀 ותחזיר )𝑥(𝑀‪.‬‬
‫כלומר‪ ,‬נרצה שיתקיים‪:‬‬
‫)𝑥(𝑀 = )> 𝑥 ‪𝑈(< 𝑀,‬‬
‫על מנת לייצג מ"ט באופן נוח‪ ,‬נרצה לקודד אותה בצורת מחרוזת מעל הא"ב }‪.{0, 1‬‬
‫דרישות מקידוד > 𝑀 < של מכונת טיורינג‪:‬‬
‫‪ .1‬יהיה ניתן לשחזר את המכונה 𝑀 בהינתן הקידוד שלה > 𝑀 <‪.‬‬
‫‪ .2‬יהיה ניתן "להריץ" או "לסמלץ" את המכונה בהינתן הקידוד שלה > 𝑀 < על הקלט שלה > 𝑥 <‪.‬‬
‫מקבילה בעולם שלנו‬ ‫מונח‬
‫מחשב מודרני ‪ /‬מערכת ההפעלה‬ ‫מכונת טיורינג אוניברסלית ‪𝑈 -‬‬
‫אלגוריתם ספציפי במחשב ‪ /‬תוכנה‬ ‫מכונת טיורינג רגילה ‪𝑀 -‬‬
‫קידוד של מכונת טיורינג‬

‫אמרנו שמ"ט אוניברסלית 𝑈 מקבלת קידוד של מ"ט 𝑀‪ .‬כעת נראה שניתן לקודד מ"ט 𝑀 למחרוזת‪.‬‬
‫(‬ ‫)‬
‫● תהי שביעייה‪.𝑀 = 𝑄, Σ, Γ, δ, 𝑞0, 𝐹 = {𝑞𝑎𝑐𝑐𝑒𝑝𝑡, 𝑞𝑟𝑒𝑗𝑒𝑐𝑡}, 𝑏‾ :‬‬
‫● נניח בלי הגבלת הכלליות שמ"ט 𝑀 היא מהצורה הבאה‪:‬‬
‫}𝑠𝑏 ‪𝑄 = {𝑞1, 𝑞2 , . . . , 𝑞𝑚} , Σ = {𝑎1, 𝑎2, . . . , 𝑎𝑘} , Γ = {𝑏1, 𝑏2 , . . . ,‬‬
‫כאשר 𝑡𝑐𝑒𝑗𝑒𝑟𝑞 ‪ 𝑞0, 𝑞𝑎𝑐𝑐𝑒𝑝𝑡,‬הם ‪ 𝑞1, 𝑞2, 𝑞3‬בהתאם‪.‬‬
‫כאשר ‾𝑏 ‪ 𝑎1, 𝑎2,..., 𝑎𝑘,‬הם ‪ 𝑏1, 𝑏2,..., 𝑏𝑘, 𝑏𝑘+1‬בהתאם‪.‬‬

‫● נקודד‪.𝐿 = 1 , 𝑅 = 2 , 𝑆 = 3 :‬‬
‫𝑝‬ ‫𝑏‬
‫> )𝑎 ‪.< δ(𝑞,‬‬ ‫● לכל )𝑆𝑅𝐿 ‪ δ(𝑞, 𝑎) = (𝑝, 𝑏,‬נקודד בצורה הבאה‪= 1 01 123 :‬‬
‫● נפריד כל שני מעברי ‪ δ‬שונים על ידי ‪.00‬‬
‫לכן‪ ,‬הקידוד של המכונה 𝑀 מתואר באופן הבא‪:‬‬
‫|𝑄|‬ ‫|‪|Γ‬‬ ‫|‪|Σ‬‬

‫‪< 𝑀 >= 1 01 01 0 < δ(𝑞1, 𝑏1) > 00 ... 00 < δ(𝑞𝑚, 𝑏𝑠 ) > 00‬‬
‫קידוד הקלט ‪x‬‬

‫במכונת טיורינג אוניברסלית נרצה שיתקיים )𝑥(𝑀 = )> 𝑥 ‪.𝑈(< 𝑀,‬‬
‫עד עכשיו‪ ,‬קידדנו את המכונה 𝑀‪ ,‬אבל צריך בנוסף לקודד גם את 𝑥‪.‬‬
‫נשים לב שייתכן ש‪ Σ𝑈 ≠ Σ𝑀 :‬ואז הקלט של 𝑀 מורכב מתווים שזרים למכונה 𝑈 וזה בעיה‪ ,‬איך 𝑈 תתמודד?‬
‫אז את ה‪ 𝑥 ∈ Σ𝑀 * -‬צריך לקודד בצורה כזו שגם 𝑈 תוכל להריץ‪ ,‬לכן 𝑥 צריך להיות בא"ב 𝑈‪.Σ‬‬
‫כלומר‪ ,‬הקלט יהיה בדרך ככל בצורה הבאה‪ < 𝑀 >< 𝑥 > :‬ולא 𝑥 > 𝑀 <‪.‬‬
‫הרי אמרנו שיהיה ניתן לשחזר את המכונה 𝑀 בהינתן הקידוד שלה > 𝑀 <‪ ,‬לכן נרצה שהמכונה 𝑈 תדע לקרוא‬
‫את המחרוזת 𝑥 ולכן נקודד אותה בשביל ש‪ 𝑈-‬תדע לקרוא אותה‪.‬‬
‫התאמת מכונות להרצה במ"ט אוניברסלית‬

‫צריך עדיין להוכיח שקיימת מכונה אוניברסלית 𝑈 שיכולה לשחזר את הפעולה של כל מכונה שנתונה לה בתור‬
‫קידוד‪ .‬כלומר המכונה 𝑈 יכולה "לחקות" את ריצת 𝑀 על 𝑥‪:‬‬
‫‪ .1‬המכונה 𝑈 תשמור את הקונפיגורציה ההתחלתית של 𝑀 בסרט נוסף (או בסוף הקלט של > 𝑀 <)‪.‬‬
‫ראינו שמ"ט עם 𝑘 סרטים שקולה למכונה רגילה עם סרט אחד‪ ,‬לכן אפשר לעבוד עם סרט נוסף‪.‬‬
‫‪ .2‬המכונה 𝑈 תשמור סימן מיוחד שמציין את מיקום הראש הקורא‪/‬כותב‪.‬‬
‫‪ .3‬בכל שלב‪ ,‬המכונה 𝑈 תעדכן את הקונפיגורציה הנוכחית של 𝑀‪ ,‬שנמצאת בסרט השני לפי ההוראות‬
‫הנתונות בפונקציית המעברים ‪ δ‬שנמצאות כבר בקידוד שהכנו ל‪.𝑀-‬‬
‫‪ .4‬כאשר המכונה 𝑈 תזהה מצב סופי של 𝑀 (𝑀 עצרה) אז היא גם תעצור‪ ,‬ותחזיר את הפלט של 𝑀‪.‬‬
‫טיפול בקידוד לא תקין‬

‫מה קורה אם > 𝑀 < לא תקין? ‪ -‬יש שתי גישות עיקריות‪:‬‬
‫‪ .1‬יחסית קל לבדוק בתחילת האלגוריתם אם הקלט תקין‪ ,‬לכן אפשר להניח שהקלט תקין‪.‬‬
‫‪ .2‬לכל קידוד של מכונה שאיננו תקין‪ ,‬נתייחס בתור המכונה 𝑀𝐴𝑇𝑆𝑀 העוברת מיידית למצב 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪.‬‬
‫כלומר‪ ,‬כל מחרוזת בינארית שאיננה ניתנת לפירוש כקידוד של > 𝑀 <‪ ,‬נבין אותה כקידוד של מכונת‬
‫טיורינג 𝑀𝐴𝑇𝑆𝑀 שעוצרת מיד (עוברת למצב 𝑡𝑐𝑒𝑗𝑒𝑟𝑞)‪.‬‬
‫ריצת מ"ט אוניברסלית‬

‫כיצד המכונה 𝑈 תרוץ? ‪ -‬אנחנו נבנה מ"ט המממשת את 𝑈‪.‬‬
‫להלן סקיצה של מימוש מסוים‪ ,‬וזה יהיה "המכונה האוניברסלית" שעוד נפגוש המון בקורס‪:‬‬
‫● המכונה האוניברסלית 𝑈𝑀 על הקלט > 𝑥 ‪:< 𝑀,‬‬
‫○ אם הקידוד > 𝑥 < לא חוקי אז נבצע לולאה אינסופית (נתקע במצב מסוים שהוא לא סופי)‪.‬‬
‫○ נכתוב על הסרט השני את הקונפיגורציה )> 𝑐 < ‪ (< 𝑀 >,‬כאשר > 𝑐 < היא ‪ 𝑐0‬של 𝑀‪.‬‬
‫○ כל עוד 𝑐 לא קונפיגורציה סופית‪ ,‬נחשב את )> 𝑐 < ‪ 𝑁𝐸𝑋𝑇(< 𝑀 >,‬ונכתוב אותה בתור‬
‫הקונפיגורציה הנוכחית (עדכון של 𝑐 הקודמת)‪( .‬ראינו שהעדכון נקבע לפי ‪ δ‬של 𝑀)‪.‬‬
‫○ אם 𝑐 קונפיגורציה סופית‪ ,‬אז נפלוט את קידוד הפלט המיוצג על ידי 𝑐‪.‬‬
‫● המכונה 𝑈𝑀 מבצעת סימולציה צעד אחרי צעד של ריצת 𝑀 על הקלט 𝑥‪.‬‬
‫כלומר‪ ,‬בכל שלב נפעיל את ‪ δ‬ונעדכן בהתאם את הקונפיגורציה ‪ -‬ככה עד שנגיע לקונפ' סופית‪.‬‬
‫המחלקות ‪ R‬ו‪RE-‬‬
‫תזכורת ‪ -‬מ"ט לקבלת שפות‬
‫תזכורת‪ :‬שפה 𝐿 הינה תת קבוצה סופית או אינסופית של * ‪.Σ‬‬
‫הגדרה‪ :‬מכונת טיורינג לקבלת שפות הינה מכונת טיורינג רגילה שמקיימת }𝑗𝑒𝑟𝑞 ‪.𝐹 = {𝑞𝑎𝑐𝑐,‬‬
‫● המצב 𝑐𝑐𝑎𝑞 הינו מצב סופי שמשמעותו היא שהמכונה מקבלת את הקלט שלה‪.‬‬
‫● המצב 𝑗𝑒𝑟𝑞 הינו מצב סופי שמשמעותו היא שהמכונה דוחה את הקלט שלה‪.‬‬
‫הערה‪ :‬גם למכונה לקבלת שפות יש פלט כמו שהוגדר במודל המקורי‪ ,‬אבל לרוב לא נתייחס אליו‪.‬‬
‫שפה של מכונה‬
‫בהינתן מכונה 𝑀 עם הקלט שלה * ‪ 𝑥 ∈ Σ‬אז‪:‬‬
‫● אם המכונה 𝑀 בריצתה על 𝑥 נעצרת על מצב 𝑐𝑐𝑎𝑞‪ ,‬נאמר ש‪ 𝑀-‬מקבלת את 𝑥 ונסמן ב‪.𝑀(𝑥) = 1 -‬‬
‫● אם המכונה 𝑀 בריצתה על 𝑥 נעצרת על מצב 𝑗𝑒𝑟𝑞‪ ,‬נאמר ש‪ 𝑀-‬דוחה את 𝑥 ונסמן ב‪.𝑀(𝑥) = 0 -‬‬
‫● אם המכונה לא עצרה ‪ -‬הפלט לא מוגדר‪.‬‬
‫הגדרה‪ :‬שפת המכונה )𝑀(𝐿 הינה קבוצת כל המילים אשר המכונה 𝑀 מקבלת אותם (‪.)𝑀(𝑥) = 1‬‬
‫הגדרה‪ :‬השפה המשלימה )𝑀(𝐿\ * ‪ 𝐿(𝑀) = Σ‬היא קבוצת כל המילים ש‪ 𝑀-‬דוחה או לא עוצרת‪.‬‬
‫ההבדל בין קבלת שפות להכרעת שפות‬

‫הגדרה ‪ :1‬בהינתן שפה * ‪ ,𝐿 ⊆ Σ‬נאמר שמכונה 𝐿𝑀 מקבלת (מזהה) את השפה 𝐿 אם מתקיים‪:‬‬
‫‪𝑥 ∈ 𝐿 ↔ 𝑀(𝑥) = 1‬‬
‫נקודה חשובה להגדרה ‪ :1‬אם 𝐿 ∉ 𝑥 אז ‪ 𝑀(𝑥) = 0‬או )𝑥(𝑀 לא עוצרת לעולם‪.‬‬
‫הגדרה ‪ :2‬בהינתן שפה * ‪ ,𝐿 ⊆ Σ‬נאמר שמכונה 𝐿𝑀 מכריעה את השפה 𝐿 אם מתקיים‪:‬‬

‫‪𝑥 ∈ 𝐿 ↔ 𝑀(𝑥) = 1‬‬
‫ובנוסף‪ 𝑀𝐿 ,‬תמיד עוצרת‪.‬‬
‫נקודה חשובה להגדרה ‪ :2‬המכונה תמיד תעצור עבור כל מילה 𝐿 ∉ 𝑥 ותחזיר ‪.𝑀(𝑥) = 0‬‬
‫הוכחת נכונות של שוויון מהצורה 𝐿 = )𝑀(𝐿‬

‫בהינתן שפה 𝐿‪ ,‬שבנינו לה מכונה 𝑀‪ ,‬נצטרך להוכיח 𝐿 = )𝑀(𝐿 (כלומר‪ ,‬ששפת המכונה היא אכן השפה 𝐿)‪.‬‬
‫בתרגילים שנרצה להוכיח 𝐿 = )𝑀(𝐿‪ ,‬אנחנו נוכיח את הטענה הבאה (תלוי אם היא מקבלת או מכריעה)‪:‬‬
‫טענה‪ 𝐿(𝑀) = 𝐿 :‬אם לכל * ‪ 𝑥 ∈ Σ‬מתקיים )𝑀(𝐿 ∈ 𝑥 ↔ 𝐿 ∈ 𝑥 ‪.‬‬

‫● מבנה ההוכחה עבור מכונה מקבלת‪:‬‬
‫○ כל מילה 𝐿 ∈ 𝑥 נרצה להראות את הפלט‪ 𝑀(𝑥) = 1 :‬כלומר )𝑀(𝐿 ∈ 𝑥‪.‬‬
‫○ כל מילה 𝐿 ∉ 𝑥 נרצה להראות ש‪ 𝑀(𝑥) = 0 :‬או ש‪ 𝑀(𝑥)-‬לא מוגדר כלומר )𝑀(𝐿 ∉ 𝑥‪.‬‬
‫● מבנה ההוכחה עבור מכונה מכריעה‪:‬‬
‫○ כל מילה 𝐿 ∈ 𝑥 נרצה להראות את הפלט‪ 𝑀(𝑥) = 1 :‬כלומר )𝑀(𝐿 ∈ 𝑥‪.‬‬
‫○ כל מילה 𝐿 ∉ 𝑥 נרצה להראות את הפלט‪ 𝑀(𝑥) = 0 :‬כלומר )𝑀(𝐿 ∉ 𝑥‪.‬‬
‫המחלקות ‪ R‬ו‪RE-‬‬
‫הגדרה‪ :‬מחלקה 𝑅 היא קבוצה שמכילה את כל השפות שקיימות עבורן מכונת טיורינג המכריעה אותן‪.‬‬
‫}𝑡𝑢𝑝𝑛𝑖 𝑦𝑟𝑒𝑣𝑒 𝑛𝑜 𝑠𝑝𝑜𝑡𝑠 𝑀 ∧ 𝐿 = )𝑀(𝐿 ‪𝑅 = {∀ 𝐿 ⊆ Σ * | ∃ 𝑡𝑢𝑟𝑖𝑛𝑔 𝑚𝑎𝑐ℎ𝑖𝑛𝑒 𝑀 𝑠. 𝑡.‬‬
‫הגדרה‪ :‬מחלקה 𝐸𝑅 היא קבוצה שמכילה את כל השפות שקיימות עבורן מכונת טיורינג המקבלת אותן‪.‬‬
‫}𝐿 = )𝑀(𝐿 ‪𝑅𝐸 = {∀ 𝐿 ⊆ Σ * | ∃ 𝑡𝑢𝑟𝑖𝑛𝑔 𝑚𝑎𝑐ℎ𝑖𝑛𝑒 𝑀 𝑠. 𝑡.‬‬
‫● למכונה מכריעה יש יותר כוח‪.‬‬

‫● הסימון 𝑅 אומר 𝑒𝑣𝑖𝑠𝑟𝑢𝑐𝑒𝑅‪.‬‬
‫● בהמשך נראה כי 𝐸𝑅 ⊂ 𝑅‪.‬‬
‫● הסימון 𝐸𝑅 אומר 𝑒𝑙𝑏𝑎𝑟𝑒𝑚𝑢𝑛𝐸 𝑦𝑙𝑒𝑣𝑖𝑠𝑟𝑢𝑐𝑒𝑅‪.‬‬
‫דוגמאות לשפות ב‪R-‬‬

‫● השפות הטריוויאליות‪.Σ *, ∅ :‬‬
‫● השפות הרגולריות‪ - .‬אוטומט סופי דטרמיניסטי 𝐴𝐹𝐷 הוא מקרה פרטי של מכונת טיורינג (עם ראש‬
‫קורא‪/‬כותב שעובר פעם אחת בדיוק על הקלט)‪.‬‬
‫● שפות של בעיות מוכרות שידוע לנו על אלגוריתם שפותר אותן (תמיד) כמו למשל‪:‬‬
‫○ }𝑟𝑒𝑏𝑚𝑢𝑛 𝑒𝑚𝑖𝑟𝑝 𝑎 𝑠𝑖 𝑥 | 𝑥{ = 𝐿‬
‫○ }‪𝐿 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑐𝑜𝑛𝑛𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ‬‬
‫○ }‪𝐿 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ𝑎𝑡 ℎ𝑎𝑠 𝑎𝑛 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛 𝑝𝑎𝑡ℎ‬‬
‫תכונות של המחלקות ‪R, RE‬‬

‫תכונה ‪ :𝑅 ⊆ 𝑅𝐸 - 1‬מ"ט המכריעה שפה‪ ,‬בהכרח גם מקבלת אותה‪.‬‬
‫תכונה ‪ - 2‬המחלקה 𝑅 סגורה למשלים‪ :‬אם 𝑅 ∈ 𝐿 אז 𝑅 ∈ ‾𝐿‪.‬‬

‫הוכחה ‪ - 2‬תהי 𝑅 ∈ 𝐿‪ ,‬לפי הגדרת 𝑅‪ ,‬קיים מכונה 𝑀 המכריעה את השפה 𝐿‪.‬‬
‫נבנה מכונה 𝑀 שמכריעה את השפה ‾𝐿‪ :‬המכונה 𝑀 זהה ל‪ 𝑀-‬למעט החלפה בין המצב המקבל והמצב הדוחה‪.‬‬
‫נראה נכונות עבור השפה המשלימה‪:‬‬
‫● אם ‾𝐿 ∈ 𝑥 אז 𝐿 ∉ 𝑥 ובמקרה כזה 𝑀 דוחה את 𝑥 והמכונה 𝑀 מקבלת את 𝑥‪.‬‬
‫● אם ‾𝐿 ∉ 𝑥 אז 𝐿 ∈ 𝑥 ובמקרה כזה 𝑀 מקבלת את 𝑥 והמכונה 𝑀 דוחה את 𝑥‪.‬‬
‫קיבלנו ש‪ .𝐿‾ = 𝐿(𝑀) :‬בנוסף‪ 𝑀 ,‬תמיד עוצרת (כי 𝑀 עוצרת תמיד)‪.‬‬
‫מכאן‪ ,‬שקיימת מכונה מכריעה ל‪ .𝐿‾-‬ולכן 𝑅 ∈ ‾𝐿‪.‬‬
‫∎‬
‫תכונה ‪ - 3‬המחלקה 𝑅 סגורה לאיחוד‪.‬‬

‫טענה ‪ - 3‬תהיינה 𝑅 ∈ ‪ 𝐿1, 𝐿2‬אז 𝑅 ∈ ‪.𝐿1 ∪ 𝐿2‬‬
‫הוכחה ‪ - 3‬תהיינה ‪ 𝐿1, 𝐿2‬שייכות ל‪ ,𝑅-‬ותהיינה ‪ 𝑀1, 𝑀2‬מ"ט המכריעות את ‪ 𝐿1, 𝐿2‬בהתאמה‪.‬‬
‫נגדיר מכונה חדשה '𝑀 על קלט 𝑥 שמבצעת‪:‬‬
‫‪ 𝑀' .1‬מריצה את ‪ 𝑀1‬על 𝑥 ואם ‪ 𝑀1‬קיבלה‪ ,‬אזי '𝑀 עוצרת ומקבלת‪.‬‬
‫‪ .2‬אחרת‪ 𝑀' ,‬מריצה את ‪ 𝑀2‬על 𝑥 ועונה כמוה‪.‬‬
‫נראה נכונות עבור שפת האיחוד‪:‬‬
‫● אם ‪ 𝑥 ∉ 𝐿1 ∪ 𝐿2‬אז ‪ 𝑥 ∉ 𝐿1 ∧ 𝑥 ∉ 𝐿2‬כלומר ‪ 𝑀1(𝑥) = 0 ∧ 𝑀2(𝑥) = 0‬ולכן ‪.𝑀'(𝑥) = 0‬‬
‫● אם ‪ 𝑥 ∈ 𝐿1 ∪ 𝐿2‬אז ‪ 𝑥 ∈ 𝐿1 ∨ 𝑥 ∈ 𝐿2‬כלומר ‪ 𝑀1(𝑥) = 1 ∨ 𝑀2(𝑥) = 1‬ולכן ‪.𝑀'(𝑥) = 1‬‬
‫כלומר הראנו ש‪ .𝐿1 ∪ 𝐿2 = 𝐿(𝑀') :‬הראנו שקיים מ"ט '𝑀 מכריעה לשפת האיחוד ומכאן 𝑅 ∈ ‪.𝐿1 ∪ 𝐿2‬‬
‫∎‬
‫תכונה ‪ - 4‬המחלקה 𝐸𝑅 סגורה לאיחוד‪.‬‬

‫טענה ‪ - 4‬תהיינה 𝐸𝑅 ∈ ‪ 𝐿1, 𝐿2‬אז 𝐸𝑅 ∈ ‪.𝐿1 ∪ 𝐿2‬‬
‫מבוא להוכחה ‪ - 4‬אנחנו לא יכולים להוכיח כמו שהוכחנו עבור 𝑅 מכיוון שב‪ 𝑅𝐸-‬קיימים מקרים של קלטים לא‬
‫מוגדרים על המכונות‪ .‬אנחנו נבצע הרצה מבוקרת כמו שראינו שניתן לסמלץ מכונה בהינתן קידוד עבורה‪.‬‬
‫ניתן גם לסמלץ שתי מכונות במקביל‪ .‬לדוגמה ‪ -‬בכל צעד זוגי‪ ,‬להריץ את המכונה הראשונה ובכל צעד אי‪-‬זוגי‬
‫להריץ את המכונה השנייה‪ .‬נוכל להשתמש ב‪ 2-‬סרטים ‪ -‬אחד עבור ריצת המכונה הראשונה ואחד עבור ריצת‬
‫המכונה השנייה‪.‬‬
‫במילים אחרות‪ ,‬כאשר המכונה האוניברסלית 𝑈 מקבלת קלט הוא יושב אצלה בסרט אחד‪.‬‬
‫אבל המכונה 𝑈 יכולה‪:‬‬
‫להשאיר את החצי הראשון של הקלט בסרט ‪ 1‬עם הקונפיגורציה שלה בסרט ‪.2‬‬ ‫‪.1‬‬
‫‪ .2‬לגזור את החצי השני של הקלט לסרט ‪ 3‬ואת הקונפיגורציה שלה בסרט ‪.4‬‬
‫רעיון הוכחה ‪ - 4‬תהיינה ‪ 𝐿1, 𝐿2‬שייכות ל‪ ,𝑅𝐸-‬ותהיינה ‪ 𝑀1, 𝑀2‬מ"ט המקבלות את ‪ 𝐿1, 𝐿2‬בהתאמה‪.‬‬
‫נגדיר מכונה חדשה '𝑀 על קלט 𝑥 שמבצעת‪:‬‬
‫‪ 𝑀'(𝑥) .1‬תסמלץ את שתי המכונות ‪ 𝑀1, 𝑀2‬במקביל על 𝑥‪.‬‬
‫‪ .2‬אם אחת מהן עצרה ב‪ 𝑞𝑎𝑐𝑐𝑒𝑝𝑡-‬אז מיד נעצור ונקבל‪.‬‬
‫‪ .3‬אם שתיהן עצרו ב‪ 𝑞𝑟𝑒𝑗𝑒𝑐𝑡-‬אז נעצור ונדחה‪.‬‬
‫‪ .4‬אחרת ‪ -‬המכונה שלנו פשוט תמשיך לרוץ לנצח (וזה בסדר…)‪.‬‬
‫נשאר להוכיח את נכונות הבניה‪ .‬כלומר ש‪ 𝑥 ∈ 𝐿(𝑀1) :‬או )‪.𝑥 ∈ 𝐿(𝑀2‬‬
‫● ‪ 𝑥 ∈ 𝐿1 ∪ 𝐿2‬אז לפחות אחת מהמכונות עוצרת על 𝑥 ב‪ 𝑞𝑎𝑐𝑐𝑒𝑝𝑡-‬ונסמן ב‪ 𝑖-‬את הצעד בו היא עצרה‪.‬‬
‫מהבניה של '𝑀‪ ,‬המכונה '𝑀 תזהה עצירה זו בסימולציה של הצעד הנ"ל בצעד סימולציה 𝑖‪ 2‬לכל‬
‫היותר (כי יש ‪ 2‬סרטים שרצים במקביל)‪ .‬במקרה זה‪ ,‬היא גם תעצור ותקבל‪ .‬גם אם ‪ 𝑀2‬עצרה לפני כן‪,‬‬
‫זה לא ישנה את התוצאה ל‪ 𝑞𝑟𝑒𝑗𝑒𝑐𝑡-‬כי '𝑀 לא עוצרת ב‪ 𝑞𝑟𝑒𝑗𝑒𝑐𝑡-‬אלא אם שתי המכונות עצרו ב‪.𝑞𝑟𝑒𝑗𝑒𝑐𝑡-‬‬
‫● ‪ 𝑥 ∉ 𝐿1 ∪ 𝐿2‬אז )‪ 𝑥 ∉ 𝐿1 = 𝐿(𝑀1‬וגם )‪ . 𝑥 ∉ 𝐿2 = 𝐿(𝑀2‬כלומר‪ ,‬אף אחת מהמכונות לא תעצור‬
‫במצב 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪ .‬לכן '𝑀 גם לא תעצור ב‪ 𝑞𝑎𝑐𝑐𝑒𝑝𝑡-‬אלא תעצור ב‪ 𝑞𝑟𝑒𝑗𝑒𝑐𝑡-‬אם שתיהן עוצרות או לא‪.‬‬
‫∎‬
‫תכונה ‪ - 5‬המחלקה 𝐸𝑅 סגורה לחיתוך‪.‬‬

‫טענה ‪ - 5‬תהיינה 𝐸𝑅 ∈ ‪ 𝐿1, 𝐿2‬אז 𝐸𝑅 ∈ ‪.𝐿1 ∩ 𝐿2‬‬
‫בהינתן 𝐸𝑅 ∈ ‪ 𝐿1, 𝐿2‬המתקבלות על ידי מ"ט ‪ ,𝑀1, 𝑀2‬נקבל את ‪.𝐿1 ∩ 𝐿2‬‬
‫נבנה מ"ט דו‪-‬סרטית 𝑀 אשר בהינתן קלט 𝑥 תבצע‪:‬‬
‫‪ 𝑀 .1‬תעתיק את 𝑥 לסרט נוסף‪.‬‬
‫‪ .2‬תריץ את ‪ 𝑀1‬על 𝑥 בסרט הראשון‪.‬‬
‫‪ .a‬אם ‪ 𝑀1‬דחתה‪ 𝑀 ,‬תדחה‪.‬‬
‫‪ .b‬אם ‪ 𝑀1‬קיבלה אז 𝑀 תריץ את ‪ 𝑀2‬על 𝑥 בסרט השני ותענה כמוה‪.‬‬
‫אזי 𝑀 תקבל קלט 𝑥 אם"ם 𝑥 מתקבל ע"י ‪ 𝑀1‬וגם ע"י ‪ .𝑀2‬כלומר‪.𝐿(𝑀) = 𝐿1 ∩ 𝐿2 :‬‬
‫נותר להוכיח את נכונות הבניה‪.‬‬
‫∎‬
‫סגירויות של המחלקות 𝐸𝑅 ‪𝑅,‬‬

‫כל אחת מהטענות הללו דורשות הוכחה‪( .‬לחלקן צריך הרצה מבוקרת)‪.‬‬
‫מחלקה 𝐸𝑅‬ ‫מחלקה 𝑅‬ ‫סגירות‬
‫✘‬ ‫✔‬ ‫משלים‬
‫✔‬ ‫✔‬ ‫איחוד‬
‫✔‬ ‫✔‬ ‫חיתוך‬
‫✔‬ ‫✔‬ ‫שרשור‬
‫✔‬ ‫✔‬ ‫איטרציה‬
‫✔‬ ‫✔‬ ‫היפוך (רוורס)‬
‫המחלקה ‪co-RE‬‬
‫הגדרה‪ .𝑐𝑜𝑅𝐸 = {𝐿 | 𝐿‾ ∈ 𝑅𝐸} :‬כלומר‪ ,‬קבוצת כל השפות אשר לשפה המשלימה שלהן יש מכונה מקבלת‪.‬‬
‫הגדרה שקולה‪ :‬הקבוצה 𝐸𝑅𝑜𝑐 היא קבוצת השפות שיש עבורן מכונה 𝑀 כך ש‪:‬‬
‫‪ .1‬אם 𝐿 ∈ 𝑥 אז המכונה עוצרת ומקבלת או לא עוצרת בכלל‪.‬‬
‫‪ .2‬אם 𝐿 ∉ 𝑥 אז המכונה עוצרת ודוחה‪.‬‬
‫אבחנה‪ :‬כשמגדירים שפה 𝐸𝑅𝑜𝑐 ∈ 𝐿 על ידי מכונה 𝑀 כנ"ל‪ ,‬לא בהכרח מתקיים 𝐿 = )𝑀(𝐿‪.‬‬
‫שאלה ‪ -‬מתי זה כן מתקיים‪ .‬תשובה ‪ -‬עבור כל שפה 𝐸𝑅𝑜𝑐 ⊆ 𝑅 ∈ 𝐿‪.‬‬
‫סדר בראש‪:‬‬
‫עבור 𝐸𝑅 ∈ 𝐿 מתקיים‪:‬‬
‫● אם 𝐿 ∈ 𝑥 אז ‪ 𝑀(𝑥) = 1‬ועוצר‪.‬‬
‫● אם 𝐿 ∉ 𝑥 אז ‪ 𝑀(𝑥) = 0‬או )𝑥(𝑀 לא עוצר‪.‬‬
‫עבור 𝐸𝑅𝑜𝑐 ∈ 𝐿 מתקיים‪:‬‬
‫● אם 𝐿 ∈ 𝑥 אז ‪ 𝑀(𝑥) = 1‬או )𝑥(𝑀 לא עוצר‪.‬‬
‫● אם 𝐿 ∉ 𝑥 אז ‪ 𝑀(𝑥) = 0‬ועוצר‪.‬‬
‫סיכום מחלקות עד כה‬
‫}קיימת מכונה 𝑀 המכריעה את 𝐿| 𝐿{ = 𝑅‬

‫}קיימת מכונה 𝑀 המקבלת את 𝐿| 𝐿{ = 𝐸𝑅‬
‫}קיימת מכונה 𝑀 הדוחה את 𝐿| 𝐿{ = 𝐸𝑅𝑜𝑐‬
‫תכונות של המחלקה ‪coRE‬‬

‫תכונה‪ :𝑅 ⊆ 𝑐𝑜𝑅𝐸 :‬מ"ט המכריעה שפה 𝐿‪ ,‬בהכרח עוצרת על כל קלט 𝐿 ∉ 𝑥‪.‬‬
‫טענה‪.𝑅 = 𝑅𝐸 ∩ 𝑐𝑜𝑅𝐸 :‬‬

‫הוכחה‪ :‬נוכיח בהכלה דו‪-‬כיוונית‪.‬‬
‫● כיוון ראשון 𝐸𝑅𝑜𝑐 ∩ 𝐸𝑅 ⊆ 𝑅‪:‬‬
‫ראינו ש‪ 𝑅 ⊆ 𝑅𝐸 :‬וגם ש‪ 𝑅 ⊆ 𝑐𝑜𝑅𝐸 :‬מכאן 𝐸𝑅𝑜𝑐 ∩ 𝐸𝑅 ⊆ 𝑅‪.‬‬
‫● כיוון שני‪:𝑅𝐸 ∩ 𝑐𝑜𝑅𝐸 ⊆ 𝑅 :‬‬
‫תהי 𝐸𝑅𝑜𝑐 ∩ 𝐸𝑅 ∈ 𝐿‪ ,‬צריך להוכיח כי 𝑅 ∈ 𝐿 כלומר שיש לשפה 𝐿 מכונה מכריעה‪.‬‬
‫מכיוון ש‪ 𝐿 ∈ 𝑅𝐸 :‬אז קיימת לה מכונה ‪ 𝑀1‬המקבלת את 𝐿‪.‬‬
‫וגם 𝐸𝑅𝑜𝑐 ∈ 𝐿 אז קיימת לה מכונה ‪ 𝑀2‬שמזהה קלטים שלא ב‪ 𝐿-‬ודוחה אותם‪.‬‬
‫(זאת בעצם המכונה המקבלת של השפה ‾𝐿)‪.‬‬

‫נתאר מכונה חדשה * 𝑀 בהרצה מבוקרת‪ .‬המכונה * 𝑀 על קלט 𝑥‪:‬‬
‫‪ .1‬מריצה במקביל את ‪ 𝑀1‬על 𝑥 ואת ‪ 𝑀2‬על 𝑥‪.‬‬
‫‪ .2‬בכל שלב‪ ,‬אם ‪ 𝑀1‬קיבלה אז * 𝑀 גם מקבלת‪ .‬אם ‪ 𝑀2‬דחתה אז * 𝑀 גם דוחה‪.‬‬
‫נשאר להוכיח את נכונות הבניה‪:‬‬
‫● אם 𝐿 ∈ 𝑥 אז ‪ 𝑀1(𝑥) = 1‬כלומר ‪.𝑀 * (𝑥) = 1‬‬
‫● אם 𝐿 ∉ 𝑥 אז ‪ 𝑀2(𝑥) = 0‬כלומר ‪.𝑀 * (𝑥) = 0‬‬
‫∎‬
‫הערת עזר לכיוון שני של ההוכחה הקודמת‪:‬‬
‫𝐸𝑅 ∈ 𝐿 אז קיים לה מ"ט ‪ 𝑀1‬שעוצרת במצב קבלה וגם 𝐸𝑅𝑜𝑐 ∈ 𝐿 אז קיים לה מ"ט ‪ 𝑀2‬שעוצרת במצב‬
‫דחייה‪ .‬אמרנו שכל 𝑅 ∈ 𝐿 קיים לה מ"ט 𝑀 שעוצר תמיד וקובע אם קיבל או דחה‪ .‬לכן‪ ,‬אנחנו צריכים "לתפוס"‬
‫את המקרים שבהם ‪ 𝑀1, 𝑀2‬עוצרים‪ .‬לכן‪ ,‬ניצור * 𝑀 ונראה בהרצה מבוקרת שכל מילה מתקבלת 𝐿 ∈ 𝑥 אז‬
‫נפנה ל‪ 𝑀1-‬שעוצר במצב מקבל‪ .‬ואם 𝐿 ∉ 𝑥 אז נפנה ל‪ 𝑀2-‬שעוצר במצב דוחה‪ .‬הראנו בנייה עבור מ"ט * 𝑀‬
‫שמכריעה את השפה ולכן 𝑅 ∈ 𝐿‪.‬‬
‫השפה 𝑢𝐿‬
‫האם השפה }𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑥 ‪ 𝐿𝑢 = {< 𝑀,‬שייכת ל‪ ?𝑅𝐸-‬האם היא שייכת ל‪ - ?𝑅-‬הוכיחו‪.‬‬
‫טענה‪.𝐿𝑢 ∈ 𝑅𝐸 :‬‬
‫הוכחה‪ :‬נתאר מכונת טיורינג 𝑢𝑀 המקבלת את השפה 𝑢𝐿‪:‬‬
‫𝑢𝑀 על קלט > 𝑥 ‪ < 𝑀,‬תסמלץ את ריצת 𝑀 על הקלט 𝑥 ותענה כמוה‪.‬‬
‫● (ראינו שניתן "לסמלץ" ריצה של מכונה שנתונה לנו כקידוד)‪.‬‬
‫● אם 𝑢𝐿 ∈> 𝑥 ‪ < 𝑀,‬אז 𝑀 מקבלת את הקלט 𝑥‪ ,‬מכאן ש‪ 𝑀𝑢-‬מקבלת את הקלט > 𝑥 ‪ < 𝑀,‬אזי‬
‫)𝑢𝑀(𝐿 ∈> 𝑥 ‪.< 𝑀,‬‬
‫● אם 𝑢𝐿 ∉> 𝑥 ‪ < 𝑀,‬אז 𝑀 לא מקבלת את הקלט 𝑥‪ ,‬מכאן ש‪ 𝑀𝑢-‬לא מקבלת את הקלט > 𝑥 ‪< 𝑀,‬‬
‫אזי )𝑢𝑀(𝐿 ∉> 𝑥 ‪( .< 𝑀,‬כלומר היא דוחה או לא עוצרת כהגדרה של 𝐸𝑅)‪.‬‬
‫הראנו ש‪ 𝐿𝑢 = 𝐿(𝑀𝑢) :‬כלומר שקיימת מכונה 𝑢𝑀 המקבלת את השפה 𝑢𝐿 ולכן 𝐸𝑅 ∈ 𝑢𝐿‪.‬‬
‫∎‬
‫האם השפה 𝑢𝐿 שייכת למחלקה 𝑅?‪ :‬התשובה היא לא כלומר 𝑅 ∉ 𝑢𝐿‪.‬‬

‫כדי להוכיח זאת אנחנו צריכים להוכיח שכל אלגוריתם בעולם‪ ,‬לא יכול להכריע את השפה הזו‪( .‬נראה בהמשך)‪.‬‬
‫השפה 𝐷𝐿‬
‫האם השפה }> 𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑀 <{ = 𝐷𝐿 שייכת ל‪ ?𝑅𝐸-‬האם שייכת ל‪ - ?𝑅-‬הוכיחו‪.‬‬
‫טענה‪.𝐿𝐷 ∈ 𝑅𝐸 :‬‬
‫הוכחה‪ :‬נתאר מ"ט 𝐷𝑀 המקבלת את השפה 𝐷𝐿‪:‬‬
‫𝐷𝑀 על הקלט > 𝑀 < תסמלץ את ריצת 𝑀 על הקלט > 𝑀 < ותענה כמוה‪.‬‬
‫● אם 𝐷𝐿 ∈> 𝑀 < אז ‪.𝑀𝐷(< 𝑀 >) = 1‬‬
‫● אם 𝐷𝐿 ∉> 𝑀 < אז ‪ 𝑀𝐷(< 𝑀 >) = 0‬או )> 𝑀 <(𝐷𝑀 לא תעצור (לא מוגדרת)‪.‬‬
‫הראנו ש‪ 𝐿𝐷 = 𝐿(𝑀𝐷) :‬כלומר שקיימת מכונה 𝐷𝑀 המקבלת את השפה 𝐷𝐿 ולכן 𝐸𝑅 ∈ 𝐷𝐿‪.‬‬
‫שיטת הלכסון של קנטור‬

‫קנטור הוכיח שבקטע ]‪ [0, 1‬יש כמות לא בת מניה של מספרים‪.‬‬
‫מבנה ההוכחה‪:‬‬
‫‪ .1‬נניח בשלילה שיש מספר בן‪-‬מניה של מספרים בין ‪ 0‬ל‪.1-‬‬
‫‪ .2‬לשם הנוחות‪ ,‬ניקח תת‪-‬קבוצה 𝐴 של מספרים בין ‪ 0‬ל‪ ,1-‬שהייצוג שלהם מכיל רק ‪ 2‬תווים (למשל ‪.)0,1‬‬
‫‪ .3‬נסדר את המספרים הללו בסידור כלשהו (מובטח שקיים סידור כזה מכיוון שהנחנו שמדובר בקבוצת‬
‫בת מנייה)‪.‬‬
‫‪ .4‬נבנה מספר חדש 𝑐 על ידי זה שניקח את הספרות שבאלכסון ונחליף אותן‪ 1 ,‬יהפוך ל‪ 0-‬ו‪ 0-‬יהפוך ל‪.1-‬‬
‫‪ .5‬המספר 𝐴 ∈ 𝑐 ולכן קיים אינדקס 𝑖 כך שהמספר שלנו הוא בדיוק האיבר 𝑖𝑛‪.‬‬
‫‪ .6‬אבל‪ ,‬לפי הבנייה של 𝑐‪ ,‬הערך של 𝑐 בתו ה‪ 𝑖-‬שונה מהערך של 𝑖𝑛 בתו ה‪.𝑖-‬‬
‫‪ .7‬סתירה‪.‬‬
‫הרעיון מאחורי ההוכחה‪:‬‬

‫יש לנו אינסוף מספרים בין ‪ 0‬ל‪ ,1-‬אבל כמות בת מניה של מספרים ולכן אנחנו יכולים לתת למספרים האלה‬
‫סידור‪ ,‬כל מספר קיבל ייצוג 𝑗𝑛 בהתאם לסידור הזה‪ .‬לכן‪ ,‬בין האינסוף מספרים האלה קיים ייצוג 𝑖𝑛 של המספר‬
‫החדש 𝑐 שנוצר מההחלפה שעשינו‪ .‬אבל בייצוג הזה קיבלנו ש‪ .𝑛𝑖[𝑖] ≠ 𝑐[𝑖] :‬כלומר 𝑖𝑛 לא מייצג את 𝑐‪.‬‬
‫אבל מכיוון שקיים סידור (בן מניה) והמספר לא נמצא בשורה הזאת אז הוא לא קיים בין ‪ 0‬ל‪ 1-‬ו‪ 𝐴-‬לא בן מניה‪.‬‬
‫האם השפה 𝐷𝐿 שייכת ל‪?𝑅-‬‬

‫האם השפה }> 𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑀 <{ = 𝐷𝐿 שייכת ל‪?𝑅-‬‬
‫טענה‪.𝐿𝐷 ∉ 𝑅 :‬‬
‫מבנה ההוכחה‪ :‬ניצור פרדוקס‪ :‬נניח בשלילה ונראה שזה גורר סתירה‪.‬‬
‫הוכחה‪ :‬נניח בשלילה ש‪ 𝐿𝐷 ∈ 𝑅 :‬ולכן קיימת לשפה 𝐷𝐿 מכונה 𝐷𝑀 המכריעה אותה‪.‬‬
‫נגדיר מכונה חדשה 𝐷𝐴 (היא גם מכונה מכריעה לפי סגירות למשלים) שפועלת בצורה הבאה‪:‬‬
‫< ועונה הפוך‪( .‬כמו שהפכנו את הביטים‬ ‫המכונה 𝐷𝐴 על הקלט > 𝑀 < מריצה את המכונה 𝐷𝑀 על הקלט > 𝑀‬
‫בלכסון של קנטור)‪ .‬מכיוון שיש מספר בן מניה של מכונות טיורינג‪ ,‬ניתן לסדר את כל המכונות בסידור כלשהו (למשל‬
‫סידור לקסיקוגרפי של מחרוזות הקידוד)‪.‬‬
‫נבנה טבלה אינסופית של כל הזוגות האפשריים של מכונות טיורינג‪ ,‬כך שבתא ה‪ [𝑖][𝑗]-‬נאחסן את התשובה‬
‫לשאלה הבאה‪ :‬האם המכונה 𝑖𝑀 מקבלת את הקלט > 𝑗𝑀 < (הקידוד של המכונה 𝑗𝑀)?‬
‫> ‪< 𝑀1‬‬ ‫> ‪< 𝑀2‬‬ ‫> ‪< 𝑀3‬‬ ‫> ‪< 𝑀4‬‬ ‫…‬ ‫…‬ ‫…‬
‫> ‪< 𝑀1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫> ‪< 𝑀2‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫> ‪< 𝑀3‬‬ ‫‪1‬‬
‫> ‪< 𝑀4‬‬ ‫‪0‬‬
‫…‬ ‫‪0‬‬
‫…‬ ‫‪1‬‬
‫…‬ ‫‪0‬‬
‫𝑀 יודעת למלא את התאים של האלכסון בטבלה (כי 𝐷𝑀 מכריעה את השפה 𝐷𝐿 שמקבלת כל קידוד > 𝑖𝑀 < של‬ ‫המכונה‬
‫𝐷‬
‫המכונה 𝑖𝑀 כלומר כל ]𝑖[]𝑖[ בונה את האלכסון של הטבלה) ‪ ,‬לכן המכונה 𝐷𝐴 גם כן יודעת למלא את תאי האלכסון של הטבלה‬
‫(ממלאת את האלכסון אבל בדיוק ההפך)‪.‬‬
‫המכונה 𝐷𝐴 היא גם מכונת טיורינג ולכן היא נמצאת בטבלה‪ ,‬כלומר קיים אינדקס 𝑖 כך שמתקיים ש‪.𝐴𝐷 = 𝑀𝑖 :‬‬
‫מה הערך בתא ה‪ [𝑖][𝑖]-‬בטבלה? ‪ -‬כלומר מה הערך של‪?𝑀𝑖(< 𝑀𝑖 >) = 𝐴𝐷(< 𝑀𝑖 >) :‬‬
‫● אם 𝐷𝐴 מקבלת על הקלט > 𝐷𝐴 < אז בתא ]𝑖[]𝑖[ צריך להיות ערך ‪( 1‬זה נכון לפי הגדרת הטבלה)‪.‬‬
‫אבל בהרצה של 𝐷𝐴 על הקלט > 𝐷𝐴 <‪ ,‬המכונה 𝐷𝑀 תענה ‪ 1‬ואז 𝐷𝐴 חייב לפלוט ‪ - .0‬סתירה‪.‬‬
‫● אם 𝐷𝐴 לא מקבלת על הקלט > 𝐷𝐴 < אז בתא ]𝑖[]𝑖[ צריך להיות ערך ‪( 0‬זה נכון לפי הגדרת הטבלה)‪.‬‬
‫אבל בהרצה של 𝐷𝐴 על הקלט > 𝐷𝐴 <‪ ,‬המכונה 𝐷𝑀 תענה ‪ 0‬ואז 𝐷𝐴 חייב לפלוט ‪ - .1‬סתירה‪.‬‬
‫∎‬
‫השפה 𝑃𝐻 (‪)Halting Problem‬‬

‫האם }𝑥 𝑛𝑜 )𝑠𝑝𝑜𝑡𝑠( 𝑠𝑡𝑙𝑎‪ 𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ‬שייכת ל‪ ?𝑅𝐸-‬האם שייכת ל‪ - ?𝑅-‬הוכיחו‪.‬‬
‫אינטואיציה‪ :‬אם 𝑀 עצרה על 𝑥 אז 𝑃𝐻 ∈> 𝑥 ‪ ,< 𝑀,‬כלומר הגענו למצב מקבל 𝑡𝑝𝑒𝑐𝑐𝑎𝑞 והקלט בשפה‪.‬‬
‫אם 𝑀 לא עצרה על 𝑥 אז 𝑃𝐻 ∉> 𝑥 ‪ ,< 𝑀,‬אבל אנחנו לא יודעים אם בוודאות המכונה עצרה ולכן‪ ,‬המכונה 𝑀‬
‫לא יכולה להכריע את השפה‪ .‬מכאן ‪ 𝐻𝑃 ∈ 𝑅𝐸 -‬אבל 𝑅 ∉ 𝑃𝐻‪.‬‬
‫טענה‪.𝐻𝑃 ∈ 𝑅𝐸 :‬‬
‫רעיון ההוכחה‪ :‬נראה מכונה שאם היא עוצרת אז היא מקבלת את הקלט ‪ -‬אחרת היא לאו דווקא עוצרת‪.‬‬
‫הוכחה‪ :‬נתאר מכונת טיורינג 𝑃𝐻𝑀 המקבלת את השפה 𝑃𝐻‪:‬‬
‫המכונה 𝑃𝐻𝑀 על הקלט > 𝑥 ‪ < 𝑀,‬תסמלץ את ריצת 𝑀 על הקלט 𝑥‪ ,‬אם עצרה ‪ -‬נקבל (נעבור ל‪.)𝑞𝑎𝑐𝑐𝑒𝑝𝑡-‬‬
‫אם הקידוד > 𝑥 ‪ < 𝑀,‬לא חוקי ‪ -‬המכונה 𝑃𝐻𝑀 לא עוצרת‪.‬‬
‫● אם 𝑃𝐻 ∈> 𝑥 ‪ < 𝑀,‬אז 𝑀 עוצרת על הקלט 𝑥 ולכן 𝑃𝐻𝑀 מקבלת את הקלט > 𝑥 ‪.< 𝑀,‬‬
‫אזי )𝑃𝐻𝑀(𝐿 ∈> 𝑥 ‪.< 𝑀,‬‬
‫● אם 𝑃𝐻 ∉> 𝑥 ‪ < 𝑀,‬אז 𝑀 לא עוצרת על הקלט 𝑥 ולכן 𝑃𝐻𝑀 לא מקבלת את הקלט > 𝑥 ‪.< 𝑀,‬‬
‫ובפרט‪ ,‬המכונה 𝑃𝐻𝑀 לא עוצרת על קלט זה‪ .‬אזי )𝑃𝐻𝑀(𝐿 ∉> 𝑥 ‪.< 𝑀,‬‬
‫הראנו ש‪ 𝐻𝑃 = 𝐿(𝑀𝐻𝑃) :‬כלומר שקיימת מכונה 𝑃𝐻𝑀 המקבלת את השפה 𝑃𝐻 ולכן 𝐸𝑅 ∈ 𝑃𝐻‪.‬‬
‫∎‬
‫בעיית העצירה‬
‫שאלה‪ :‬האם השפה 𝑅 ∈ 𝑃𝐻?‬
‫תשובה‪ :‬לא‪ .‬כלומר 𝑅 ∉ 𝑃𝐻‪.‬‬
‫רעיון ההוכחה‪:‬‬
‫‪ .1‬נניח בשלילה שיש מכונה 𝑃𝐻𝑀 המכריעה את 𝑃𝐻‪.‬‬
‫‪ .2‬נשתמש ב‪ 𝑀𝐻𝑃-‬כדי להכריע את }> 𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑀 <{ = 𝐷𝐿‪.‬‬
‫‪ .3‬אבל הוכחנו שלא קיימת מכונה 𝐷𝑀 שמכריע את השפה 𝐷𝐿‪.‬‬
‫‪ .4‬לכן גם לא קיימת מכונה שמכריע את 𝑃𝐻 ‪ -‬נקבל סתירה‪.‬‬
‫טענה‪.𝐻𝑃 ∉ 𝑅 :‬‬
‫הוכחה‪ :‬נניח בשלילה 𝑅 ∈ }𝑥 𝑛𝑜 )𝑠𝑝𝑜𝑡𝑠( 𝑠𝑡𝑙𝑎‪ 𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ‬ולכן קיימת מכונת טיורינג 𝑃𝐻𝑀‬
‫המכריעה את השפה 𝑃𝐻‪ .‬בהינתן קידוד של מכונה כלשהי > 𝑀 <‪ ,‬נרצה להכריע האם היא שייכת לשפה‬
‫}> 𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑀 <{ = 𝐷𝐿 או לא‪:‬‬
‫נבנה מכונה '𝑀 אשר זהה ל‪ ,𝑀-‬רק שבכל פעם כאשר 𝑀 דוחה אז '𝑀 נכנסת ללולאה אינסופית‪.‬‬
‫עבור המכונה '𝑀 על הקלט 𝑦 ‪:‬‬
‫● מסמלצת את ריצת 𝑀 על 𝑦‪ ,‬אם 𝑀 קיבלה ‪ -‬אז '𝑀 מקבלת‪.‬‬
‫● אם 𝑀 דחתה ‪ -‬אז '𝑀 נכנסת ללולאה אינסופית‪.‬‬
‫כעת נשלח אל המכונה 𝑃𝐻𝑀 את הקידוד >> 𝑀 < ‪.< 𝑀',‬‬
‫● אם 𝑃𝐻𝑀 תענה שהקלט בשפה 𝑃𝐻 אז '𝑀 עוצרת על > 𝑀 < ולפי בניית '𝑀 נסיק ש‪ 𝑀-‬מקבלת את‬
‫> 𝑀 < ונסיק מכך כי 𝐷𝐿 ∈> 𝑀 <‪.‬‬
‫● אם 𝑃𝐻𝑀 תענה שהקלט לא בשפה 𝑃𝐻 אז '𝑀 לא עוצרת על > 𝑀 < ולפי בניית '𝑀 נסיק ש‪𝑀-‬‬
‫לא‪-‬מקבלת את > 𝑀 < (דוחה או נכנסת ללולאה אינסופית) ונסיק מכך כי 𝐷𝐿 ∉> 𝑀 <‪.‬‬
‫קיבלנו אלגוריתם שמכריע את השפה 𝐷𝐿 ‪ -‬סתירה‪.‬‬
‫∎‬
‫הערות הוכחה‪:‬‬
‫● אם יש לנו מכונה 𝑃𝐻𝑀 שמכריע את 𝑃𝐻 אז המכונה הזאת אומרת לנו האם נכנסו ללולאה אינסופית או‬
‫לא (האם עצרנו או לא)‪ .‬אם יש לולאה אינסופית אז נדחה ואם הגענו למצב סופי אז נקבל‪.‬‬
‫● הסתירה נובעת כי הוכחנו כבר ש‪ 𝐿𝐷 ∉ 𝑅 :‬כלומר שאי אפשר להכריע אותה אבל הראנו הרגע שקיים‬
‫אלגוריתם שמכריע אותה וזו הסתירה‪.‬‬
‫● הוכחנו ישירות משיטת הלכסון של קנטור ש‪ 𝐿𝐷 ∉ 𝑅 :‬ואנחנו נעזרים בו בשביל להוכיח ש‪.𝐻𝑃 ∉ 𝑅 :‬‬
‫כלומר הוכחנו ש‪ 𝐻𝑃 :‬לא כריעה‪.‬‬
‫תמונת מצב‬
‫בקורס אוטומטים למדנו על המחלקות הרגולריות‪,‬‬
‫חסרות ההקשר ותלויות ההקשר‪ .‬לכל אחת‬
‫מהמחלקות האלה קיים מכונה שיודעת למדל אותם‪.‬‬
‫כל מכונה שונה כזאת חזקה יותר מהשניה ככל שהיא‬
‫תכיל יותר מחלקות בתוכה‪.‬‬
‫השפה הרגולרית ‪ -‬הם שפות שלא צריך לזכור בהן משהו אינסופי‪ .‬הן שפות מחזוריות‪ .‬כלומר‪ :‬לא צריך ספירה‬
‫𝑖‬
‫מדויקת וגם לא צריך למנות משהו כנגד משהו אחר‪ .‬לדוגמה השפה }‪ 𝐿 = {𝑎 : 𝑖 ∈ ℕ‬היא שפה רגולרית‪.‬‬
‫לשפות האלו למדנו את המודלים ‪ 𝐷𝐹𝐴, 𝑁𝐹𝐴, 𝑁𝐹𝐴 − ε‬וקבענו כי אם ניתן לבנות לשפה אוטומט ממודלים‬
‫אלה אז השפה היא רגולרית‪ .‬בתחילת הקורס של אוטומטים‪ ,‬הסבירו לנו כי לכל אוטומט יש סרט וראש קורא‬
‫שעובר על הקלט‪ .‬עבור כל תו שהראש קורא בסרט‪ ,‬נשתמש בפונקצית המעברים ‪ δ‬כדי לקבוע (דטרמיניסטי או‬
‫לא) לאיזה מצב להמשיך‪ .‬כלומר‪ ,‬המודלים 𝐴𝐹𝑁‪ 𝐷𝐹𝐴, 𝑁𝐹𝐴, ε‬הם מקרה פרטי של מכונת טיורינג שיודעות‬
‫לקבל רק את השפות הרגולריות ולא יותר מזה‪ .‬לפי הציור אפשר להבין כי כל השפות רגולריות הם גם חסרות‬
‫הקשר‪ ,‬תלויות הקשר‪.𝑅, 𝑅𝐸 ,‬‬
‫שפות חסרות ההקשר ‪ -‬הם שפות שיש להן זיכרון של מחסנית‪ .‬לא ניתן לבצע ספירה מדויקת אבל ניתן לזכור‬
‫𝑛 𝑛‬
‫כמות כנגד כמות‪ .‬לדוגמה‪ ,‬השפה }‪ 𝐿 = {𝑎 𝑏 : 𝑛 ∈ ℕ‬היא שפה חסרת הקשר ובפרט לא רגולרית‪.‬‬
‫לשפות אלה למדנו את המודל 𝐴𝐷𝑃 או 𝑎𝑡𝑎𝑚𝑜𝑡𝑢𝐴 𝑛𝑤𝑜𝐷 ‪ 𝑃𝑢𝑠ℎ‬כלומר אוטומט המחסנית‪ .‬למדנו על‬
‫דקדוקים חסרי הקשר והראנו שהם שקולים ל‪ .𝑃𝐷𝐴-‬גם כאן‪ ,‬למדנו שלאוטומט 𝐴𝐷𝑃 יש ראש קורא‪/‬כותב וסרט‪.‬‬
‫כלומר 𝐴𝐷𝑃 הוא גם מקרה פרטי של מכונת טיורינג שמחקה התנהגות של מחסנית‪ .‬מודל 𝐴𝐷𝑃 הוא מודל חזק‬
‫יותר ממודלי 𝐴𝐹𝐷 של השפות הרגולריות וככל שנעטוף יותר מחלקות ככה המודל יהיה חזק יותר‪.‬‬
‫שפות תלויות הקשר ‪ -‬הם שפות שאפשר לבצע בהן ספירה מדויקת ותלות משולשת בין תווים‪ .‬לדוגמה השפות‬
‫𝑝‬ ‫𝑛 𝑛 𝑛‬
‫}𝑁 ∈ 𝑛 ‪ 𝐿 = {𝑎 𝑏 𝑐 :‬ו‪ 𝐿 = {𝑎 : 𝑝 𝑖𝑠 𝑝𝑟𝑖𝑚𝑒} -‬הם תלויות הקשר‪ .‬לשפות תלויות הקשר יש להן זיכרון‬
‫חסום של מכונת טיורינג (מקרה פרטי) והם חזקות יותר ממודלי 𝐴𝐷𝑃 ‪ 𝐷𝐹𝐴,‬וכל מחלקה שהיא עוטפת‪.‬‬
‫המחלקה ‪ - R‬היא קבוצת כל השפות שקיים עבורן מכונת טיורינג שמכריעה אותן‪ .‬כלומר‪ ,‬זה שפות שאפשר‬
‫לקבוע עבורן החלטה חד‪-‬משמעית האם המילה מתקבלת או לא‪ .‬למשל השפה * ‪ Σ‬נמצאת ב‪ 𝑅-‬מכיוון שלא‬
‫ניתן לקבוע חישובים מסובכים‪ ,‬עבור כל * ‪ 𝑥 ∈ Σ‬אז ‪ 𝑀(𝑥) = 1‬אם תתקבל או ‪ 𝑀(𝑥) = 0‬אם תדחה‪.‬‬
‫מכיוון שהמכונה 𝑀 מכירה את ‪ Σ‬אז אין לנו כאן בעיות שעלולות להוביל אותנו לריצה אינסופית‪.‬‬
‫המחלקה ‪ - RE‬היא קבוצת כל השפות שקיים עבורן מכונת טיורינג שמקבלת אותן‪ .‬זה שפות שייתכן שקיים להן‬
‫מכונת טיורינג שעבור קלט מסוים עלולות להוביל את המכונה למצב אינסופי ולא להיעצר לעולם‪.‬‬
‫סיכום הרצאה ‪2‬‬

‫מכונת טיורינג אוניברסלית ‪ -‬בתחילת ההרצאה למדנו על מכונת טיורינג אוניברסלית 𝑈 שהיא מכונת טיורינג‬
‫כללית שתוכל לבצע את המשימה של כל מכונת טיורינג אחרת‪ .‬היא צריכה לקבל קידוד של מכונה 𝑀 ואת‬
‫הקלט * ‪ 𝑥 ∈ Σ‬עבור 𝑀 ותחזיר )𝑥(𝑀‪ .‬מכונת טיורינג אוניברסלית 𝑈 מחקה את ריצת 𝑀 על 𝑥 בעזרת שמירת‬
‫קונפיגורציה בסרט נוסף‪ ,‬כאשר הקונפיגורציה נקבעת על סמך פונקציית המעברים ‪ δ‬שנתונה בקידוד > 𝑀 <‬
‫‪ .‬כאשר 𝑀 תגיע למצב סופי ותעצור אז 𝑈 תחזיר )𝑥(𝑀‪.‬‬
‫מכונת טיורינג לקבלת שפות הינה מכונת טיורינג רגילה 𝑀 שמקיימת }𝑗𝑒𝑟𝑞 ‪.𝐹 = {𝑞𝑎𝑐𝑐,‬‬
‫● נאמר ש‪ 𝑀 :‬מקבלת את 𝑥 ונסמן ‪.𝑀(𝑥) = 1‬‬
‫● נאמר ש‪ 𝑀 :‬דוחה את 𝑥 ונסמן ‪.𝑀(𝑥) = 0‬‬
‫● שפת המכונה )𝑀(𝐿 הינה קבוצת כל המילים אשר המכונה 𝑀 מקבלת אותם (‪.)𝑀(𝑥) = 1‬‬
‫● השפה המשלימה )𝑀(𝐿\ * ‪ 𝐿(𝑀) = Σ‬היא קבוצת כל המילים ש‪ 𝑀-‬דוחה או לא עוצרת‪.‬‬
‫קבלת שפה ‪ -‬נאמר שמכונה 𝐿𝑀 מקבלת (מזהה) את השפה 𝐿 אם מתקיים‪. 𝑥 ∈ 𝐿 ↔ 𝑀(𝑥) = 1 :‬‬
‫הכרעת שפה ‪ -‬נאמר שמכונה 𝐿𝑀 מכריעה את השפה 𝐿 אם מתקיים‪.𝑥 ∈ 𝐿 ↔ 𝑀(𝑥) = 1 :‬‬
‫בנוסף‪ 𝑀𝐿 ,‬תמיד עוצרת‪.‬‬
‫המחלקה ‪ - R‬היא קבוצה שמכילה את כל השפות שקיימות עבורן מכונת טיורינג המכריעה אותן‪.‬‬
‫המחלקה ‪ - RE‬היא קבוצה שמכילה את כל השפות שקיימות עבורן מכונת טיורינג המקבלת אותן‪.‬‬
‫‪ :𝑅 ⊆ 𝑅𝐸 .1‬מ"ט המכריעה שפה‪ ,‬בהכרח גם מקבלת אותה‪.‬‬
‫‪ .2‬המחלקה 𝑅 סגורה למשלים‪ :‬אם 𝑅 ∈ 𝐿 אז 𝑅 ∈ ‾𝐿‪.‬‬
‫‪ .3‬המחלקה 𝑅 סגורה לאיחוד‪.‬‬
‫‪ .4‬המחלקה 𝐸𝑅 סגורה לאיחוד‪.‬‬
‫‪ .𝑐𝑜𝑅𝐸 = {𝐿 | 𝐿‾ ∈ 𝑅𝐸} .5‬כלומר‪ ,‬קבוצת כל השפות אשר לשפה המשלימה שלהן יש מכונה מקבלת‪.‬‬
‫‪ :𝑅 ⊆ 𝑐𝑜𝑅𝐸 .6‬מ"ט המכריעה שפה 𝐿‪ ,‬בהכרח עוצרת על כל קלט 𝐿 ∉ 𝑥‪.‬‬
‫‪.𝐿𝑢 = {< 𝑀, 𝑥 > | 𝑀 𝑎𝑐𝑐𝑒𝑝𝑡𝑠 𝑥} ∈ 𝑅𝐸 .7‬‬
‫‪𝐿𝐷 = {< 𝑀 > | 𝑀 𝑎𝑐𝑐𝑒𝑝𝑡𝑠 < 𝑀 >} ∈ 𝑅𝐸 .8‬‬
‫‪𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ𝑎𝑙𝑡𝑠 (𝑠𝑡𝑜𝑝𝑠) 𝑜𝑛 𝑥} ∈ 𝑅𝐸 .9‬‬
‫שיטת הלכסון של קנטור ‪ -‬קנטור הוכיח שבקטע ]‪ [0, 1‬יש כמות לא בת מניה של מספרים‪ .‬נשתמש בשיטה זו‬
‫כדי להראות אי שייכות למחלקה 𝑅‪.‬‬
‫הרצה מבוקרת‬
‫נציג כעת שיטה חזקה להוכחה ששפות מסוימות שייכות ל‪.𝑅𝐸-‬‬
‫בתור דוגמה‪ ,‬נתונה השפה הבאה‪.𝐿 = {< 𝑀 > | ∃𝑥 𝑠. 𝑡. 𝑓𝑀(𝑥) = 𝑥 } :‬‬
‫● זוהי שפת כל המכונות שיש "נקודת שבת" לפונקציה שהן מחשבות‪.‬‬
‫● בהינתן דקדוק מכונה > 𝑀 <‪ ,‬לא ברורה הדרך לבדוק האם קיימת נקודת שבת מלבד לבצע‬
‫𝑒𝑐𝑟𝑜𝐹 𝑒𝑡𝑢𝑟𝐵 לכל קלט * ‪ 𝑤𝑖 ∈ Σ‬אפשרי כזה (יש אינסוף כאלה)‪.‬‬
‫● במכונות המקבלות שפה‪ ,‬ייתכן שעבור קלט מסוים המכונה לא תעצור לעולם‪.‬‬
‫● מה הבעיה? ‪ -‬יכול להיות ש‪ 𝑀(𝑤2) = 𝑤2 :‬אבל )‪ 𝑀(𝑤1‬לא תעצור לעולם ולכן 𝑀 לא תבדוק את ‪.𝑤2‬‬
‫● פתרון ‪ -‬נשתמש בהרצה מבוקרת‪.‬‬
‫מה זה הרצה מבוקרת? ‪ -‬כדי להימנע ממצב שעבור קלט מסוים 𝑤‪ ,‬המכונה תיכנס ללולאה אינסופית‪ ,‬נשתמש‬
‫בשיטת הרצה מבוקרת‪ .‬זו שיטה עדינה ומבוקרת יותר המונעת ריצה אינסופית‪ .‬בכל צעד באלגוריתם‪ ,‬נפעיל‬
‫חלק קטן מתוך כל מילה 𝑖𝑤 שנעבוד עליה‪ .‬ככל שמספר הצעדים גדל ‪ -‬ככה נעבוד על יותר מילים במקביל ‪-‬‬
‫כך שאם מילה 𝑖𝑤 תיכנס למצב אינסופי‪ ,‬המילה ‪ 𝑤𝑖+1‬שגם נעבוד עליה במקביל‪ ,‬תמשיך להיבדק עד‬
‫לעצירתה‪ .‬נסתכל על הפתרון הבא שיעזור לנו להבין יותר את רעיון השיטה הזו‪.‬‬
‫שאלה‪ :‬האם 𝐸𝑅 ∈ } 𝑥 = )𝑥(𝑀𝑓 ‪ - ?𝐿 = {< 𝑀 > | ∃𝑥 𝑠. 𝑡.‬הוכיחו‪.‬‬

‫פתרון‪ :‬כן‪ .𝐿 ∈ 𝑅𝐸 ,‬נראה בהרצה מבוקרת‪.‬‬
‫נבנה מכונה 𝐿𝑀 המקבלת את השפה 𝐿‪.‬‬
‫𝐿𝑀 על קלט > 𝑀 <‪:‬‬
‫𝑤‪( .‬אפשרי כי בת מניה)‪.‬‬ ‫● נסדר את כל המילים ב‪ Σ *-‬בסדר לקסיקוגרפי ‪, 𝑤2, 𝑤3, 𝑤4,....‬‬
‫‪1‬‬
‫● עבור ‪ ; 𝑖 = 1‬עד אינסוף ; ‪:𝑖 ++‬‬
‫○ עבור ‪ ; 𝑗 = 1‬עד 𝑖 ; ‪:𝑗 ++‬‬
‫(‬ ‫)‬
‫■ סמלץ את 𝑀 על קלט 𝑗𝑤 במשך 𝑖 צעדים‪( .‬כלומר ]𝑖 ‪.)𝑀 𝑤𝑗[1....‬‬
‫■ אם 𝑀 החזירה 𝑗𝑤‪ ,‬קבל‪.‬‬
‫נותר להוכיח את נכונות הבניה‪:‬‬
‫כיוון ראשון ‪ -‬יהי 𝐿 ∈> 𝑀 <‪ ,‬אז קיים 𝑥 כך ש‪.𝑓𝑀(𝑥) = 𝑥 :‬‬
‫𝑥 (כלומר 𝑥 זו המילה ה‪ 𝑘-‬בסדר לקסיקוגרפי)‪.‬‬ ‫● נסמן את המילה ה‪ 𝑘-‬כך ש‪= 𝑤𝑘 :‬‬
‫נסמן 𝑡 מספר הצעדים של 𝑀 על 𝑥 (כלומר אחרי 𝑡 צעדים‪ 𝑀 ,‬עוצרת ומחזירה 𝑥)‪.‬‬ ‫●‬
‫𝑖 (אנחנו נרצה 𝑘 ≥ 𝑖 כדי שנריץ את המילה 𝑘𝑤 וגם 𝑡 ≥ 𝑖 צעדים עד ש‪ 𝑀-‬תסיים לעבור על 𝑘𝑤)‪.‬‬ ‫● נסמן )𝑘 ‪= 𝑚𝑎𝑥(𝑡,‬‬
‫● נרוץ על 𝑖𝑤 ‪( 𝑤1,...,‬ובטוח גם על 𝑘𝑤) למשך 𝑖 צעדים (לפחות 𝑡 צעדים) ולכן נזהה את 𝑥 = )𝑥(𝑀𝑓 ונקבל את‬
‫> 𝑀 <‪.‬‬
‫● לכן‪ ,𝑀𝐿(< 𝑀 >) = 1 ,‬כלומר )𝐿𝑀(𝐿 ∈> 𝑀 <‪.‬‬

‫כיוון שני ‪ -‬יהי 𝐿 ∉> 𝑀 <‪ ,‬לא קיים 𝑥 כך ש‪.𝑓𝑀(𝑥) = 𝑥 :‬‬
‫● לא קיים 𝑘 כך ש‪.𝑓𝑀(𝑤𝑘) = 𝑤𝑘 :‬‬
‫● לכל 𝑖 ולכל 𝑗‪ ,‬המכונה 𝑀 לא תעצור ותחזיר את 𝑗𝑤‪.‬‬
‫● המכונה 𝐿𝑀 תרוץ לנצח (כי היא לא תמצא אף מילה שמקיימת את 𝑀𝑓)‪.‬‬
‫● לכן‪.< 𝑀 >∉ 𝐿(𝑀𝐿) ,‬‬
‫∎‬
‫הסבר כיוון ראשון‪ :‬נניח שהמילה ה‪ ,𝑘 = 1-‬כלומר ה‪ , 𝑤1-‬עוצרת (מסתיימת) בריצת המכונה 𝑀 לאחר‬
‫‪ 𝑡 = 30‬צעדים והיא אכן מקיימת ש‪( 𝑓𝑀(𝑤1) = 𝑤1 -‬בהכרח יש כזאת כי 𝐿 ∈> 𝑀 <)‪.‬‬
‫כלומר‪ ,‬צריך לקרוא את כל המילה ‪ 𝑤1‬בשביל לקבוע אם מתקיים‪ .‬המילה הזאת היא בת כ‪ 𝑡 = 30-‬תווים‪.‬‬
‫רק כאשר באלגוריתם שלנו‪ ,‬ה‪( 𝑖-‬לולאה החיצונית) יהיה }𝑘 ‪ 𝑖 = 𝑚𝑎𝑥{𝑡,‬אז 𝑀 תסיים לקרוא את המילה ‪𝑤1‬‬
‫ותקבע ש ‪ .𝑓𝑀(𝑤1) = 𝑤1‬כלומר אנחנו נצטרך בזמן הריצה לעבור על 𝑖𝑤 ‪ 𝑤1,...,‬מילים עד ש‪ 𝑤1-‬תעצור‪.‬‬
‫תרגיל‬
‫נתונה השפה הבאה‪ .𝐿 = {< 𝑀 > | < 𝑀 >∉ 𝐿(𝑀) } :‬האם היא ב‪ ?𝑅𝐸-‬האם ב‪ ?𝑅-‬האם ב‪?𝑐𝑜𝑅𝐸-‬‬
‫האם היא ב‪ - ?R-‬לא‪ .‬אם היא הייתה‪ ,‬אז ניתן היה בקלות להכריע את 𝐷𝐿 שראיתם בהרצאה שהיא לא ב‪.𝑅-‬‬
‫האם היא ב‪ - ?coRE-‬כן‪ .‬נוכיח את זה‪ .‬צריך להראות מכונה כך ש‪:‬‬
‫‪ .1‬אם הקלט לא בשפה‪ ,‬אז המכונה תמיד עוצרת ודוחה‪.‬‬
‫‪ .2‬אם הקלט בשפה‪ ,‬אז המכונה מקבלת או לא עוצרת‪.‬‬
‫נבנה מכונה '𝑀 המקבלת את השפה 𝐿‪.‬‬
‫מכונה '𝑀 על קלט > 𝑀 < תבצע‪:‬‬
‫‪ .1‬נסמלץ את 𝑀 על > 𝑀 <‪.‬‬
‫‪ .2‬אם 𝑀 עצרה‪:‬‬
‫‪ .a‬וקיבלה את הקלט‪ ,‬אז '𝑀 תדחה‪.‬‬
‫‪ .b‬ודחתה את הקלט‪ ,‬אז '𝑀 תקבל‪.‬‬
‫נוכיח את נכונות הבניה‪.‬‬
‫כיוון ראשון ‪ ,< 𝑀 >∈ 𝐿 -‬נראה כי )'𝑀(𝐿 ∈> 𝑀 <‪.‬‬
‫‪ .1‬לפני ההנחה 𝑀 עוצרת ודוחה או לא עוצרת על > 𝑀 <‪.‬‬
‫לכן‪ 𝑀' ,‬תעצור ותקבל או לא תעצור‪( .‬כי אם 𝑀 לא עצרה אז גם '𝑀 לא עוצרת)‪.‬‬ ‫‪.2‬‬
‫‪ .3‬מכאן )'𝑀(𝐿 ∈> 𝑀 <‪.‬‬
‫כיוון שני ‪ ,< 𝑀 >∉ 𝐿 -‬נראה כי )'𝑀(𝐿 ∉> 𝑀 <‪.‬‬

‫‪ .1‬לפי ההנחה‪ 𝑀 ,‬עוצרת ומקבלת את > 𝑀 <‪.‬‬
‫‪ .2‬לכן‪ 𝑀' ,‬תעצור ותדחה‪.‬‬
‫‪ .3‬כלומר‪ < 𝑀 >∉ 𝐿(𝑀') ,‬כנדרש‪.‬‬
‫∎‬
‫האם היא ב‪ - ?RE-‬לא‪ .‬הוכחנו כבר ש‪ .𝑅 = 𝑐𝑜𝑅𝐸 ∩ 𝑅𝐸 :‬אם 𝐸𝑅 ∈ 𝐿 וגם 𝐸𝑅𝑜𝑐 ∈ 𝐿 אז 𝑅 ∈ 𝐿 אבל‬
‫ראינו כבר ש‪ 𝐿 ∉ 𝑅:‬ולכן 𝐸𝑅 ∉ 𝐿‪.‬‬
‫המחלקה ‪ R‬סגורה להיפוך‬

‫𝑅‬
‫{‬ ‫}‬
‫הגדרה‪ :‬בהינתן שפה 𝐿‪ ,‬נגדיר את השפה 𝐿 ∈ ‪.𝐿 = 𝑤 = 𝑎1𝑎2 ... 𝑎𝑛 | 𝑎𝑛 ... 𝑎2𝑎1‬‬
‫𝑅‬
‫טענה‪ :‬תהיה 𝑅 ∈ 𝐿 אז 𝑅 ∈ 𝐿‪ .‬כלומר 𝑅 סגורה להיפוך‪.‬‬
‫הוכחה‪ :‬תהיה שפה 𝑅 ∈ 𝐿 אז קיים לה מכונה 𝑀 המכריעה אותה‪.‬‬
‫𝑅‬ ‫𝑅‬
‫נבנה מכונה 𝑀 שמכריעה את השפה 𝐿‪.‬‬
‫𝑅‬ ‫𝑅‬
‫המכונה 𝑀 על קלט 𝐿 ∈ 𝑥 תפעל בצורה הבאה‪:‬‬
‫𝑅‬
‫‪ .1‬תהפוך את 𝑥 ל‪.𝑥 -‬‬
‫𝑅‬
‫‪ .2‬תפעיל את 𝑀 על 𝑥 ותענה כמו 𝑀‪.‬‬
‫נותר להוכיח את נכונות הבניה‪:‬‬
‫𝑅‬ ‫𝑅‬
‫כיוון ראשון ‪ -‬תהיה 𝐿 ∈ 𝑥 נוכיח ש‪.𝑥 ∈ 𝐿(𝑀 ) :‬‬
‫𝑅‬
‫● לפי הגדרת ההיפוך 𝐿 ∈ 𝑥‪.‬‬
‫𝑅‬
‫● ידוע ש‪ 𝑀-‬מכריעה את 𝐿 ולכן בהפעלתה על 𝑥‪ ,‬היא תעצור ותקבל אותה‪.‬‬
‫𝑅‬
‫● לפי הבניה‪ 𝑀 ,‬עונה אותו הדבר כמו 𝑀 ‪ ,‬אז גם היא תעצור ותקבל‪.‬‬
‫𝑅‬
‫● קיבלנו ש‪ 𝑥 ∈ 𝐿(𝑀 ) :‬כנדרש‪.‬‬
‫𝑅‬ ‫𝑅‬
‫כיוון שני ‪ -‬תהיה 𝐿 ∉ 𝑥‪ ,‬נוכיח כי ) 𝑀(𝐿 ∉ 𝑥‪.‬‬
‫𝑅‬
‫● לפי הגדרת ההיפוך 𝐿 ∉ 𝑥‪.‬‬
‫𝑅‬
‫● ידוע ש‪ 𝑀-‬מכריעה את 𝐿 ולכן בהפעלתה על 𝑥‪ ,‬היא תעצור ותדחה אותה‪.‬‬
‫𝑅‬
‫● לפי הבניה‪ 𝑀 ,‬עונה אותו הדבר כמו 𝑀 ‪ ,‬אז גם היא תעצור ותדחה‪.‬‬
‫𝑅‬
‫● קיבלנו ש‪ 𝑥 ∉ 𝐿(𝑀 ) :‬כנדרש‪.‬‬
‫∎‬
‫המחלקה ‪ R‬סגורה לשרשור‬

‫{‬ ‫}‬
‫הגדרה‪ :‬בהינתן שתי שפות ‪ 𝐿1‬ו‪ ,𝐿2-‬נגדיר את השפה ‪.𝐿1 · 𝐿2 = 𝑣 · 𝑤 | 𝑣 ∈ 𝐿1 , 𝑤 ∈ 𝐿2‬‬
‫טענה‪ :‬יהיו 𝑅 ∈ ‪ 𝐿1, 𝐿2‬אז 𝑅 ∈ ‪ .𝐿1 · 𝐿2‬כלומר 𝑅 סגורה לשרשור‪.‬‬
‫הוכחה‪ :‬יהיו שתי שפות 𝑅 ∈ ‪ .𝐿1, 𝐿2‬יהיו ‪ 𝑀1, 𝑀2‬מ"ט המכריעות את ‪ 𝐿1, 𝐿2‬בהתאמה‪.‬‬
‫נבנה מכונה חדשה '𝑀 שתכריע את השפה ‪.𝐿1 · 𝐿2‬‬
‫'𝑀 על הקלט ‪ 𝑥 ∈ 𝐿1 · 𝐿2‬תבצע‪:‬‬
‫הקלט 𝑥 מורכב מהתווים‪.𝑥 = 𝑎1𝑎2𝑎3.... 𝑎𝑛 :‬‬ ‫‪.1‬‬
‫‪ .2‬לכל 𝑛 ‪ 𝑖 = 1, 2,....,‬בצע‪:‬‬
‫‪.𝑣 = 𝑎1.... 𝑎𝑖 ,‬‬ ‫‪ .a‬נציג פירוק למילה‪ 𝑥 = 𝑣 · 𝑤 :‬כאשר‪𝑤 = 𝑎𝑖+1.... 𝑎𝑛 :‬‬
‫‪ .b‬נריץ את ‪ 𝑀1‬על 𝑣‪.‬‬
‫‪ .c‬נריץ את ‪ 𝑀2‬על 𝑤‪.‬‬
‫‪ .d‬אם ‪ 𝑀1(𝑣) = 1‬וגם ‪( 𝑀2(𝑤) = 1‬שתיהן קיבלו) אז ‪ ,𝑀'(𝑥) = 1‬כלומר נקבל‪.‬‬
‫‪ .3‬אם לא קיבלנו לכל 𝑛 ≤ 𝑖 ≤ ‪ 1‬אז ‪ ,𝑀'(𝑥) = 0‬כלומר נדחה‪.‬‬
‫נותר להוכיח את נכונות הבניה‪.‬‬
‫כיוון ראשון ‪ -‬תהיה ‪ .𝑥 ∈ 𝐿1 · 𝐿2‬נוכיח כי )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫● לפי ההנחה‪ ,‬קיימות מילים ‪ 𝑤 ∈ 𝐿2‬ו‪ 𝑣 ∈ 𝐿1-‬כך ש‪.𝑥 = 𝑣 · 𝑤 :‬‬
‫● בשלב מסוים בריצה‪ 𝑀' ,‬תבחן את החלוקה הנכונה עבור 𝑥‪:‬‬
‫○ ‪ 𝑀1‬תקבל את 𝑣 כי היא מכריעה את ‪.𝐿1‬‬
‫○ ‪ 𝑀2‬תקבל את 𝑤 כי היא מכריעה את ‪.𝐿2‬‬
‫● לכן‪ ,‬לפי הבנייה של '𝑀 היא תקבל כי שתי המכונות גם קיבלו‪.‬‬
‫● מכאן )'𝑀(𝐿 ∈ 𝑥 כנדרש‪.‬‬
‫כיוון שני ‪ 𝑥 ∉ 𝐿1 · 𝐿2 -‬נוכיח כי )'𝑀(𝐿 ∉ 𝑥‪.‬‬

‫● לפי ההנחה‪ ,‬לא קיימות מילים ‪ 𝑤 ∈ 𝐿2‬ו‪ 𝑣 ∈ 𝐿1-‬כך ש‪.𝑥 = 𝑣 · 𝑤 :‬‬
‫● לכן‪ ,‬לכל חלוקה ש '𝑀 תבחן בריצה‪:‬‬
‫○ ‪ 𝑀1‬תדחה את 𝑣 כי היא מכריעה את ‪.𝐿1‬‬
‫○ ‪ 𝑀2‬תדחה את 𝑤 כי היא מכריעה את ‪.𝐿2‬‬
‫● לכן‪ ,‬לפי הבנייה של '𝑀 ‪ -‬היא תדחה כי לכל חלוקה הראנו שגם שתי המכונות דחו‪.‬‬
‫● מכאן )'𝑀(𝐿 ∉ 𝑥 כנדרש‪.‬‬
‫∎‬
‫המחלקה ‪ RE‬סגורה לשרשור‬

‫טענה‪ :‬יהיו 𝐸𝑅 ∈ ‪ 𝐿1, 𝐿2‬אז 𝐸𝑅 ∈ ‪ .𝐿1 · 𝐿2‬כלומר 𝐸𝑅 סגורה לשרשור‪.‬‬
‫מבוא להוכחה‪ :‬אם נוכיח כמו שעשינו עבור 𝑅 ∈ ‪ 𝐿1 · 𝐿2‬אז האלגוריתם שלנו לא יעצור לכל מילה בשפה‪.‬‬
‫למה? ‪ -‬כי כאשר נבחר את הפירוק הנכון 𝑤 · 𝑣 = 𝑥 מובטח לנו ש‪ 𝑀1 :‬ו‪ 𝑀2-‬יעצרו‪ ,‬אבל עבור כל פירוק אחר‪,‬‬
‫המכונות ‪ 𝑀1‬ו‪ 𝑀2-‬יכולות לא לעצור‪ .‬במקרים כאלה‪ ,‬לא נגיע לפירוק הנכון לעולם כי נתקע בלולאה אינסופית‪.‬‬
‫הפתרון הוא להשתמש בשיטת הרצה מבוקרת‪.‬‬
‫הוכחה‪ :‬יהיו שתי שפות 𝐸𝑅 ∈ ‪ .𝐿1, 𝐿2‬יהיו ‪ 𝑀1, 𝑀2‬מ"ט המקבלות את ‪ 𝐿1, 𝐿2‬בהתאמה‪.‬‬
‫נבנה מכונה חדשה '𝑀 שתקבל את השפה ‪.𝐿1 · 𝐿2‬‬
‫'𝑀 על הקלט 𝑥 תבצע‪:‬‬
‫‪ .1‬הקלט 𝑥 מורכב מהתווים‪.𝑥 = 𝑎1𝑎2𝑎3.... 𝑎𝑛 :‬‬
‫‪ .2‬לכל ∞ → ‪ 𝑖 = 1, 2, 3,....‬תבצע‪:‬‬
‫‪ .a‬לכל אפשרות של פירוק המילה 𝑥 ל‪ 2-‬מילים‪ 𝑥 = 𝑣 · 𝑤 :‬תבצע‪:‬‬
‫הרצת ‪ 𝑀1‬על 𝑣 למשך 𝑖 צעדים‪.‬‬ ‫‪.i‬‬
‫הרצת ‪ 𝑀2‬על 𝑤 למשך 𝑖 צעדים‪.‬‬ ‫‪.ii‬‬
‫אם שתיהן קיבלו ‪ -‬אז קבל‪.‬‬ ‫‪.iii‬‬
‫‪ .3‬אם עברנו על כל האפשרויות ולא קיבלנו כלל ‪ -‬דחה‪.‬‬
‫נוכיח את נכונות הבניה‪.‬‬
‫כיוון ראשון ‪ ,𝑥 ∈ 𝐿1 · 𝐿2 -‬נוכיח )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫● לפי ההנחה‪ ,‬למילה 𝑥 קיים פירוק מהצורה 𝑤 · 𝑣 = 𝑥 כך ש‪.𝑣 ∈ 𝐿1, 𝑤 ∈ 𝐿2 :‬‬
‫● נניח ש‪ 𝑀1(𝑣) = 1 :‬לאחר ‪ 𝑘1‬צעדים וגם ‪ 𝑀2(𝑤) = 1‬לאחר ‪ 𝑘2‬צעדים‪.‬‬
‫● באיטרציה ה‪ ,𝑖 = 𝑚𝑎𝑥{𝑘1, 𝑘2}-‬כאשר נבחן את החלוקה הנכונה נקבל ש‪:‬‬
‫○ ‪ 𝑀1‬תקבל את 𝑣 כי היא מקבלת את ‪.𝐿1‬‬
‫○ ‪ 𝑀2‬תקבל את 𝑤 כי היא מקבלת את ‪.𝐿2‬‬
‫● לכן‪ 𝑀' ,‬תקבל כי שתי המכונות קיבלו‪.‬‬
‫● מכאן )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫כיוון שני ‪ ,𝑥 ∉ 𝐿1 · 𝐿2 -‬נוכיח כי )'𝑀(𝐿 ∉ 𝑥‪.‬‬
‫● לפי ההנחה‪ ,‬לא קיים אף פירוק מהצורה 𝑤 · 𝑣 = 𝑥 כך ש‪.𝑣 ∈ 𝐿1 , 𝑤 ∈ 𝐿2 :‬‬
‫● לכל חלוקה ש‪ 𝑀' :‬תבחן ולכל מספר צעדים שנריץ ("או" בין ‪ 2‬המקרים הבאים)‪:‬‬
‫○ ‪ 𝑀1‬תדחה או לא תעצור על 𝑣 כי הוא לא ב‪.𝐿1-‬‬
‫○ ‪ 𝑀2‬תדחה או לא תעצור על 𝑤 כי הוא לא ב‪.𝐿2-‬‬
‫● בכל איטרציה‪ 𝑀' ,‬תרוץ על כל האופציות בלי לקבל בשום שלב ריצה‪.‬‬
‫● המכונה '𝑀 לא תסיים את ריצתה לעולם‪( .‬כי הלולאה הראשית רצה לאינסוף ונעצרת רק אם נקבל)‪.‬‬
‫● מכאן )'𝑀(𝐿 ∉ 𝑥 כנדרש‪.‬‬
‫∎‬
‫המחלקה ‪ coRE‬סגורה לאיטרציה‬

‫⋆‬
‫טענה‪ :‬תהי שפה 𝐸𝑅𝑜𝑐 ∈ 𝐿‪ ,‬אזי גם 𝐸𝑅𝑜𝑐 ∈ 𝐿 (סגירות לאיטרציה‪/‬סגור‪-‬קליין)‪.‬‬
‫הוכחה‪ :‬תהי שפה 𝐸𝑅𝑜𝑐 ∈ 𝐿 אז קיים לה מכונה 𝑀 שמקבלת אותה‪.‬‬
‫⋆‬ ‫⋆‬
‫נבנה מכונה חדשה 𝑀 שתקבל את השפה 𝐿‪.‬‬
‫⋆‬
‫𝑀 על הקלט 𝑥 תבצע הרצה מבוקרת "חזקה"‪:‬‬
‫⋆‬
‫‪ .1‬נבחר 𝑘 כך ש‪ 1 ≤ 𝑘 ≤ |𝑥| :‬ונבחר פירוק של 𝑥 ל‪ 𝑘-‬מילים כך‪ 𝑥 = 𝑥1... 𝑥𝑘 :‬כאשר ‪:𝑥𝑖 ∈ Σ‬‬
‫‪ .2‬לכל ‪ 𝑖 = 1, 2, 3,....‬תבצע‪:‬‬
‫‪ .a‬לכל 𝑖 ≤ 𝑗 ≤ ‪ 1‬בצע‪:‬‬
‫סמלץ את 𝑀 על 𝑗𝑥 על 𝑖 צעדים‪.‬‬ ‫‪.i‬‬
‫⋆‬
‫אם 𝑀 דחה‪ 𝑀 ,‬דוחה‪.‬‬ ‫‪.ii‬‬
‫⋆‬
‫‪ .b‬אם 𝑀 קיבל את כל ה‪-𝑥𝑗-‬ים‪ 𝑀 ,‬מקבל‪.‬‬
‫נכונות‪:‬‬
‫⋆‬
‫● אם 𝐿 ∈ 𝑥 אז קיים פירוק של 𝑥 לצורה 𝑘𝑥 ‪ 𝑥 = 𝑥1...‬כך שלכל 𝑗𝑥 מתקיים 𝐿 ∈ 𝑗𝑥‪.‬‬
‫לכן‪ ,‬יכול להתקיים אחד מהשניים‪:‬‬
‫⋆‬
‫‪ .1‬המכונה 𝑀 קיבלה את כל ה‪-𝑥𝑗-‬ים ולכן 𝑀 תקבל‪.‬‬
‫⋆‬
‫‪ .2‬המכונה 𝑀 לא עוצרת עבור 𝑗𝑥 מסוים וכך גם המכונה 𝑀‪.‬‬
‫⋆‬
‫● אם 𝐿 ∉ 𝑥 אז לכל פירוק של 𝑥 לצורה 𝑘𝑥 ‪ 𝑥 = 𝑥1...‬קיים 𝑗𝑥 כך ש‪.𝑥𝑗 ∉ 𝐿 :‬‬
‫⋆‬
‫לכן‪ 𝑀(𝑥𝑗) ,‬ידחה (עבור 𝑖 גדול מספיק) וגם 𝑀 ידחה באותו האופן‪.‬‬
‫∎‬
‫רדוקציות‬
‫מבוא‬
‫רדוקציה היא שיטה אלגוריתמית המאפשרת להמיר בעיה נתונה לבעיה‬
‫אחרת שבעזרתה ניתן לפתור את הבעיה המקורית‪ .‬לדוגמה‪ ,‬נניח שנתונה‬
‫סדרת מספרים כלשהי‪ ,‬ונניח שקל לפתור את הבעיה "מהו המספר הראשון‬
‫בסדרה"‪ .‬את הבעיה "מהו המספר הקטן ביותר בסדרה" נוכל לפתור באופן‬
‫הבא‪ :‬ראשית נמיין את סדרת המספרים‪ ,‬ואז נפעיל את האלגוריתם שפותר‬
‫את בעיית "מהו המספר הראשון בסדרה" התוצאה תהיה המספר הקטן‬
‫ביותר בסדר‪ .‬משפט רייס מוכיח שהבעיה של זיהוי תכונה לא טריוויאלית של‬
‫פונקציה היא לא כריעה על ידי רדוקציה מבעיית העצירה (שאינה כריעה) אליה‪.‬‬
‫בציור‪ :‬כל הקלטים ב‪ 𝐿1-‬ממופים לקלטים של ‪ ,𝐿2‬ואילו קלטים שאינם ב‪ 𝐿1-‬ממופים לקלטים שאינם ב‪.𝐿2-‬‬
‫תזכורת מהרצאה קודמת‬

‫אם 𝐿 ∉ 𝑥‬ ‫אם 𝐿 ∈ 𝑥‬
‫דוחה‬ ‫מקבל‬ ‫𝑅 ∈ 𝐿 (הכרעה)‬
‫דוחה או לא עוצר‬ ‫מקבל‬ ‫𝐸𝑅 ∈ 𝐿 (קבלה)‬
‫דוחה‬ ‫מקבל או לא עוצר‬ ‫𝐸𝑅𝑜𝑐 ∈ 𝐿 (דחייה)‬
‫בנוסף‪ ,‬למדנו על בעיית העצירה עם השפה }𝑥 𝑛𝑜 )𝑠𝑝𝑜𝑡𝑠( 𝑠𝑡𝑙𝑎‪.𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ‬‬
‫וראינו כי אם 𝑀 עצרה על 𝑥 אז 𝑃𝐻 ∈> 𝑥 ‪ ,< 𝑀,‬כלומר הגענו למצב מקבל 𝑡𝑝𝑒𝑐𝑐𝑎𝑞 והקלט בשפה‪.‬‬
‫אם 𝑀 לא עצרה על 𝑥 אז 𝑃𝐻 ∉> 𝑥 ‪ ,< 𝑀,‬אבל אנחנו לא יודעים אם בוודאות המכונה עצרה‪.‬‬
‫לכן‪ ,‬המכונה 𝑀 לא יכולה להכריע את השפה‪ .‬מכאן ‪ 𝐻𝑃 ∈ 𝑅𝐸 -‬אבל 𝑅 ∉ 𝑃𝐻‪.‬‬
‫רדוקציה (הגדרה)‬
‫תהיינה שפות * ‪ ,𝐿1, 𝐿2 ⊆ Σ‬נאמר ש‪ 𝐿1 :‬ניתנת לרדוקציה ל‪( 𝐿2-‬נסמן ‪)𝐿1 ≤ 𝐿2‬‬
‫אם ורק אם קיימת פונקציה * ‪ 𝑓: Σ *→ Σ‬שהיא‪:‬‬
‫‪ .1‬פונקציה מלאה‪ :‬פונקציה המוגדרת לכל קלט‪.‬‬
‫‪ .2‬פונקציה הניתנת לחישוב‪ :‬כלומר‪ ,‬קיימת מכונת טיורינג שיכולה לחשב את הפונקציה הזו‪.‬‬
‫‪ .3‬פונקציה תקפה‪.∀𝑥 ∈ Σ * : 𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2 :‬‬
‫‪1‬‬
‫= )𝑥(𝑓 כאשר ‪ 𝑥 = 0‬לא מוגדר‪.‬‬ ‫𝑥‬
‫הערות‪ :‬פונקציה לא מלאה יכולה להיות מהצורה‬
‫● פונקציה תקפה ‪ -‬כל קלט 𝑥 שמתקבל ב‪ ,𝐿1-‬הפונקציה שלו )𝑥(𝑓 צריכה להתקבל ב‪.𝐿2-‬‬
‫תקפות של פונקצית רדוקציה‬

‫הגדרה ‪ -‬פונקציה תקפה‪.∀𝑥 ∈ Σ * : 𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2 :‬‬
‫באיור‪ :‬אם נצליח להראות שאם אחרי הפעלת הפונקציה‪ ,‬קיבלנו משהו שמתקבל ב‪ 𝐿2-‬אז לפני זה הוא התקבל‬
‫ב‪ 𝐿1-‬וגם להפך‪ .‬למשל‪ ,‬אם ‪ 𝐿2‬לא עוצר על )𝑥(𝑓 אז גם ‪ 𝐿1‬לא יעצור‪.‬‬
‫משפט הרדוקציה‬
‫אם ‪( 𝐿1 ≤ 𝐿2‬אם ‪ 𝐿1‬ניתנת לרדוקציה ל‪ )𝐿2-‬אז‪:‬‬
‫● אם 𝑅 ∈ ‪ 𝐿2‬אז גם 𝑅 ∈ ‪.𝐿1‬‬
‫● אם 𝐸𝑅 ∈ ‪ 𝐿2‬אז גם 𝐸𝑅 ∈ ‪.𝐿1‬‬
‫● אם 𝐸𝑅𝑜𝑐 ∈ ‪ 𝐿2‬אז גם 𝐸𝑅𝑜𝑐 ∈ ‪.𝐿1‬‬
‫רעיון ההוכחה (בציור)‪:‬‬

‫● אם ‪" 𝐿1‬קשה" כמו ‪ ,𝐿2‬אז אנחנו יודעים לסווג את ‪ 𝐿2‬ואז גם את ‪ 𝐿1‬אנחנו נדע לסווג‪.‬‬
‫● אם אנחנו יודעים של‪ 𝐿2 ∈ 𝑅𝐸-‬יש מ"ט מקבלת אז גם ל‪ 𝐿1 ∈ 𝑅𝐸-‬אפשר יהיה לבנות מ"ט מקבלת‪.‬‬
‫● בציור‪ :‬ההרכבה של המכונה ‪( 𝑀2‬פונקציה ל‪ )𝐿2-‬עם המכונה 𝑓𝑀 (פונקצית רדוקציה) תיצור את‬
‫המכונה ‪ 𝑀1‬שתתן פתרון עבור ‪.𝐿1‬‬
‫הוכחת משפט הרדוקציה‬

‫אנחנו נוכיח עבור 𝑅‪ ,‬ועבור שתי המחלקות הנוספות ‪ -‬ההוכחה דומה‪.‬‬
‫טענה‪ :‬אם ‪ 𝐿1 ≤ 𝐿2‬וגם 𝑅 ∈ ‪ 𝐿2‬אז גם 𝑅 ∈ ‪.𝐿1‬‬

‫הוכחה‪ :‬נניח ש‪ ,𝐿1 ≤ 𝐿2 :‬אזי קיימת מכונת טיורינג 𝑓𝑀 המחשבת את פונקציית הרדוקציה מ‪ 𝐿1-‬ל‪.𝐿2-‬‬
‫ונניח שגם 𝑅 ∈ ‪ ,𝐿2‬אזי קיימת מכונת טיורינג ‪ 𝑀2‬המכריעה את השפה ‪.𝐿2‬‬
‫נתאר מכונה מכריעה ‪ 𝑀1‬לשפה ‪:𝐿1‬‬
‫המכונה ‪ 𝑀1‬על קלט 𝑥‪:‬‬
‫‪ .1‬מחשבת את )𝑥(𝑓 (על ידי סימלוץ של ריצת 𝑓𝑀 על הקלט 𝑥)‪.‬‬
‫‪ .2‬מריצה את ‪ 𝑀2‬על )𝑥(𝑓 ועונה כמוה‪.‬‬
‫נכונות המכונה נובעת ישירות מהתכונות של פונקציית הרדוקציה‪.‬‬
‫● מכיוון שהפונקציה מלאה וניתנת לחישוב‪ ,‬השלב הראשון (חישוב הפונקציה) תמיד יעבור בהצלחה‪.‬‬
‫● הפונקציה תקפה‪:‬‬
‫○ )‪𝑥 ∈ 𝐿1 → 𝑓(𝑥) ∈ 𝐿2 → 𝑀2(𝑓(𝑥)) = 1 → 𝑀1(𝑥) = 1 → 𝑥 ∈ 𝐿(𝑀1‬‬
‫○ )‪𝑥 ∉ 𝐿1 → 𝑓(𝑥) ∉ 𝐿2 → 𝑀2(𝑓(𝑥)) = 0 → 𝑀1(𝑥) = 0 → 𝑥 ∉ 𝐿(𝑀1‬‬
‫● התנאים בנוגע למתי המכונה ‪ 𝑀1‬עוצרת ומתי לא‪ ,‬זהים עבור המכונה ‪.𝑀2‬‬
‫משפט הרדוקציה ‪ -‬ניסוח שקול (ושימושי יותר)‬

‫אם ‪( 𝐿1 ≤ 𝐿2‬אם ‪ 𝐿1‬ניתנת לרדוקציה ל‪ )𝐿2-‬אז‪:‬‬
‫● אם 𝑅 ∉ ‪ 𝐿1‬אז גם 𝑅 ∉ ‪.𝐿2‬‬
‫● אם 𝐸𝑅 ∉ ‪ 𝐿1‬אז גם 𝐸𝑅 ∉ ‪.𝐿2‬‬
‫● אם 𝐸𝑅𝑜𝑐 ∉ ‪ 𝐿1‬אז גם 𝐸𝑅𝑜𝑐 ∉ ‪.𝐿2‬‬
‫הערות‪:‬‬
‫● נזכר בהוכחה בסוף של מצגת ‪ ,2‬למעשה הוכחנו שיש רדוקציה 𝑃𝐻 ≤ 𝐷𝐿‪ .‬ואז מכיוון ש‪ 𝐿𝐷 ∉ 𝑅 :‬אזי‬
‫לפי משפט הרדוקציה נובע שגם 𝑅 ∉ 𝑃𝐻‪.‬‬
‫● בדרך כלל‪ ,‬כשנתעסק ברדוקציות‪ ,‬אנחנו נתעסק עם המשפט של הניסוח השקול‪.‬‬
‫כלומר‪ ,‬אם ‪ 𝐿1 ≤ 𝐿2‬אז אפשר להגיד שהשפה ‪ 𝐿1‬יכולה להיות אחת מהשפות הבאות שנלמדו‪:‬‬
‫𝑅 ∉ 𝑈𝐿 ‪ 𝐻𝑃, 𝐿𝐷,‬ואז גורר מכך ש‪ .𝐿2 ∉ 𝑅 :‬כי אם ‪" 𝐿2‬קשה" לפחות כמו ‪ 𝐿1‬אז בוודאות 𝑅 ∉ ‪.𝐿2‬‬
‫● כלומר‪ ,‬אם נסתכל על ‪ 𝐿1 ≤ 𝐿2‬אז אפשר להגיד שאם "השמאלי" לא ב‪ 𝑅-‬אז גם "הימני" לא ב‪.𝑅-‬‬
‫וזה נכון גם עבור 𝐸𝑅𝑜𝑐 ‪.𝑅𝐸,‬‬
‫הוכחת 𝑅 ∉ 𝑃𝐻 על ידי רדוקציה‬

‫נוכיח כעת שנית את אותה הטענה אבל בעזרת רדוקציה‪.‬‬
‫𝐸𝑅 ∈ }> 𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑀 <{ = 𝐷𝐿‬
‫𝐸𝑅 ∈ }𝑥 𝑛𝑜 )𝑠𝑝𝑜𝑡𝑠( 𝑠𝑡𝑙𝑎‪𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ‬‬
‫נראה כי 𝑅 ∉ 𝑃𝐻 אך הפעם נעשה זאת במבנה הוכחה של רדוקציה‪.‬‬
‫טענה‪.𝐻𝑃 ∉ 𝑅 :‬‬
‫הקדמה להוכחה‪ :‬נציג כאן מכונה '𝑀 שתייצג את 𝑃𝐻 ומכונה 𝑀 שתייצג את 𝐷𝐿‪.‬‬
‫הוכחה‪ :‬נוכיח ע"י בניית רדוקציה 𝑃𝐻 ≤ 𝐷𝐿‪ ,‬ואז לפי משפט הרדוקציה נקבל שמכיוון ש‪ 𝐿𝐷 ∉ 𝑅 :‬אז גם‬
‫<(𝑓‪( .‬זה פונקציה 𝑃𝐻 → 𝐷𝐿 כמו "המרה" )‪.‬‬ ‫𝑅 ∉ 𝑃𝐻‪ .‬פונקציית הרדוקציה‪𝑀 >) =< 𝑀', < 𝑀 >> :‬‬
‫כאשר '𝑀 על קלט 𝑦‪:‬‬
‫● מסמלצת את ריצת 𝑀 על 𝑦‪.‬‬
‫אם 𝑀 קיבלה אז גם '𝑀 מקבלת‪( .‬כי אמרנו ש‪ 𝐿𝐷 ∈ 𝑅𝐸 :‬וב‪ 𝑅𝐸-‬כל מילה 𝐷𝐿 ∈ 𝑥 הוא מתקבל ועוצר)‪.‬‬ ‫●‬
‫אם 𝑀 דחתה אז '𝑀 נכנסת ללולאה אינסופית‪( .‬כי לפי הגדרת 𝑃𝐻‪ ,‬המכונה שלה לא עוצרת [‪ ]halts‬לכל דחייה‪.‬‬
‫במילים אחרות‪ ,‬אם הקלט 𝑥 לא התקבל ב‪ 𝐿𝐷-‬אז הוא גם לא מתקבל ב‪ 𝐻𝑃-‬ולפי הגדרת השפה‪ ,‬המכונה של 𝑃𝐻 לא עוצרת)‪.‬‬
‫כעת‪ ,‬צריך להוכיח שהפונקציה מלאה‪ ,‬ניתנת לחישוב ותקפה (מספיק להראות זאת בנוגע לקלט תקין)‪:‬‬
‫● הפונקציה מלאה כיוון שמכל מכונה 𝑀 שנתונה לנו‪ ,‬ניתן לבנות את המכונה '𝑀‪.‬‬
‫● הפונקציה ניתנת לחישוב כיוון שלמדנו שכל מכונת טיורינג ניתנת לקידוד כמחרוזת‪.‬‬
‫● הפונקציה תקפה‪ :‬צריך להראות ש‪.∀𝑥 ∈ Σ * : 𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2 :‬‬
‫○ אם 𝐷𝐿 ∈ 𝑀 )🠈( 𝑀 מקבלת את > 𝑀 < )🠈( '𝑀 גם עוצרת על > 𝑀 < ומקבלת‬
‫= )> 𝑀 <(𝑓‪.‬‬ ‫> 𝑀 < ‪< 𝑀' ,‬‬ ‫>‬ ‫)🠈( 𝑃𝐻 ∈‬
‫○ אם 𝐷𝐿 ∉ 𝑀 )🠈( 𝑀 דוחה את > 𝑀 < או לא עוצרת )🠈( '𝑀 עוברת ללולאה אינסופית על‬
‫= )> 𝑀 <(𝑓‪.‬‬ ‫> 𝑀 < ‪< 𝑀' ,‬‬ ‫>‬ ‫> 𝑀 < או דוחה אותה )🠈( 𝑃𝐻 ∉‬
‫∎‬
‫𝐸𝑅 ∈ }> 𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑀 <{ = 𝐷𝐿‬

‫𝐸𝑅 ∈ }𝑥 𝑛𝑜 )𝑠𝑝𝑜𝑡𝑠( 𝑠𝑡𝑙𝑎‪𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ‬‬
‫אבחנה‪ :‬הפונקציה הזו מתאימה גם אם נחליף את השפה 𝑃𝐻 בשפה‪:‬‬

‫𝐸𝑅 ∈ }𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑥 ‪𝐿𝑢 = {< 𝑀,‬‬
‫כלומר‪ .𝑓(𝑥) =< 𝑀', 𝑥 > ,‬לכן מתקיים כי 𝑢𝐿 ≤ 𝐷𝐿‪ .‬מכאן גם 𝑅 ∉ 𝑢𝐿‪.‬‬
‫● במילים אחרות‪ ,‬אם 𝑃𝐻 ≤ 𝐷𝐿 אז אותה רדוקציה בדיוק תתאים גם ל‪ 𝐿𝐷 ≤ 𝐿𝑢-‬ואז 𝑅 ∉ 𝑢𝐿‪.‬‬
‫תכונות של יחס הרדוקציה‬

‫תכונה ‪ :1‬אם ‪ 𝐿1 ≤ 𝐿2‬אז גם ‪.𝐿1 ≤ 𝐿2‬‬
‫הוכחה‪ :‬זוהי תוצאה ישירה של התקפות של הרדוקציה‪.‬‬
‫שאלה‪ :‬האם אפשר להשתמש באותה הפונקציה 𝑓 אבל עבור המשלים?‬
‫תשובה‪ :‬כן‪ .‬כי לפי התקפות של פונקצית הרדוקציה‪. 𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2:‬‬
‫לכן‪ ,‬אם ‪ 𝑥 ∈ 𝐿1‬אז גם ‪ 𝑓(𝑥) ∈ 𝐿2‬ולהפך‪ ,‬אם ‪ 𝑥 ∉ 𝐿1‬אז גם ‪.𝑓(𝑥) ∉ 𝐿2‬‬
‫כלומר‪ ,‬אם ‪ 𝑥 ∈ 𝐿1‬אז גם ‪( .𝑓(𝑥) ∈ 𝐿2‬המחשה בציור מלמטה)‪:‬‬
‫תכונה ‪ :2‬היחס ≤ הוא רפלקסיבי‪.‬‬

‫כלומר‪ :‬לכל שפה 𝐿 מתקיים 𝐿 ≤ 𝐿‪ .‬במילים אחרות‪ ,‬כל פונקציה ניתנת לרדוקציה לעצמה‪.‬‬
‫רעיון ההוכחה‪ :‬מתבצע בעזרת פונקציית הזהות 𝑥 = )𝑥(𝑓‪.‬‬
‫תכונה ‪ :3‬היחס ≤ הוא טרנזיטיבי‪.‬‬

‫כלומר‪ :‬אם ‪ 𝐿1 ≤ 𝐿2‬וגם ‪ 𝐿2 ≤ 𝐿3‬אז גם ‪.𝐿1 ≤ 𝐿3‬‬
‫רעיון ההוכחה‪ :‬הרכבת פונקציות‪ :‬אם ‪ 𝑓(𝐿1) → 𝐿2‬וגם ‪ 𝑔(𝐿2) → 𝐿3‬אז ‪.𝑔(𝑓(𝐿1)) → 𝐿3‬‬
‫תכונה ‪ :4‬היחס ≤ הוא לא סימטרי‪.‬‬

‫כלומר‪ :‬אם ‪ 𝐿1 ≤ 𝐿2‬אז לא בהכרח מתקיים ש‪.𝐿2 ≤ 𝐿1 :‬‬
‫דוגמה‪ :‬ניקח את השפות 𝑃𝐻 ו‪.Σ * -‬‬
‫● מצד אחד ‪ -‬אפשר לחשוב על רדוקציה 𝑃𝐻 ≤* ‪ ,Σ‬למשל > 𝑥 ‪.𝑓(𝑥) =< 𝑀𝑆𝑇𝐴𝑀,‬‬
‫תזכורת ‪ -‬המכונה 𝑀𝐴𝑇𝑆𝑀 מעבירה מיד קידוד לא תקין למצב 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪.‬‬
‫כל מילה * ‪ 𝑥 ∈ Σ‬תמיד מתקבלת‪ .‬לכן‪ ,‬נבחר במכונה 𝑀𝐴𝑇𝑆𝑀 שמקבלת כל 𝑥‪.‬‬
‫● מצד שני ‪ 𝐻𝑃 ≤ Σ * -‬לא מתקיים‪ ,‬כי אז לפי משפט הרדוקציה היינו מקבלים כי גם 𝑅 ∈ 𝑃𝐻‪.‬‬
‫אבל ב‪ 𝐻𝑃-‬יש קלטים שלא עוצרים‪ ,‬וב‪ Σ *-‬הכל מתקבל בשפה כי זה כל 𝑥 (ניתן להכרעה)‪.‬‬
‫תרגיל ‪ - 1‬שאלה לדוגמה‬

‫> 𝑀 <{ = 𝐿‪.‬‬ ‫נתונה השפה‪: |𝐿(𝑀)| ≥ 4 } :‬‬
‫סעיף א'‪ :‬קבעו האם 𝐸𝑅 ∈ 𝐿? הוכיחו את תשובתכם‪.‬‬
‫פתרון סעיף א'‪ :‬אכן השפה 𝐸𝑅 ∈ 𝐿‪ .‬נוכיח ע"י תיאור מ"ט מקבלת לשפה 𝐿‪.‬‬
‫נצטרך פה הרצה מבוקרת "חזקה"‪ ,‬שיכולה (תיאורטית) לעבור על כל המילים ב‪.Σ *-‬‬
‫המכונה 𝑈 על קלט > 𝑀 <‪:‬‬
‫נשתמש בסידור לקסיקוגרפי (אינסופי) של * ‪ Σ‬כך‪.𝑤1, 𝑤2, 𝑤3,... :‬‬ ‫‪1‬‬
‫אתחל מונה ‪ .𝑐𝑜𝑢𝑛𝑡𝑒𝑟 = 0‬בכל שלב אם ‪ 𝑐𝑜𝑢𝑛𝑡𝑒𝑟 = 4‬אז עצור וקבל‪.‬‬ ‫‪2‬‬
‫לכל ‪ 𝑖 = 1, 2, 3,...‬בצע‪:‬‬ ‫‪3‬‬
‫לכל 𝑖 ≤ 𝑗 ≤ ‪ 1‬בצע‪:‬‬ ‫‪4‬‬
‫𝑤 למשך 𝑖 צעדים‪( .‬כלומר נריץ )]𝑖 ‪.)𝑀(𝑤𝑗[1...‬‬ ‫הרץ את המכונה 𝑀 על המילה‬ ‫‪5‬‬
‫𝑗‬
‫אם 𝑀 קיבלה את המילה 𝑗𝑤 אז הוסף למונה‪.𝑐𝑜𝑢𝑛𝑡𝑒𝑟 = 𝑐𝑜𝑢𝑛𝑡𝑒𝑟 + 1 :‬‬ ‫‪6‬‬
‫אפס את המונה ‪.𝑐𝑜𝑢𝑛𝑡𝑒𝑟 = 0‬‬ ‫‪7‬‬
‫נוכיח שהמכונה 𝑈 מקבלת את השפה 𝐿‪:‬‬

‫● אם 𝐿 ∈> 𝑀 < אז קיימות ‪ 4‬במילים 𝑟𝑤 ‪ 𝑤𝑖, 𝑤𝑗 , 𝑤𝑘,‬המתקבלות בכמות הצעדים הקטנה ביותר ‪-‬‬
‫𝑡 ונניח בה"כ ש‪ .𝑖, 𝑗, 𝑘, 𝑟 < 𝑡 :‬אזי באיטרציה 𝑡 של האלגוריתם‪ ,‬נספק לכל מילה 𝑡 צעדים עד ש‪𝑀-‬‬
‫יריץ את המילה 𝑡𝑤‪ .‬באיטרציה זו‪ ,‬נקבל את 𝑟𝑤 ‪ 𝑤𝑖, 𝑤𝑗 , 𝑤𝑘,‬ולכן )𝑈(𝐿 ∈> 𝑀 <‪.‬‬
‫● אם 𝐿 ∉> 𝑀 < אז לא קיימות לפחות ‪ 4‬מילים כאלה‪ ,‬אנחנו נמשיך לרוץ בלולאה ונחפש את המילים‬
‫האלה למרות שהם לא קיימות ‪ -‬לכן אנחנו לא נעצור לעולם ונרוץ לאינסוף‪ .‬ולכן )𝑈(𝐿 ∉> 𝑀 <‪.‬‬
‫הוכחנו ש‪ 𝐿(𝑈) = 𝐿 :‬וכן המכונה 𝑈 מקבלת את השפה 𝐿 כנדרש‪.‬‬
‫∎‬
‫סעיף ב'‪ :‬קבעו האם 𝑅 ∈ 𝐿? הוכיחו את תשובתכם‪.‬‬

‫אינטואיציה‪ :‬הרגע הוכחנו ש‪ 𝐿 ∈ 𝑅𝐸 :‬והראנו באלגוריתם בהרצה מבוקרת כי אם 𝐿 ∉> 𝑀 < אז לא נעצור‬
‫לעולם‪ .‬לכן‪ ,‬לא נוכל לבנות מכונה שתכריע את השפה הזאת‪.‬‬
‫פתרון סעיף ב'‪ :‬השפה 𝐿 איננה ב‪ .𝑅-‬נוכיח זאת ע"י רדוקציה 𝐿 ≤ 𝑃𝐻‪.‬‬
‫פונקצית הרדוקציה היא‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀𝑥 > :‬‬
‫כאשר 𝑥𝑀 על קלט 𝑦 אז‪:‬‬
‫● מריצה את 𝑀 על 𝑥 (מתעלמת מהקלט 𝑦)‪.‬‬
‫● 𝑥𝑀 מקבלת את 𝑦‪.‬‬
‫נכונות הפונקציה‪:‬‬
‫● הפונקציה מלאה ‪ -‬לכל קידוד של מכונה וקלט נתונים‪ ,‬ניתן לבנות את המכונה 𝑥𝑀‪.‬‬
‫● הפונקציה ניתנת לחישוב ‪ -‬כל מ"ט ניתנת לקידוד כמחרוזת‪.‬‬
‫● הפונקציה תקפה ‪ -‬צריך להראות ש‪.∀𝑥 ∈ Σ * : 𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2 :‬‬
‫○ אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 (🠈) < 𝑀,‬עוצרת על 𝑥 )🠈( 𝑥𝑀 גם עוצרת על 𝑦 ומקבלת‬
‫)🠈( 𝐿 ∈> 𝑥𝑀 <= )> 𝑥 ‪.𝑓(< 𝑀,‬‬
‫○ אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 (🠈) < 𝑀,‬לעולם לא עוצרת על 𝑥 )🠈( 𝑥𝑀 גם לעולם לא עוצרת על 𝑦 ולכן‬
‫)🠈( 𝐿 ∉> 𝑥𝑀 <= )> 𝑥 ‪.𝑓(< 𝑀,‬‬
‫∎‬
‫הסבר על הרדוקציה הזאת‪ :‬לפי משפט הרדוקציה (השקול)‪ ,‬עבור 𝐿 ≤ 𝑃𝐻 אז אם 𝑅 ∉ 𝑃𝐻 גם 𝑅 ∉ 𝐿‪.‬‬

‫פונקציית הרדוקציה לוקחת קלט שהיא מילה > 𝑥 ‪ < 𝑀,‬מהשפה 𝑃𝐻‪ ,‬ומחזירה פלט שהיא מילה > 𝑥𝑀 <‬
‫משפה 𝐿‪ .‬אם 𝑀 עצרה על 𝑥‪ ,‬אז 𝑥𝑀 צריכה לקבל לפחות ‪ 4‬מילים‪ .‬לכל קלט 𝑦 ב‪ ,𝑀𝑥-‬המכונה תמיד תקבל‬
‫אותה‪ ,‬למה? כי 𝑥𝑀 "מפעילה את 𝑀 על 𝑥" ובגלל ש‪"-‬מפעילה את 𝑀 על 𝑥" תמיד עוצר (כי היא שייכת ל‪)𝐻𝑃-‬‬
‫אז תמיד נוכל להמשיך לשלב הבא באלגוריתם שזה לקבל את 𝑦 תמיד ללא תנאים‪.‬‬
‫|‬ ‫|‬
‫ואם 𝑦 תמיד תתקבל לא משנה איזה 𝑦 זה‪ ,‬אז זה אומר ש‪ 𝑀𝑥 :‬מקבל כל דבר ‪ -‬כלומר ∞ = )𝑥𝑀(𝐿 ‪.‬‬
‫לכן‪ ,‬יש בהכרח לפחות ‪ 4‬מילים בשפת המכונה ואם כך 𝐿 ∈> 𝑥𝑀 <‪.‬‬
‫תרגיל ‪ - 2‬שאלה לדוגמה‬

‫נתונה השפה‪.𝐿2 = {< 𝑀 > | 𝑀 𝑠𝑡𝑜𝑝𝑠 𝑓𝑜𝑟 𝑒𝑣𝑒𝑟𝑦 𝑖𝑛𝑝𝑢𝑡 𝑥 ∈ Σ *} :‬‬
‫נשים לב שהרדוקציה האחרונה שראינו‪ ,‬מתאימה גם לשפה הזו‪ ,‬כי אם 𝑀 עוצרת על כל 𝑥 אז היא בוודאי ש‪:‬‬
‫𝑅 ∉ ‪ .𝐿2‬בנוסף‪ ,𝐿2 ∉ 𝑐𝑜𝑅𝐸 ,‬נחזור לזה בהמשך‪.‬‬
‫השפה איננה ב‪ .𝑅-‬נוכיח זאת ע"י רדוקציה ‪.𝐻𝑃 ≤ 𝐿2‬‬
‫● מקבלת (את 𝑦)‪.‬‬
‫נכונות הפונקציה דומה להוכחה ברדוקציה שעשינו בשאלה הקודמת‪.‬‬
‫תמונת העולם עד כה‬

‫עד עכשיו‪ ,‬הוכחנו ולמדנו על כל מה שמופיע בציור‬
‫משמאל‪ ,‬כולל השפות המשלימות ב‪.𝑐𝑜𝑅𝐸-‬‬
‫מה לגבי שפות שלא שייכות ל‪ 𝑅𝐸-‬וגם לא שייכות ל‪-‬‬

‫𝐸𝑅𝑜𝑐? נראה כאלה עכשיו‪.‬‬
‫הקדמה ‪ -‬רוב השפות לא שייכות ל‪ 𝑅𝐸-‬ולא ל‪𝑐𝑜𝑅𝐸-‬‬

‫(‬ ‫)‬
‫● כל מכונת טיורינג מורכבת משביעייה ‪.𝑀 = 𝑄, 𝑞0, 𝐹, Γ, Σ, 𝑏‾, δ‬‬
‫● כל איבר איבר בשביעייה מכיל קבוצה שגודלה הוא בן מניה‪.‬‬
‫● מ"ט מורכבת ממכפלה קרטזית של ‪ 7‬קבוצות בנות מניה‪.‬‬
‫● לכן יש מספר בן מניה של שפות ב‪.𝑅𝐸-‬‬
‫● אבל‪ ,‬יש מספר לא בן מניה של שפות (הוכחנו בקורס אוטומטים)‪.‬‬
‫תרגיל ‪3‬‬
‫נציג כאן דוגמה לשפה ששייכת ל‪( .𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸 -‬כלומר שפה שלא ב‪ 𝑅𝐸-‬ולא ב‪.)𝑐𝑜𝑅𝐸-‬‬
‫נתונה השפה הבאה‪.𝐿∞ = {< 𝑀 > : |𝐿(𝑀)| = ∞} :‬‬
‫אינטואיציה‪ :‬גם אם נצליח לוודא שהמכונה מקבלת המון קלטים‪ ,‬כל כמות שנצליח לבדוק היא בהכרח סופית‪.‬‬
‫לדוגמה‪ ,‬לא נוכל לבצע הרצה מבוקרת על אינסוף מילים‪ ,‬כי הרצה מבוקרת תמיד תעצור לפי הגדרתה‪.‬‬
‫בכל איטרציה‪ ,‬היא עוצרת על כמות סופית של מילים ותבדוק אותם‪.‬‬
‫טענה‪.𝐿∞ ∈ 𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸 :‬‬
‫מבוא‪ :‬ההוכחה תהיה בשני שלבים‪:‬‬
‫‪ - 𝐻𝑃 ≤ 𝐿∞ .1‬ממשפט הרדוקציה נובע ש‪.𝐿∞ ∉ 𝑐𝑜𝑅𝐸 :‬‬
‫‪ - 𝐻𝑃 ≤ 𝐿∞ .2‬ממשפט הרדוקציה נובע ש‪.𝐿∞ ∉ 𝑅𝐸 :‬‬

‫הוכחה ‪ -‬חלק (‪ :)1‬נוכיח זאת ע"י רדוקציה ∞𝐿 ≤ 𝑃𝐻‪.‬‬
‫● מקבלת (את 𝑦)‪.‬‬
‫נכונות הפונקציה דומה כמו שעשינו בתרגילים קודמים‪.‬‬
‫הוכחה ‪ -‬חלק (‪ :)2‬נוכיח זאת ע"י רדוקציה ∞𝐿 ≤ 𝑃𝐻‪.‬‬

‫(כלומר‪ ,‬נרצה להוכיח שאם 𝑀 לא עוצרת על 𝑥 אז נרצה שהשפה תהיה אינסופית)‪.‬‬
‫פונקצית הרדוקציה היא‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀'𝑥 > :‬‬
‫⋆‬
‫כאשר 𝑥'𝑀 על קלט ‪ 𝑦 ∈ Σ‬אז‪:‬‬
‫‪ .1‬מריצה את 𝑀 על 𝑥 למשך |𝑦| צעדים‪.‬‬
‫‪ .2‬אם 𝑀 לא עצרה על 𝑥 בשלב ‪ - 1‬קבל‪.‬‬
‫‪ .3‬אם 𝑀 עצרה על 𝑥 ‪ -‬דחה‪.‬‬
‫נכונות הפונקציה דומה כמו שעשינו בתרגילים קודמים‪.‬‬
‫תקפות הרדוקציה‪:‬‬
‫‪ .1‬אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 (🠈) < 𝑀,‬לא עוצרת על 𝑥 )🠈( 𝑀 לא עצרה גם בתוך |𝑦| צעדים עבור כל 𝑦 )🠈(‬
‫|‬ ‫|‬
‫𝑥'𝑀 תקבל כל 𝑦 )🠈( * ‪.< 𝑀'𝑥 >∈ 𝐿∞ (🠈) 𝐿(𝑀'𝑥) = ∞ (🠈) 𝐿(𝑀'𝑥) = Σ‬‬
‫‪ .2‬אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 (🠈) < 𝑀,‬עוצרת על 𝑥 לאחר מספר סופי 𝑘 של צעדי חישוב )🠈( עבור כל 𝑦‬
‫המקיים 𝑘 > |𝑦| אז 𝑥'𝑀 תדחה את 𝑦 )🠈( '𝑀 תקבל רק מילים 𝑦 כך ש‪(🠈) |𝑦| < 𝑘 :‬‬
‫|‬
‫∞ < )𝑥'𝑀(𝐿 )🠈( ∞𝐿 ∉> 𝑥'𝑀 <‪.‬‬ ‫|‬
‫∎‬
‫הערה ‪ -‬חלק (‪:)2‬‬
‫● }𝑥 𝑛𝑜 𝑝𝑜𝑡𝑠 𝑡'𝑛𝑠𝑒𝑜𝑑 𝑀 | > 𝑥 ‪.𝐻𝑃 = {< 𝑀,‬‬
‫● יש לנו אינסוף מילים‪ ,‬כל מילה בפני עצמה בכמות סופית של תווים (כל מילה היא באורך סופי)‪.‬‬
‫● כל עוד אנחנו במילים קטנות 𝑦 אז השפה עדיין לא אינסופית‪ ,‬אבל כשאנחנו מגיעים למילים ארוכות‬
‫מאוד אז אנחנו נותנים ל‪ 𝑀-‬כמה צעדים שהיא צריכה‪.‬‬
‫● לכן‪ ,‬אם 𝑀 לא עצרה‪ ,‬אז היא צריכה הרבה יותר ממספר הצעדים שהיא קיבלה בזכות |𝑦|שעליה היא‬
‫מסתמכת‪ ,‬כלומר זה אינסופי ולכן נעצור ונקבל‪.‬‬
‫● אם 𝑀 עצרה אז הגענו "לחסם" מסוים לאחר 𝑡 צעדים ולכן לכל 𝑦 המקיים 𝑡 ≥ |𝑦| אז > 𝑥'𝑀 <∉ 𝑦‬
‫כלומר‪ ,‬זה לא אינסופי ונדחה‪.‬‬
‫המשך תרגיל ‪2‬‬

‫נחזור לשפה }* ‪ .𝐿2 = {< 𝑀 > | 𝑀 𝑠𝑡𝑜𝑝𝑠 𝑓𝑜𝑟 𝑒𝑣𝑒𝑟𝑦 𝑖𝑛𝑝𝑢𝑡 𝑥 ∈ Σ‬ראינו ש‪.𝐿2 ∉ 𝑅 :‬‬
‫מה לגבי שייכות ל‪ :?𝑅𝐸-‬אפשר לשנות מעט את הרדוקציה שראינו ∞𝐿 ≤ 𝑃𝐻 כדי להתאים לשפה ‪.𝐿2‬‬
‫טענה‪.𝐿2 ∉ 𝑅𝐸 :‬‬
‫הוכחה‪ :‬נראה כי ‪ .𝐻𝑃 ≤ 𝐿2‬פונקצית הרדוקציה היא‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀'𝑥 > :‬‬
‫כאשר 𝑥'𝑀 על קלט 𝑤 אז‪:‬‬
‫‪ .1‬מריצה את 𝑀 על 𝑥 למשך |𝑤| צעדים‪.‬‬
‫‪ .2‬אם 𝑀 לא עצרה על 𝑥 בשלב ‪ - 1‬קבל‪.‬‬

‫‪ .3‬אם 𝑀 עצרה על 𝑥 ‪ -‬לולאה אינסופית‪.‬‬
‫נכונות הפונקציה של מלאה וניתנת לחישוב נעשה דומה כמו שעשינו בתרגילים קודמים‪.‬‬
‫‪ .1‬אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 (🠈) < 𝑀,‬לא עוצרת על 𝑥 )🠈( 𝑥'𝑀 מקבל את 𝑤)🠈( 𝑥'𝑀 עוצרת לכל 𝑤‬
‫)🠈( ‪.𝑀'𝑥 ∈ 𝐿2‬‬
‫‪ .2‬אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 (🠈) < 𝑀,‬עוצרת על 𝑥 לאחר מספר סופי 𝑡 של צעדי חישוב )🠈( 𝑥'𝑀 תיכנס‬
‫ללולאה אינסופית עבור כל 𝑤 כך ש‪ 𝑀'𝑥 (🠈)|𝑤| ≥ 𝑡 :‬לא עוצרת לכל 𝑤 )🠈( ‪.𝑀'𝑥 ∉ 𝐿2‬‬
‫∎‬
‫הסבר להמשך תרגיל ‪ :2‬נשים לב ש‪.𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 𝑑𝑜𝑒𝑠𝑛'𝑡 𝑠𝑡𝑜𝑝 𝑜𝑛 𝑥} :‬‬
‫נזכור שלא באמת מעניין אותנו התוכן של 𝑤‪ ,‬אלא רק צריך להגיב בהתאם לעניין השייכות של 𝑃𝐻‪:‬‬
‫‪ .1‬אם 𝑀 לא עצרה על 𝑥‪ ,‬אז זה מעולה‪ ,‬כי זה עונה על דרישת השפה 𝑃𝐻‪ ,‬כלומר 𝑃𝐻 ∈> 𝑥 ‪< 𝑀,‬‬
‫ולכן גם המכונה 𝑥'𝑀 של ‪ 𝐿2‬חייבת להגיב בהתאם למקרה של ‪ < 𝑀'𝑥 >∈ 𝐿2‬ולכן‪ ,‬תקבל את 𝑤‪.‬‬
‫‪ .2‬אם 𝑀 עצרה על 𝑥‪ ,‬אז זה לא עונה על דרישת השפה 𝑃𝐻‪ ,‬כלומר 𝑃𝐻 ∉> 𝑥 ‪.< 𝑀,‬‬
‫מתי מילה לא שייכת לשפה ‪ - ?𝐿2‬כאשר 𝑀 לא עוצר עבור כל * ‪.𝑥 ∈ Σ‬‬
‫לכן המכונה 𝑥'𝑀 של ‪ 𝐿2‬חייבת לא לעצור לעולם על כל 𝑥‪.‬‬
‫נתונה השפה }* ‪.𝐿Σ* = {< 𝑀 > | 𝐿(𝑀) = Σ‬‬
‫טענה‪.𝐿Σ* ∈ 𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸 :‬‬

‫קצת סדר בראש‪ :‬השפה 𝑅 ∈* ‪ Σ‬כי ניתן להכריע אותה מיידית ‪ -‬נעבור על כל הסרט של המכונה‪ ,‬אם כל‬
‫התווים מוכרים לנו ב‪ Σ-‬אז נקבל את המילה בסוף הסרט‪ ,‬אם לא אז נדחה ישר‪ .‬כאן המקרה הוא שונה ויכול‬
‫לבלבל‪ ,‬השפה *‪ 𝐿Σ‬היא שפת כל המכונות המקבלות את השפה * ‪ .Σ‬לכן‪ ,‬שפה *‪ 𝐿Σ‬היא הרבה יותר "קשה" מ‪-‬‬
‫𝑅 ולכן היא מחוץ ל"מגרש המשחקים" שהתעסקנו בו עד עכשיו‪ ,‬כלומר היא 𝐸𝑅𝑜𝑐 ∪ 𝐸𝑅 ∈ *‪.𝐿Σ‬‬
‫אבחנה‪ :‬שתי פונקציות הרדוקציה שראינו עבור ∞𝐿 ≤ 𝑃𝐻 ‪ 𝐻𝑃 ≤ 𝐿∞ ,‬מתאימות גם עבור השפה *‪.𝐿Σ‬‬
‫הוכחה חלק ‪ :1‬אנו יודעים כי 𝐸𝑅𝑜𝑐 ∉ 𝑃𝐻‪ ,‬נוכיח ברדוקציה ⋆ 𝐿 ≤ 𝑃𝐻 וכך נראה כי 𝐸𝑅𝑜𝑐 ∉ ⋆ 𝐿‪.‬‬
‫‪Σ‬‬ ‫‪Σ‬‬
‫פונקציית הרדוקציה מוגדרת כך‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀𝑥 > :‬‬
‫𝑥𝑀 על קלט 𝑤 אז‪:‬‬
‫● מריצה את 𝑀 על 𝑥‪.‬‬
‫● מקבל את 𝑤‪.‬‬
‫נוכיח את נכונות הגדרת הפונקציה‪.‬‬

‫‪ .1‬הפונקציה מלאה‪ :‬לכל קידוד של מכונה וקלט נתונים‪ ,‬ניתן לבנות את המכונה 𝑥𝑀‪.‬‬
‫‪ .2‬הפונקציה ניתנת לחישוב‪ :‬כי קיים קידוד למחרוזת לכל מ"ט‪.‬‬
‫‪ .3‬הפונקציה פתירה‪:‬‬
‫‪ .a‬אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצר על 𝑥 ← לפי הבנייה‪ 𝑀𝑥 ,‬מקבל את 𝑤 ← ⋆ 𝐿 ∈ 𝑥𝑀‪.‬‬
‫‪Σ‬‬
‫‪ .b‬אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצר על 𝑥 ← לפי הבנייה‪ 𝑀𝑥 ,‬רץ לאינסוף ← ⋆ 𝐿 ∉ 𝑥𝑀‪.‬‬
‫‪Σ‬‬
‫הוכחה חלק ‪ :2‬אנו יודעים כי 𝐸𝑅 ∉ 𝑃𝐻‪ .‬נוכיח ברדוקציה ⋆ 𝐿 ≤ 𝑃𝐻 וכך נקבל 𝐸𝑅 ∉ ⋆ 𝐿‪.‬‬
‫‪Σ‬‬ ‫‪Σ‬‬
‫פונקציית הרדוקציה מוגדרת כך‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀𝑥 > :‬‬
‫𝑥𝑀 על קלט 𝑤 תבצע‪:‬‬
‫● 𝑀 תפעל על 𝑥 למשך |𝑤| צעדים‪.‬‬
‫○ אם 𝑀 לא עצרה על 𝑥 ‪ -‬קבל‪.‬‬
‫○ אם 𝑀 עצרה על 𝑥 ‪ -‬רוץ לאינסוף‪.‬‬
‫נוכיח את נכונות פונקצית הרדוקציה‪.‬‬
‫‪ .1‬הפונקציה מלאה‪ :‬לכל קידוד של מכונה וקלט נתונים‪ ,‬ניתן לבנות את המכונה 𝑥𝑀‪.‬‬
‫‪ .2‬הפונקציה ניתנת לחישוב‪ :‬קיים קידוד כמחרוזת לכל מ"ט‪.‬‬
‫‪ .a‬אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עצרה על 𝑥 ← 𝑥𝑀 מקבל כל קלט באורך |𝑤|← ⋆ 𝐿 ∈ 𝑥𝑀‪.‬‬
‫‪Σ‬‬
‫‪ .b‬אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬עצרה על 𝑥 לאחר 𝑡 צעדים ← 𝑥𝑀 רץ לאינסוף החל מהצעד ה‪𝑡-‬‬
‫⋆‬
‫← מילה לא התקבלה כל מילה חייבת להיות ב‪.𝑀𝑥 ∉ 𝐿 ⋆ ←Σ -‬‬
‫‪Σ‬‬
‫נתונה השפה })‪.𝐿𝑒𝑞 = {< 𝑀1 , 𝑀2 > | 𝐿(𝑀1) = 𝐿(𝑀2‬‬
‫טענה‪.𝐿𝑒𝑞 ∈ 𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸 :‬‬

‫אינטואיציה‪ :‬אם נמצא מילה 𝑥 כלשהי ש‪ 𝑀1-‬מקבלת ו‪ 𝑀2-‬דוחה אז )‪ ,𝐿(𝑀1) ≠ 𝐿(𝑀2‬כלומר זיהינו מקרה‬
‫של קלט שהוא לא בשפה‪ ,‬אז אפשר לחשוב תחילה כי 𝐸𝑅𝑜𝑐 ∈ 𝑞𝑒𝐿‪ .‬מה יכול להיות בעייתי? ‪ -‬לא מובטח לנו ש‬
‫‪ 𝑀2‬תדחה את המילה ‪ -‬יכול להיות שתרוץ לאינסוף על 𝑥 ולא נוכל לזהות מקרים‪ .𝐿(𝑀1) = 𝐿(𝑀2) :‬לכן‪ ,‬יש‬
‫לנו כאן בעיה "קשה" יותר משפות ב‪ 𝑐𝑜𝑅𝐸-‬ולכן 𝐸𝑅𝑜𝑐 ∪ 𝐸𝑅 ∈ 𝑞𝑒𝐿‪.‬‬

‫מבוא להוכחה‪ :‬אפשר להוכיח ע"י שתי רדוקציות‪ ,‬כמו קודם‪ .‬אבל נעשה קיצור דרך‪:‬‬
‫אפשר להוכיח ע"י רדוקציה משפה שאנחנו כבר יודעים עליה שהיא ב‪.𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸-‬‬
‫תזכורת ‪ 𝑀𝑆𝑇𝐴𝑀 -‬היא מכונה המקבלת כל קלט‪.‬‬
‫}* ‪𝐿Σ* = {< 𝑀 > | 𝐿(𝑀) = Σ‬‬

‫})‪𝐿𝑒𝑞 = {< 𝑀1 , 𝑀2 > | 𝐿(𝑀1) = 𝐿(𝑀2‬‬
‫הוכחה‪ :‬נוכיח בעזרת הרדוקציה 𝑞𝑒𝐿 ≤ *‪ 𝐿Σ‬שמתקיים 𝐸𝑅𝑜𝑐 ∪ 𝐸𝑅 ∈ 𝑞𝑒𝐿‪.‬‬

‫פונקציית הרדוקציה‪.𝑓(< 𝑀 >) = (< 𝑀, 𝑀𝑆𝑇𝐴𝑀 >) :‬‬
‫הערה‪ :‬למה אפשר להשתמש ב‪ ?𝑀𝑆𝑇𝐴𝑀-‬כי *‪ < 𝑀𝑆𝑇𝐴𝑀 >∈ 𝐿Σ‬כי באמת מתקיים * ‪ 𝐿(𝑀𝑆𝑇𝐴𝑀) = Σ‬בגלל שהיא מקבלת כל קלט‪ ,‬כלומר כל‬
‫מילה שזה בדיוק ההגדרה ל‪.Σ *-‬‬
‫נוכיח את נכונות פונקציית הרדוקציה‪:‬‬
‫‪ .1‬הפונקציה מלאה‪ :‬לכל מכונה 𝑀 אפשר להצמיד מכונה נוספת 𝑀𝐴𝑇𝑆𝑀‪.‬‬
‫‪ .2‬הפונקציה ניתנת לחישוב‪ :‬כי אפשר ליצור קידוד כמחרוזת לכל מ"ט‪.‬‬
‫⋆‬
‫‪ .a‬אם *‪ ← < 𝑀 >∈ 𝐿Σ‬לפי הגדרת השפה ‪← 𝐿(𝑀) = 𝐿(𝑀𝑆𝑇𝐴𝑀) ← 𝐿(𝑀) = Σ‬‬
‫𝑞𝑒𝐿 ∈> 𝑀𝐴𝑇𝑆𝑀 ‪.< 𝑀,‬‬
‫⋆‬
‫‪ .b‬אם *‪ ← < 𝑀 >∉ 𝐿Σ‬לפי הגדרת השפה ‪← 𝐿(𝑀) ≠ 𝐿(𝑀𝑆𝑇𝐴𝑀) ← 𝐿(𝑀) ≠ Σ‬‬
‫𝑞𝑒𝐿 ∉> 𝑀𝐴𝑇𝑆𝑀 ‪.< 𝑀,‬‬
‫תרגול ‪ - 3‬שאלה ‪1‬‬

‫עבור השפה הבאה }‪ 𝐿ε = {< 𝑀 > | 𝑀 𝑎𝑐𝑐𝑒𝑝𝑡𝑠 ε‬הוכיחו כי השפה איננה ב‪.𝑅-‬‬
‫● אינטואיציה‪ :‬ייתכן שעבור מ"ט 𝑀 לא תעצור לעולם על קלט ‪ ε‬ולכן 𝐸𝑅 ∈ 𝐿‪.‬‬
‫● תיאור הרדוקציה‪ :‬נראה רדוקציה ‪ .𝐻𝑃 ≤ 𝐿ε‬פונקציית הרדוקציה‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀' > :‬‬
‫כך ש‪ 𝑀'-‬על כל קלט 𝑤‪:‬‬
‫‪ .1‬מסמלצת את ריצת 𝑀 על 𝑥‪.‬‬
‫‪ .2‬אם 𝑀 עצרה ‪ 𝑀' -‬תקבל‪.‬‬
‫● נכונות פונקציית הרדוקציה‪:‬‬
‫○ הפונקציה מלאה‪ :‬כי '𝑀 מוגדרת לכל 𝑀 ו‪.𝑥-‬‬
‫○ הפונקציה ניתנת לחישוב‪ :‬לכל מכונה קיים קידוד למחרוזת‪.‬‬
‫○ הפונקציה תקפה‪:‬‬
‫⋆‬
‫■ אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עצר על 𝑥 ← '𝑀 מקבל את 𝑤 ← ‪←𝐿(𝑀') = Σ‬‬
‫)'𝑀(𝐿 ∈ ‪.𝑀' ∈ 𝐿ε ← ε‬‬
‫■ אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עצר על 𝑥 ← '𝑀 רץ לאינסוף ← ∅ = )'𝑀(𝐿 ←‬

‫)'𝑀(𝐿 ∉ ‪.𝑀' ∉ 𝐿ε← ε‬‬
‫● סיכום‪ :‬הראינו כי 𝑃𝐻 ניתנת לרדוקציה ל‪ 𝐿ε-‬ידוע לנו כי 𝑅 ∉ 𝑃𝐻 ולכן 𝑅 ∉ ‪ 𝐿ε‬כנדרש‪.‬‬

‫נתונה השפה }𝑡‪.𝐿 = {< 𝑀 > : 𝑀 𝑜𝑛 ε 𝑖𝑡𝑒𝑟𝑎𝑡𝑒 3 𝑐𝑜𝑛𝑠𝑒𝑐𝑢𝑡𝑖𝑣𝑒 𝑠𝑡𝑒𝑝𝑠 𝑡𝑜 𝑡ℎ𝑒 𝑟𝑖𝑔ℎ‬‬
‫כלומר‪ < 𝑀 >∈ 𝐿 ,‬אם 𝑀 בריצתה על ‪ ε‬מבצעת ‪ 3‬צעדים רצופים ימינה‪.‬‬
‫סעיף א'‪ :‬האם השפה ב‪ - ?𝑅𝐸-‬הוכיחו‪.‬‬
‫סעיף ב'‪ :‬האם השפה ב‪ - ?𝑅-‬הוכיחו‪.‬‬
‫פתרון סעיף א'‪ :‬השפה אכן ב‪ .𝑅𝐸-‬לפי הגדרת 𝐸𝑅 קיים מכונה 𝑀 המקבלת את השפה 𝐿‪ .‬אכן אפשר לבנות‬
‫מכונה 𝑀 שכזאת‪ ,‬נבנה מונה (‪ )counter‬שסופר את מספר הצעדים רצוף ימינה‪ ,‬אם הגענו ל‪ 3-‬צעדים אז‬
‫נקבל‪ .‬אם זזנו שמאלה או נשאר במקום אז נאפס את המונה‪ .‬כדי לתת תשובה פורמלית לסעיף זה‪ ,‬צריך‬
‫להוכיח ע"י בניית מכונה‪ .‬לא נוכיח כאן כי זה הרבה עבודה אבל ניתן רעיון כללי‪:‬‬
‫‪ .1‬אם בתחילת האלגוריתם‪ ,‬הראש קרא מתא ‪ 1‬את ‾𝑏 אז אכן מדובר במילה הריקה‪.‬‬
‫‪ .2‬נשתמש בסרט נוסף שיכיל את המונה (‪ )counter‬ובו נעדכן בהתאם כמה צעדים רצופים ימינה עשינו‪.‬‬
‫‪ .3‬נזוז ימינה 𝑅‪ ,‬אם התא הבא גם ‾𝑏 (הוא כזה כי המילה ריקה) אז נעשה ‪ 𝑐𝑜𝑢𝑛𝑡𝑒𝑟 ++‬בסרט השני‪.‬‬
‫‪ .4‬אם נזוז שמאלה 𝐿 או נשאר במקום 𝑆 אז נאפס את המונה ‪ 𝑐𝑜𝑢𝑛𝑡𝑒𝑟 = 0‬בסרט השני‪.‬‬
‫‪ .5‬אם ‪ 𝑐𝑜𝑢𝑛𝑡𝑒𝑟 == 3‬אז נעבור למצב מקבל 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪.‬‬
‫פתרון סעיף ב'‪:‬‬
‫‪ .1‬אינטואיציה‪ :‬קל לראות ש‪ ,𝐿 ∈ 𝑅𝐸 :‬כאשר נסמלץ ריצה של 𝑀 על ‪ ,ε‬נוכל לזהות שהיא מבצעת ‪3‬‬
‫צעדים רצופים ימינה‪ .‬אבל אם יש לדוגמה מ"ט כלשהי '𝑀 כלשהי שעבור ‪ 𝑥 = ε‬רצה לאינסוף ועבור‬
‫‪ 𝑥 ≠ ε‬עוצרת ומקבלת‪ ,‬אז לא נוכל להכריע במקרה זה‪ .‬כלומר אנחנו לא נוכל להגיד לא כי המכונה‬
‫תקועה בלולאה אינסופית ולכן לא נוכל לזהות מה הפלט הנכון‪.‬‬
‫לכן‪ ,‬נוכיח שלא שייכת ל‪ 𝑅-‬באמצעות השפה ‪ 𝐿ε‬והוכחנו כבר עליה כי 𝑅 ∉ ‪.𝐿ε‬‬
‫נוכיח שמתקיים‪ .𝐿ε ≤ 𝐿 :‬כלומר נוכיח כי אם 𝑅 ∉ ‪ 𝐿ε‬אז מהרדוקציה נקבל גם כי 𝑅 ∉ 𝐿‪.‬‬
‫‪ .2‬תיאור הרדוקציה‪ :‬נראה רדוקציה‪.𝐿ε ≤ 𝐿 :‬‬
‫פונקצית הרדוקציה תהיה‪.𝑓(< 𝑀 >) =< 𝑀' > :‬‬
‫כאשר '𝑀 על קלט 𝑥‪:‬‬
‫● מסמלצת את 𝑀 על ‪ ,ε‬כאשר בכל צעד‪:‬‬
‫○ אם '𝑀 עשתה צעד 𝑅‪ ,‬המכונה 𝑀 מבצעת צעד 𝑆 שלא משנה כלום‪.‬‬
‫○ אם 𝑀 קיבלה‪ ,‬אז '𝑀 הולכת שלושה צעדים ימינה ומקבלת‪.‬‬
‫○ אם 𝑀 דחתה‪ ,‬אז '𝑀 דוחה‪.‬‬
‫הערה‪ :‬אנחנו נאפשר ל‪ 𝑀'-‬לזוז ‪ 3‬צעדים ימינה רק כאשר 𝑀 תקבל את ‪ .ε‬בכל צעד של 𝑀‪ ,‬אם נזוז ימינה‪ ,‬אז '𝑀 תישאר במקום 𝑆 ולאחר מכן תזוז‬
‫ימינה 𝑅 (כלומר ניצור איזשהו מצב שיגיד לי "תשאר צעד במקום ואז תזוז ימינה")‪ .‬הסתכלות אחרת היא להגיד ש'𝑀 יכולה לעשות 𝑅𝑅𝑅 רק כאשר‬
‫𝑀 תקבל את ‪ ,ε‬בשביל למנוע מצב ש'𝑀 תעשה 𝑅𝑅𝑅 כשלא באמת צריך‪ ,‬אז נגיד שלכל צעד ימינה‪ ,‬נעמוד במקום ואז נזוז ימינה‪ ,‬ואז יהיה לנו רצף‬
‫צעדים של 𝑅𝑆𝑅𝑆𝑅𝑆𝑅𝑆 וככה אנחנו מתחייבים שלא יהיה לנו לפחות ‪ 3‬ימינה רצופים כנדרש‪.‬‬
‫‪ .3‬נכונות פונקציית הרדוקציה‪:‬‬
‫‪ .a‬הפונקציה מלאה‪ :‬כי '𝑀 מוגדרת לכל 𝑀‪.‬‬
‫‪ .b‬הפונקציה ניתנת לחישוב‪ :‬כי קיים קידוד לכל מ"ט‪.‬‬
‫‪ .c‬הפונקציה פתירה‪:‬‬
‫‪ 𝑀 ← < 𝑀 >∈ 𝐿ε‬תעצור ותקבל את ‪ 𝑀' ← ε‬בריצתה על ‪ ε‬תלך שלושה צעדים‬ ‫‪.i‬‬
‫רצופים ימינה ← 𝐿 ∈> '𝑀 <‪.‬‬
‫‪ 𝑀 ← < 𝑀 >∉ 𝐿ε‬תעצור ותדחה או לא תעצור ← '𝑀 בריצתה על ‪ ε‬לא תלך‬ ‫‪.ii‬‬
‫שלושה צעדים רצופים ימינה ואפילו אינסוף (משום שקטענו עם 𝑆) ← 𝐿 ∉> '𝑀 <‪.‬‬
‫‪ .4‬סיכום‪ :‬הראינו כי ‪ 𝐿ε‬ניתנת לרדוקציה ל‪ 𝐿-‬ידוע לנו כי 𝑅 ∉ ‪ 𝐿ε‬ולכן 𝑅 ∉ 𝐿 כנדרש‪.‬‬

‫נתונה השפה הבאה‪.𝐿 = {< 𝑀 > : 𝑀(001) = 001} :‬‬
‫סעיף א'‪ :‬האם השפה הנתונה ב‪?𝑅𝐸-‬‬
‫סעיף ב'‪ :‬האם השפה הנתונה ב‪?𝑅-‬‬
‫פתרון סעיף א'‪ :‬אם 𝑀 לא עוצרת על ‪ 001‬אז בפרט המילה הזאת לא בשפה והמכונה לא קולטת את המילה‬
‫הזאת‪ .‬אבל לפי 𝐸𝑅 אם היא לא בשפה אז מותר לנו שהמכונה לא תעצור וזה בסדר… כלומר השפה הנתונה כן‬
‫ב‪ .𝑅𝐸-‬כדי להוכיח ששפה שייכת למחלקה‪ ,‬צריך לבנות מ"ט שמקבלת את השפה‪( .‬הוכחה בבית)‪.‬‬
‫‪ .1‬אינטואיציה‪ :‬קל לראות ש‪( 𝐿 ∈ 𝑅𝐸 :‬הראינו בסעיף א')‪ ,‬אבל ייתכן שקיים מכונה 𝑀 כלשהי כך‬
‫שבהינתן הקלט ‪ ,001‬היא לא תדע איך לעבוד איתה ולכן תיכנס ללולאה אינסופית ‪ -‬כלומר היא לא‬
‫תוכל להכריע את דרישת השפה 𝐿‪ .‬לכן‪ ,‬השפה 𝑅 ∉ 𝐿‪ .‬נרצה להוכיח ש𝑅 ∉ 𝐿 ולכן נשתמש‬
‫ברדוקציה‪ .‬אנחנו צריכים לחשוב על שפה אחרת שהוכחנו עליה כבר שהיא לא ב‪ 𝑅-‬אבל כן ב‪.𝑅𝐸-‬‬
‫‪ .2‬תיאור הרדוקציה‪ :‬נראה רדוקציה 𝐿 ≤ 𝑃𝐻‪.‬‬
‫פונקציית הרדוקציה היא > 𝑥𝑀 <= )> 𝑥 ‪.𝑓(< 𝑀,‬‬
‫כאשר 𝑥𝑀 על קלט 𝑤‪:‬‬
‫● תסמלץ את 𝑀 על 𝑥‪.‬‬
‫● אז קבל (מחזירה את 𝑤)‪.‬‬
‫הערה‪ :‬אם 𝑀 תעצור על 𝑥‪ ,‬אז נחזיר את 𝑤‪ .‬ה‪ 𝑤-‬יכול להיות כל מיני מחרוזות‪ 𝑤 = 011 ,‬או ‪ 𝑤 = 110‬או ‪ 𝑤 = 001‬וכו'‪ ...‬לכן‪ ,‬אם 𝑀 לא עצרה‬
‫על 𝑥‪ ,‬אז לא נחזיר את 𝑤 ואז > 𝑀 < לא תהיה בשפה וזה בסדר‪ .‬ואם 𝑀 כן עצרה על 𝑥 אז נקבל את > 𝑀 < לשפה‪.‬‬
‫‪ .a‬הפונקציה מלאה‪ :‬לכל 𝑀 ו‪ ,𝑥-‬ניתן ליצור 𝑥𝑀‪.‬‬
‫‪ .b‬הפונקציה ניתנת לחישוב‪ :‬לכל מכונה קיים קידוד‪.‬‬
‫אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 ← 𝑥𝑀 גם עוצרת ומחזירה לכל 𝑤 ←‬ ‫‪.i‬‬

‫בפרט אם ‪ 𝑤 = 001‬כך ש‪.< 𝑀𝑥 >∈ 𝐿 ← 𝑀𝑥(001) = 001 :‬‬
‫אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת על 𝑥 ← 𝑥𝑀 רצה לאינסוף‪ ,‬כלומר לא עוצרת‬ ‫‪.ii‬‬
‫לכל 𝑤 ← בפרט )‪ 𝑀𝑥(001‬לא מוגדרת← 𝐿 ∉> 𝑥𝑀 <‪.‬‬
‫‪ .4‬סיכום‪ :‬הראינו כי 𝑃𝐻 ניתנת לרדוקציה ל‪ 𝐿-‬ידוע לנו כי 𝑅 ∉ 𝑃𝐻 ולכן 𝑅 ∉ 𝐿 כנדרש‪.‬‬

‫נתונה השפה }‪.𝐿=3 = {< 𝑀 >: |𝐿(𝑀)| = 3‬‬
‫סעיף א'‪ :‬האם השפה ב‪?𝑅-‬‬
‫סעיף ב'‪ :‬האם השפה ב‪?𝑅𝐸-‬‬
‫פתרון א'‪ :‬אינטואיציה‪ :‬לא‪ ,‬כי לפי משפט רייס (התרגיל הוצג אחרי שנלמד הנושא הזה) אם תכונת השפה‬
‫קשורה לתנאי המכונה אז היא לא ב‪.𝑅-‬‬
‫פתרון ב'‪:‬‬
‫‪ .1‬אינטואיציה‪ :‬נראה ש‪ 𝐻𝑃 ≤ 𝐿=3 :‬וממנה נסיק כי 𝐸𝑅 ∉ ‪ .𝐿=3‬כרגיל‪ ,‬אנו מתחילים עם קלט‬
‫> 𝑥 ‪ < 𝑀,‬ורוצים לבנות ממנו מכונה 𝑥𝑀 כך ש‪ < 𝑀𝑥 >∈ 𝐿=3 :‬רק אם 𝑀 לא עוצרת על 𝑥‪ .‬הרעיון‬
‫הוא לקבל מייד ‪ 3‬מילים כלשהן‪ ,‬ואם 𝑀 עוצרת על 𝑥 אז לקבל את כל שאר המילים האפשריות‪( .‬אנחנו‬
‫רוצים "להיכשל")‪.‬‬
‫‪ .2‬תיאור הרדוקציה‪ :‬נראה ברדוקציה ‪.𝐻𝑃 ≤ 𝐿=3‬‬
‫פונקציית הרדוקציה‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀𝑥 > :‬‬
‫⋆‬
‫כאשר 𝑥𝑀 על ‪ 𝑤 ∈ Σ‬פועלת כך‪:‬‬
‫‪ .1‬אם }‪ 𝑤 ∈ {ε, 0, 1‬אז 𝑥𝑀 מקבלת‪.‬‬
‫‪ 𝑀𝑥 .2‬תסמלץ את 𝑀 על 𝑥‪.‬‬
‫‪ .3‬אם 𝑀 עצרה‪ 𝑀𝑥 ,‬מקבלת‪.‬‬
‫הסבר‪ :‬אם 𝑀 לא עוצרת על 𝑥 אז ‾‬
‫𝑃𝐻 ∈> 𝑥 ‪ < 𝑀,‬ולפי ההגדרה של רדוקציה‪ ,‬אנחנו צריכים לחקות את השפה השניה‪ ,‬ולכן אנחנו חייבים שגם‬
‫‪ . < 𝑀𝑥 >∈ 𝐿=3‬איך נעשה את זה? אם 𝑀 לא עוצר על ה‪ 𝑥-‬הזה‪ ,‬אז אנחנו צריכים ‪ 3‬מילים שיתקבלו בשפת המכונה 𝑥𝑀‪ ,‬בה"כ נבחר את המילים‬
‫⋆‬
‫}‪ .{ε, 0, 1‬איך זה עובד בפועל? 𝑥𝑀 תעבור ותפעל על כל ‪ ,𝑤 ∈ Σ‬ואם 𝑀 לא עוצר על 𝑥 אז הוא בחיים לא יעבור לשלב (‪ ,)3‬וזה נכון לכל 𝑤 חוץ מ‪-‬‬
‫}‪ 𝑤 ∈ {ε, 0, 1‬שכן יכולות להתקבל כבר בשלב (‪ .)1‬ככה פתרנו שאם 𝑀 לא עוצר על 𝑥 אז 𝑥𝑀 מקבל רק ‪ 3‬מילים בלבד כנדרש‪.‬‬
‫מצד שני‪ ,‬אם 𝑀 עוצרת על 𝑥‪ ,‬אז ‾‬
‫𝑃𝐻 ∉> 𝑥 ‪ < 𝑀,‬זה אומר שאנחנו חייבים שגם ‪ . < 𝑀𝑥 >∉ 𝐿=3‬איך נעשה את זה? ‪ -‬אם 𝑀 עוצרת על 𝑥 אז לכל‬
‫⋆‬ ‫⋆‬
‫‪ 𝑤 ∈ Σ‬תתקבל ולכן ‪ 𝐿(𝑀𝑥) = Σ‬ובהכרח השפה לא בגודל ‪ 3‬כנדרש‪.‬‬

‫‪ .a‬הפונקציה מלאה‪ :‬לכל 𝑀 ו‪ 𝑥-‬קיים 𝑥𝑀‪.‬‬
‫‪ .b‬הפונקציה ניתנת לחישוב‪ :‬כל מ"ט ניתן לקידוד‪.‬‬
‫⋆‬
‫אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת על 𝑥 ← לכל ‪ 𝑀𝑥 ,𝑤 ∈ Σ‬מקבל רק את‬ ‫‪.i‬‬
‫}‪ 𝐿(𝑀𝑥) = {ε, 0, 1} ← 𝑤 ∈ {ε, 0, 1‬ואכן בגודל ‪.< 𝑀𝑥 >∈ 𝐿=3 ←3‬‬
‫⋆‬
‫אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 ← 𝑥𝑀 מקבל כל ‪← 𝑤 ∈ Σ‬‬ ‫‪.ii‬‬
‫⋆‬
‫‪ 𝐿(𝑀𝑥) = Σ‬ובהכרח לא בגודל ‪.< 𝑀𝑥 >∉ 𝐿=3 ← 3‬‬
‫‪ .4‬סיכום‪ :‬הראינו כי 𝑃𝐻 ניתנת לרדוקציה ל‪ 𝐿=3-‬ידוע לנו כי 𝐸𝑅 ∉ 𝑃𝐻 ולכן 𝐸𝑅 ∉ ‪ 𝐿=3‬כנדרש‪.‬‬
‫תרגול ‪ - 3‬שאלה ‪( 5‬שאלת מבחן)‬

‫|‬
‫נתונה השפה‪ .𝐿 = {< 𝑀1, 𝑀2 > : 𝐿(𝑀1) ∩ 𝐿(𝑀2) = ∞} :‬האם 𝑅 ∈ 𝐿? האם 𝐸𝑅 ∈ 𝐿 ‪ -‬הוכיחו‪.‬‬ ‫|‬
‫הוכחה‪ :‬נוכיח כי 𝑅 ∉ 𝐿 וגם 𝐸𝑅 ∉ 𝐿‪.‬‬
‫● תיאור הרדוקציה‪ :‬נראה רדוקציה 𝐿 ≤ 𝑃𝐻‪.‬‬
‫○ פונקצית הרדוקציה‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀𝑥, 𝑀𝑆𝑇𝐴𝑀 > :‬‬
‫○ עבור 𝑥𝑀 על קלט 𝑤 בצע‪:‬‬
‫■ סמלץ את 𝑀 על 𝑥 למשך |𝑤| צעדים‪.‬‬
‫■ אם 𝑀 עצרה ‪ -‬דחה‪.‬‬
‫■ אחרת לאחר ה‪ |𝑤|-‬צעדים מקבלת‪.‬‬
‫○ עבור 𝑀𝐴𝑇𝑆𝑀 מקבלת כל קלט‪.‬‬
‫● נכונות פונקצית הרדוקציה‪:‬‬
‫○ הפונקציה מלאה‪ :‬לכל קלט (אם > 𝑥 ‪ < 𝑀,‬קידוד חוקי) קיים פלט‪.‬‬
‫○ הפונקציה ניתנת לחישוב‪ :‬מדובר בפעולת קומפילציה פשוטה‪.‬‬
‫○ הפונקציה תקפה‪:‬‬
‫⋆‬
‫■ 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת לכל 𝑥 ← 𝑥𝑀 מקבל כל 𝑤 ← ‪← 𝐿(𝑀𝑥) = Σ‬‬
‫גם המכונה 𝑀𝐴𝑇𝑆𝑀 מקבלת כל קלט ←‬
‫⋆‬ ‫⋆‬
‫|‬ ‫| |‬
‫∞ = ‪.< 𝑀𝑥, 𝑀𝑆𝑇𝐴𝑀 >∈ 𝐿 ← 𝐿(𝑀𝑥) ∩ 𝐿(𝑀𝑆𝑇𝐴𝑀) = Σ ∩ Σ = Σ‬‬ ‫|⋆ | |‬
‫⋆‬
‫■ 𝑃𝐻 ∉> 𝑥 ‪ ← < 𝑀,‬לכל ‪ 𝑤 ∈ Σ‬מתקיים ש‪ 𝑀:‬על 𝑥 < |𝑤| ולכן )𝑥𝑀(𝐿 היא שפה‬
‫|‬
‫סופית ← ∞ < )𝑥𝑀(𝐿 ובנוסף 𝑀𝐴𝑇𝑆𝑀 מקבלת כל קלט ←‬ ‫|‬
‫|‬
‫∞ < )𝑀𝐴𝑇𝑆𝑀(𝐿 ∩ )𝑥𝑀(𝐿 ← 𝐿 ∉> 𝑀𝐴𝑇𝑆𝑀 ‪.< 𝑀𝑥,‬‬ ‫|‬
‫● סיכום‪ :‬ממשפט הרדוקציה 𝐸𝑅 ∉ 𝑃𝐻 ולכן 𝐸𝑅 ∉ 𝐿‪ .‬מאחר ו‪ 𝑅 ⊆ 𝑅𝐸 -‬אז גם 𝑅 ∉ 𝐿‪.‬‬
‫כלומר הוכחנו כי 𝑅 ‪ 𝐿 ∉ 𝑅𝐸,‬כנדרש‪.‬‬
‫∎‬
‫שפות שלמות‬
‫הגדרות‬
‫הגדרה ‪ - 1‬שפה 𝐿 היא שלמה ב‪ 𝑅𝐸-‬אם"ם היא מקיימת‪:‬‬
‫‪𝐿 ∈ 𝑅𝐸 .1‬‬
‫‪ 𝐿' ( ∀𝐿' ∈ 𝑅𝐸 : 𝐿' ≤ 𝐿 .2‬ניתנת לרדוקציה על 𝐿)‪.‬‬
‫הגדרה ‪ - 2‬שפה 𝐿 היא שלמה ב‪ 𝑅-‬אם"ם היא מקיימת‪:‬‬

‫‪𝐿 ∈ 𝑅 .1‬‬
‫‪ 𝐿' ( ∀𝐿' ∈ 𝑅 : 𝐿' ≤ 𝐿 .2‬ניתנת לרדוקציה על 𝐿)‪.‬‬
‫הגדרה ‪ - 3‬שפה 𝐿 היא שלמה ב‪ 𝑐𝑜𝑅𝐸-‬אם"ם היא מקיימת‪:‬‬

‫‪𝐿 ∈ 𝑐𝑜𝑅𝐸 .1‬‬
‫‪( ∀𝐿' ∈ 𝑐𝑜𝑅𝐸 : 𝐿' ≤ 𝐿 .2‬כלומר‪ 𝐿' ,‬ניתנת לרדוקציה על 𝐿)‪.‬‬
‫סימונים‬
‫● נסמן 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝑐 ‪ 𝐿 ∈ 𝑅𝐸 −‬כאשר 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝑐 ‪ 𝑅𝐸 −‬היא מחלקת השפות השלמות ב‪.𝑅𝐸-‬‬
‫● נסמן 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝑐 ‪ 𝐿 ∈ 𝑅 −‬כאשר 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝑐 ‪ 𝑅 −‬היא מחלקת השפות השלמות ב‪.𝑅-‬‬
‫● נסמן 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝑐 ‪ 𝐿 ∈ 𝑐𝑜𝑅𝐸 −‬כאשר 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝑐 ‪ 𝑐𝑜𝑅𝐸 −‬היא מחלקת השפות השלמות ב‪-‬‬
‫𝐸𝑅𝑜𝑐‬
‫דוגמא לשפה שלמה ב‪.𝑅𝐸-‬‬
‫טענה‪ :‬השפה }𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑥 ‪ 𝐿𝑢 = {< 𝑀,‬היא שפה שלמה ב‪.𝑅𝐸-‬‬
‫מבוא להוכחה‪ :‬לפי ההגדרה‪ ,‬צריך להראות ש‪ 𝐿𝑢 ∈ 𝑅𝐸 )1( :‬וגם (‪ )2‬שלא משנה איזה שפה אחרת 𝐸𝑅 ∈ '𝐿‪,‬‬
‫יש לה רדוקציה ל‪.𝐿𝑢-‬‬
‫‪ .1‬הוכחנו בשיעורים קודמים ש‪( 𝐿𝑢 ∈ 𝑅𝐸:‬נחזור על זה שוב)‪:‬‬
‫נתאר מכונת טיורינג 𝑢𝑀 המקבלת את השפה 𝑢𝐿‪:‬‬
‫𝑢𝑀 על קלט > 𝑥 ‪ < 𝑀,‬תסמלץ את ריצת 𝑀 על הקלט 𝑥 ותענה כמוה‪.‬‬
‫● (ראינו שניתן "לסמלץ" ריצה של מכונה שנתונה לנו כקידוד)‪.‬‬
‫● אם 𝑢𝐿 ∈> 𝑥 ‪ < 𝑀,‬אז 𝑀 מקבלת את הקלט 𝑥‪ ,‬מכאן ש‪ 𝑀𝑢-‬מקבלת את הקלט > 𝑥 ‪ < 𝑀,‬אזי‬
‫)𝑢𝑀(𝐿 ∈> 𝑥 ‪.< 𝑀,‬‬
‫● אם 𝑢𝐿 ∉> 𝑥 ‪ < 𝑀,‬אז 𝑀 לא מקבלת את הקלט 𝑥‪ ,‬מכאן ש‪ 𝑀𝑢-‬לא מקבלת את הקלט‬
‫> 𝑥 ‪ < 𝑀,‬אזי )𝑢𝑀(𝐿 ∉> 𝑥 ‪( .< 𝑀,‬כלומר היא דוחה או לא עוצרת כהגדרה של 𝐸𝑅)‪.‬‬
‫הראנו ש‪ 𝐿𝑢 = 𝐿(𝑀𝑢) :‬כלומר שקיימת מכונה 𝑢𝑀 המקבלת את השפה 𝑢𝐿 ולכן 𝐸𝑅 ∈ 𝑢𝐿‪.‬‬
‫‪ .2‬נראה רדוקציה מכל שפה ב‪ 𝑅𝐸-‬אל })𝑀(𝐿 ∈ 𝑥 | > 𝑥 ‪.𝐿𝑢 = {< 𝑀,‬‬
‫תהי שפה 𝐸𝑅 ∈ '𝐿‪ ,‬אזי קיימת עבורה מ"ט '𝑀 המקבלת את '𝐿‪ .‬יהי > '𝑀 < קידוד של המכונה '𝑀‪.‬‬
‫אזי פונקציית הרדוקציה עבור 𝑢𝐿 ≤ '𝐿 היא‪.𝑓(𝑥) =< 𝑀', 𝑥 > :‬‬
‫כאשר 𝑢𝑀 על קלט 𝑤 אז‪:‬‬
‫‪ .1‬נריץ את '𝑀 על 𝑥‪:‬‬
‫‪ .a‬אם '𝑀 מקבל את 𝑥 אז קבל‪.‬‬
‫‪ .b‬אם '𝑀 דוחה את 𝑥 אז דוחה‪.‬‬
‫‪ .c‬אם '𝑀 לא עוצר על 𝑥 אז גם לא עוצר‪.‬‬
‫נכונות הפונקציה‪:‬‬
‫הפונקציה מלאה וניתנת לחישוב (שרשור של מחרוזת קבועה למילה הנתונה)‪.‬‬
‫‪ .1‬אם '𝐿 ∈ 𝑥 )🠈( '𝑀 מקבלת את 𝑥 )🠈( 𝑢𝑀 עוצר ומקבל את 𝑤 )🠈( 𝑢𝐿 ∈ 𝑤‪.‬‬
‫‪ .2‬אם '𝐿 ∉ 𝑥 )🠈( '𝑀 דוחה את 𝑥 או לא עוצרת )🠈( 𝑢𝑀 דוחה את 𝑤 או לא עוצר )🠈( 𝑢𝐿 ∉ 𝑤‪.‬‬
‫∎‬
‫האם יש עוד שפות שלמות ב‪?𝑅𝐸-‬‬
‫נתונה שפה שלמה 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪ 𝐿 ∈ 𝑅𝐸 −‬ונתונה שפה נוספת 𝐸𝑅 ∈* 𝐿‪.‬‬
‫אם מתקיים ש‪ 𝐿 ≤ 𝐿 * :‬אז נסיק שגם 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪.𝐿 *∈ 𝑅𝐸 −‬‬
‫שאלה ‪ -‬למה זה נכון?‬
‫תשובה ‪ -‬הראנו שתכונת הטרנזטיביות תקפה עבור רדוקציות‪ .‬אם לכל 𝐸𝑅 ∈ '𝐿 אפשר לעשות עם 𝐿 רדוקציה‬
‫כלומר 𝐿 ≤ '𝐿 וגם מתקיים ש‪ 𝐿 ≤ 𝐿 * :‬אז * 𝐿 ≤ 𝐿 ≤ '𝐿 ולפי טרנזיטיביות* 𝐿 ≤ '𝐿 ‪.‬‬
‫מסקנה ‪ -‬השפה 𝑃𝐻 היא גם שלמה ב‪.𝑅𝐸-‬‬

‫הוכחה ‪ .𝐿𝑢 ≤ 𝐻𝑃 -‬פונקציית הרדוקציה‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀', 𝑥 > :‬‬
‫כך ש‪ 𝑀' :‬זהה למכונה 𝑀‪ ,‬רק שאם 𝑀 דוחה‪ ,‬אז '𝑀 נכנסת ללולאה אינסופית‪.‬‬
‫'𝑀 על הקלט 𝑤‪:‬‬
‫● מריצה את 𝑀 על 𝑥‪:‬‬
‫○ אם 𝑀 קיבל את 𝑥 ‪ -‬תקבל‬
‫○ אם 𝑀 דחתה את 𝑥 ‪ -‬תרוץ לאינסוף‪.‬‬
‫הוכחת נכונות פונקציית הרדוקציה‪:‬‬
‫● הפונקציה מלאה וניתנת לחישוב (שרשור של מחרוזת קבועה למילה הנתונה)‪.‬‬
‫● הפונקציה פתירה‪:‬‬
‫○ אם 𝑢𝐿 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬מקבלת את 𝑥 ← '𝑀 מקבלת את 𝑤 ← 𝑃𝐻 ∈> 𝑥 ‪.< 𝑀',‬‬
‫○ אם 𝑢𝐿 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬דוחה את 𝑥 ← '𝑀 לא עוצרת ← 𝑃𝐻 ∉> 𝑥 ‪.< 𝑀',‬‬
‫לכן‪ ,‬גם השפה 𝑃𝐻 היא שפה שלמה ב‪.𝑅𝐸-‬‬
‫שיטה להוכחת שלמות של שפה‬

‫נתונה שפה שלמה 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪ 𝐿 ∈ 𝑅𝐸 −‬ונתונה שפה נוספת 𝐸𝑅 ∈* 𝐿‪.‬‬
‫אם מתקיים ש‪ 𝐿 ≤ 𝐿 * :‬אז נסיק שגם 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪.𝐿 *∈ 𝑅𝐸 −‬‬
‫תזכורת‪ :‬ראינו רדוקציה ∞𝐿 ≤ 𝑃𝐻‪.‬‬
‫שאלה‪ :‬האם זה אומר ש‪ 𝐿∞ :‬גם היא שלמה ב‪.?𝑅𝐸-‬‬
‫תשובה‪ :‬לא‪ ,‬כי 𝐸𝑅 ∉ ∞𝐿‪.‬‬
‫שאלה‪ :‬האם יש שפות שלמות ב‪?𝑅-‬‬
‫תשובה‪ :‬כן‪ ,‬כמעט כולן! יש בדיוק ‪ 2‬שפות שלא יכולות להיות שלמות ב‪( 𝑅-‬הם השפות ∅ ‪.)Σ *,‬‬
‫שאלה‪ :‬למה השפות ∅ ‪ Σ *,‬לא שלמות?‬
‫תשובה‪ :‬כי אי אפשר לעשות עליהן רדוקציה‪ ,‬כי ∅ ‪ Σ *,‬שתיהן אומרות "כולם בפנים או כולם בחוץ" אז אין לנו‬
‫אף שפה אחרת שאפשר לעשות עליהן רדוקציה (מלבד אחת על השניה)‪.‬‬
‫טענה‬
‫}∅ ‪ .𝑅 − 𝐶𝑜𝑚𝑝𝑙𝑒𝑡𝑒 = 𝑅 \ {Σ *,‬כלומר כל שפה 𝑅 ∈ 𝐿 היא שלמה מלבד השפות }∅ ‪.{Σ *,‬‬
‫הוכחה‪ :‬ראשית‪ ,‬נשים לב שלא יכולה להיות קיימת רדוקציה משפה כלשהי 𝐿 שאינה טריוויאלית אל אחת‬
‫מהשפות הטריוויאליות ∅ ‪.Σ *,‬‬
‫נוכיח שבהינתן שתי שפות כלשהן‪ 𝐿1, 𝐿2 ∈ 𝑅 \ {Σ *, ∅} :‬מתקיים ש‪.𝐿1 ≤ 𝐿2 :‬‬
‫תהי ‪ 𝑀1‬מכונת טיורינג המכריעה את השפה ‪.𝐿1‬‬
‫נבחר שתי מילים ‪( 𝑥 ∈ 𝐿2, 𝑦 ∉ 𝐿2‬האם אפשר לבחור? ‪ -‬כן כי אנחנו לא ב‪.)Σ *, ∅-‬‬
‫נתאר מכונה לחישוב פונקציית הרדוקציה ‪:𝐿1 ≤ 𝐿2‬‬
‫המכונה 𝑓𝑀 על קלט 𝑤‪:‬‬
‫● מסמלצת את ריצת ‪ 𝑀1‬על הקלט 𝑤‪:‬‬
‫○ אם ‪ 𝑀1‬קיבלה את 𝑤 ‪ -‬מחזירה את 𝑥‪.‬‬
‫○ אם ‪ 𝑀1‬דחתה את 𝑤 ‪ -‬מחזירה את 𝑦‪.‬‬
‫הערה‪ :‬בשלב הזה‪ ,‬פונקציית הרדוקציה החזירה 𝑥 אם ‪ 𝑀1‬קיבלה את 𝑤‪ .‬אמרנו שפלט הפונקציה נשלח למכונה של ‪ ,𝐿2‬לכן המכונה ‪ 𝑀2‬תקבל את 𝑥‬
‫ומכיוון שהגדרנו כבר מראש ש‪ 𝑥 ∈ 𝐿2 :‬אז ‪ 𝑀2‬תקבל את 𝑥 כנדרש‪ .‬עבור 𝑦 השלב הזה דומה רק הפוך (דחייה)‪.‬‬
‫נוכיח את נכונות פונקציית הרדוקציה‪:‬‬

‫‪ .1‬הפונקציה מלאה וניתנת לחישוב ‪ -‬תיארנו את האלגוריתם של המכונה המחשבת את הפונקציה‪.‬‬
‫בנוסף‪ 𝑀1 ,‬מכריעה את ‪ ,𝐿1‬כך שלכל מילה ‪ 𝑀1‬עוצרת‪ .‬לכן‪ ,‬לכל מילה מ‪ ,Σ *-‬המכונה 𝑓𝑀 תחזיר‬
‫פלט‪.‬‬
‫‪ .2‬הפונקציה תקפה‪:‬‬
‫‪ .a‬אם ‪ 𝑀1 ← 𝑥 ∈ 𝐿2‬קיבלת את 𝑤 ← 𝑓𝑀 מחזירה את 𝑥 ← )‪.𝑥 ∈ 𝐿(𝑀2‬‬
‫‪ .b‬אם ‪ 𝑀1 ← 𝑦 ∉ 𝐿2‬דחתה את 𝑤 ← 𝑓𝑀 מחזירה את 𝑦 ← )‪.𝑦 ∉ 𝐿(𝑀2‬‬
‫משפט רייס‬
‫מבוא‬
‫משפט רייס הוא משפט שעוסק ביכולת של אלגוריתמים לחקור אלגוריתמים אחרים‪ .‬באופן אינטואיטיבי המשפט‬
‫טוען שתוכנית מחשב אינה יכולה לדעת כמעט כלום על הפלטים של תוכניות מחשב הנתונות לה כקלט‪.‬‬
‫הבעיה פשוטה‪ :‬בהינתן תכונה של קבוצת מספרים טבעיים‪ ,‬אנחנו רוצים‬
‫אלגוריתם כלשהו שמקבל כקלט מכונת טיורינג ואומר האם הקבוצה של‬
‫המספרים שמזוהים על ידי המכונה היא בעלת התכונה הזו או לאו‪.‬‬
‫כפי שניתן לנחש‪ ,‬אלגוריתם שכזה לא קיים כמעט אף פעם‪ ,‬ולמשפט‬
‫שאומר זאת בצורה פורמלית קוראים משפט רייס‪ .‬מה אומר משפט רייס?‬
‫שלכל תכונה לא טריוויאלית 𝑆 של קבוצות טבעיים (ובניסוחים אחרים ‪-‬‬
‫פונקציות‪ ,‬שפות ‪ -‬זה לא חשוב כי הכל שקול) לא קיים אלגוריתם שמקבל כקלט מכונת טיורינג 𝑀 ואומר האם‬
‫קבוצת המספרים ש‪ 𝑀-‬מקבלת היא בעלת התכונה 𝑆‪.‬‬
‫עד עכשיו‪ ,‬כשראינו שפה מהצורה‪ 𝐿 = {< 𝑀 > | 𝐿(𝑀) ℎ𝑎𝑠 𝑎 𝑝𝑎𝑟𝑡𝑖𝑐𝑢𝑙𝑎𝑟 𝑝𝑟𝑜𝑝𝑒𝑟𝑡𝑦} :‬ניסינו להתאים‬
‫לה רדוקציה ספציפית כדי להוכיח עבורה לאיזה מחלקה היא איננה שייכת‪.‬‬
‫במקרים כאלה‪ ,‬משפט רייס נותן לנו קיצור דרך‪.‬‬
‫הגדרה ‪ -‬תכונה של שפות ב‪𝑅𝐸-‬‬

‫אבחנה‪ :‬כשמדברים על תכונה מסוימת‪ ,‬נוח לדבר על הקבוצה של האובייקטים אשר מקיימים את התכונה‪.‬‬
‫לדוגמה‪ :‬התכונה "עיניים חומות" ≡ קבוצת האנשים בעלי עיניים חומות‪.‬‬
‫אנו נתמקד בתכונות של שפות למשל‪:‬‬
‫‪ .1‬שפות בעלות לפחות ‪ 5‬מילים‪.‬‬
‫‪ .2‬שפות בעלות מספר אינסופי של מילים‪.‬‬
‫‪ .3‬שפות המכילות רק מילים בעלות אורך זוגי‪.‬‬
‫‪ .4‬שפות המכילות את המילה ‪.ε‬‬
‫הגדרה ‪ -‬תכונות לא טריוויאליות‬

‫משפט רייס עוסק בתכונות של שפות שהמאפיין אותן הוא היותן תתי‬
‫קבוצות לא ריקות החלקיות ממש ל‪.𝑅𝐸-‬‬
‫הגדרה‪ :‬תכונות לא טריוויאליות ב‪ 𝑅𝐸-‬הן תכונות 𝑆 כך ש‪𝑆 ⊆ 𝑅𝐸 :‬‬
‫וכן 𝐸𝑅 ≠ 𝑆 ≠ ∅‪.‬‬
‫אבחנה‪ :‬לכל תכונה לא טריוויאלית 𝑆 קיימת לפחות שפה אחת ב‪𝑆-‬‬
‫ולפחות שפה אחת ב‪.𝑅𝐸\𝑆-‬‬
‫הגדרה ‪ -‬השפה 𝑆𝐿‬

‫בהינתן תכונה 𝐸𝑅 ⊂ 𝑆‪ ,‬נגדיר את השפה }𝑆 ∈ )𝑀(𝐿 | > 𝑀 <{ = 𝑆𝐿‪.‬‬
‫כלומר‪ 𝐿𝑆 ,‬היא שפת קידודי המכונות כך ששפת המכונה שייכת לתכונה 𝑆‪.‬‬
‫נסמן להמשך הפרק‪:‬‬

‫● ∅ ‪ -‬קבוצת ריקה של שפות‪.‬‬
‫● ‪ - φ‬השפה הריקה‪.‬‬
‫דוגמאות‪:‬‬
‫‪ .1‬לתכונה }‪ 𝑠1 = {𝐿 ∈ 𝑅𝐸 | |𝐿| ≥ 2‬מתאימה השפה }‪𝐿𝑠 = {< 𝑀 > : |𝐿(𝑀)| ≥ 2‬‬
‫‪1‬‬
‫‪ .2‬לתכונה }𝐿 ∈ ‪ 𝑠2 = {𝐿 ∈ 𝑅𝐸 |ε‬מתאימה השפה })𝑀(𝐿 ∈ ‪𝐿𝑠 = {< 𝑀 > : ε‬‬

‫‪2‬‬
‫⋆‬
‫‪ .3‬לתכונה }}‪ 𝑠3 = {φ, Σ , {11, 0‬מתאימה השפה }‪𝐿𝑠 = {< 𝑀 > : 𝐿(𝑀) ∈ 𝑠3‬‬
‫‪3‬‬
‫‪ .4‬לתכונה }𝑒𝑡𝑖𝑛𝑖𝑓𝑛𝑖 𝑠𝑖 |𝐿| ‪ 𝑠4 = {𝐿 ∈ 𝑅𝐸 :‬מתאימה השפה‬

‫}𝑒𝑡𝑖𝑛𝑖𝑓𝑛𝑖 𝑠𝑖 |)𝑀(𝐿| ‪𝐿∞ = {< 𝑀 > :‬‬
‫משפט רייס‬
‫לכל תכונה לא טריוויאלית 𝐸𝑅 ⊂ 𝑆 ≠ ∅ מתקיים 𝑅 ∉ 𝑆𝐿‪.‬‬
‫במילים‪ :‬כל תכונה שאפשר לכתוב ב‪ 𝑅𝐸-‬שהיא לא ∅ והיא לא כל 𝐸𝑅 אומר ששפת כל המכונות שמקיימות את‬
‫התכונה 𝑆 לא שייכת למחלקה 𝑅‪.‬‬
‫משפט רייס המורחב‬

‫בנוסף למשפט‪,‬‬
‫● אם 𝑆 ∉ ‪( φ‬השפה הריקה) אז גם 𝐸𝑅𝑜𝑐 ∉ 𝑆𝐿‪.‬‬
‫● אם 𝑆 ∈ ‪( φ‬השפה הריקה) אז גם 𝐸𝑅 ∉ 𝑆𝐿‪.‬‬
‫רעיון ההוכחה‪:‬‬
‫נחלק למקרים‪:‬‬
‫‪ .1‬אם 𝑆 ∉ ‪( φ‬השפה הריקה) אז נראה כי 𝑆𝐿 ≤ 𝑃𝐻 ומזה נובע כי 𝐸𝑅𝑜𝑐 ∉ 𝑆𝐿‪.‬‬
‫‪ .2‬אם 𝑆 ∈ ‪( φ‬השפה הריקה) אז נראה כי 𝑆𝐿 ≤ 𝑃𝐻 ומזה נובע כי 𝐸𝑅 ∉ 𝑆𝐿‪.‬‬

‫בשני המקרים נקבל כי 𝑅 ∉ 𝑆𝐿‪.‬‬
‫תזכורת‪.𝐻𝑃 ∉ 𝑐𝑜𝑅𝐸 𝑎𝑛𝑑 𝐻𝑃 ∉ 𝑅𝐸 :‬‬
‫הוכחה (מקרה ‪ :)1‬אם 𝑆 ∉ ‪ φ‬נראה כי 𝑆𝐿 ≤ 𝑃𝐻 ומזה נוכיח ש‪.𝐿𝑆 ∉ 𝑐𝑜𝑅𝐸 :‬‬

‫אם השפה הריקה לא מקיימת את התכונה 𝑆 (תכונה לא טריוויאלית)‪ ,‬כלומר 𝑆 ∉ ‪ φ‬אז‬
‫𝑆\𝐸𝑅 ∈ ‪ .φ‬לכן‪ ,‬קיימת שפה 𝑆 ∈ ‪ ,𝐿1‬ותהי 𝐿𝑀 מ"ט המקבלת את ‪.𝐿1‬‬
‫‪1‬‬
‫(למה ‪ 𝐿1‬קיימת? ‪ -‬כי ראינו שלכל תכונה לא טריוויאלית 𝑆 קיימת לפחות שפה אחת ב‪ 𝑆-‬ולפחות שפה אחת‬
‫𝑃𝐻 (נראה רדוקציה מ‪ 𝐻𝑃-‬ל‪.)𝐿𝑆-‬‬ ‫ב‪ .)𝑅𝐸\𝑆-‬נוכיח ש‪≤ 𝐿𝑆 :‬‬

‫⋆‬
‫כך ש‪ 𝑀𝑥 :‬על קלט ‪:𝑦 ∈ Σ‬‬
‫‪ .1‬מריצה את 𝑀 על 𝑥‪( .‬מחסום)‪.‬‬
‫‪ .2‬מריצה את 𝐿𝑀 על 𝑦 ועונה כמוה‪.‬‬
‫‪1‬‬
‫הערה‪ :‬אם 𝑀 לא עצרה על 𝑥 אז 𝑥𝑀 תקוע לנצח וממשיך לרוץ‪ ,‬לכן השפה תהיה ריקה ‪ φ‬כי אין לנו אף 𝑦 שאפשר יהיה להריץ אותו על 𝐿𝑀 כי 𝑀 לא‬
‫‪1‬‬
‫עוצרת‪ .‬אבל‪ ,‬אם השפה שקיבלנו ריקה ‪ φ‬אז אנחנו לא בתכונה 𝑆‪.‬‬
‫נוכיח את נכונות פונקצית הרדוקציה‪:‬‬
‫‪ .1‬הפונקציה מלאה (מהגדרה)‪.‬‬
‫‪ .2‬ניתנת לחישוב (פעולת קומפילציה פשוטה) כי ניתן לקודד כל מ"ט‪.‬‬
‫‪ .3‬תקפה‪:‬‬
‫)🠊() 𝐿𝑀(𝐿 = )𝑥𝑀(𝐿 )🠊( 𝑦 𝑛𝑜 𝐿𝑀 𝑠𝑛𝑢𝑟 𝑥𝑀 )🠊( 𝑥 𝑛𝑜 𝑠𝑝𝑜𝑡𝑠 𝑀 )🠊(𝑃𝐻 ∈> 𝑥 ‪● < 𝑀,‬‬
‫‪1‬‬ ‫‪1‬‬
‫𝑆𝐿 ∈ 𝑥𝑀 )🠊( 𝑆𝐿 ∈ 𝐿𝑀 𝑡𝑎‪(🠊)𝑊𝑒 𝑘𝑛𝑜𝑤 𝑡ℎ‬‬

‫‪1‬‬
‫)🠊( 𝑦 𝑛𝑜 𝑟𝑒𝑣𝑒𝑟𝑜𝑓 𝑠𝑛𝑢𝑟 𝑥𝑀 )🠊( 𝑥 𝑛𝑜 𝑟𝑒𝑣𝑒𝑟𝑜𝑓 𝑠𝑛𝑢𝑟 𝑀)🠊(𝑃𝐻 ∉> 𝑥 ‪● < 𝑀,‬‬
‫𝑆𝐿 ∉ 𝑥𝑀 )🠊( 𝑆𝐿 ∉ ‪(🠊)𝐿(𝑀𝑥) = φ (🠊) 𝑊𝑒 𝑘𝑛𝑜𝑤 𝑡ℎ𝑎𝑡 φ‬‬
‫אנו יודעים כי 𝐸𝑅𝑜𝑐 ∉ 𝑃𝐻 ומאחר והוכחנו ברדוקציה 𝑆𝐿 ≤ 𝑃𝐻 אז קיבלנו גם ש‪ 𝐿𝑆 ∉ 𝑐𝑜𝑅𝐸 :‬כנדרש‪.‬‬

‫∎‬
‫הוכחה (מקרה ‪ :)2‬אם 𝑆 ∈ ‪ φ‬נראה כי 𝑆𝐿 ≤ 𝑃𝐻 ומזה נוכיח ש‪.𝐿𝑆 ∉ 𝑅𝐸 :‬‬

‫השפה הריקה מקיימת את התכונה 𝑆 (תכונה לא טריוויאלית) כלומר 𝑆 ∈ ‪.φ‬‬
‫תהי שפה 𝑆\𝐸𝑅 ∈ ‪ 𝐿2‬ותהי 𝐿𝑀 מ"ט המקבלת את ‪.𝐿2‬‬
‫‪2‬‬
‫נוכיח ש‪.𝐻𝑃 ≤ 𝐿𝑆 :‬‬

‫⋆‬
‫כך ש‪ 𝑀𝑥 :‬על קלט ‪:𝑦 ∈ Σ‬‬
‫‪ .1‬מריצה את 𝑀 על 𝑥‪( .‬מחסום)‪.‬‬
‫‪ .2‬מריצה את 𝐿𝑀 על 𝑦 ועונה כמוה‪.‬‬

‫‪2‬‬
‫הערה‪ :‬אם 𝑃𝐻 ∈> 𝑥 ‪ < 𝑀,‬אז 𝑀 לא עצרה על 𝑥 כלומר 𝑥𝑀 תקוע לנצח וממשיך לרוץ‪ ,‬לכן השפה תהיה ריקה ‪ 𝐿(𝑀𝑥) = φ‬ולכן היא ב‪.𝑆-‬‬
‫נוכיח את נכונות פונקצית הרדוקציה‪:‬‬

‫‪ .1‬הפונקציה מלאה (מהגדרה)‪.‬‬
‫‪ .2‬ניתנת לחישוב (פעולת קומפילציה פשוטה) כי ניתן לקודד כל מ"ט‪.‬‬
‫‪ .3‬תקפה‪:‬‬
‫)🠊( 𝑦 𝑛𝑜 𝑟𝑒𝑣𝑒𝑟𝑜𝑓 𝑠𝑛𝑢𝑟 𝑥𝑀 )🠊( 𝑥 𝑛𝑜 𝑟𝑒𝑣𝑒𝑟𝑜𝑓 𝑠𝑛𝑢𝑟 𝑀)🠊(𝑃𝐻 ∈> 𝑥 ‪● < 𝑀,‬‬
‫𝑆𝐿 ∈ 𝑥𝑀 )🠊( 𝑆 ∈ ‪(🠊)𝐿(𝑀𝑥) = φ (🠊) 𝑊𝑒 𝑘𝑛𝑜𝑤 𝑡ℎ𝑎𝑡 φ‬‬
‫)🠊( 𝑦 𝑛𝑜 𝐿𝑀 𝑠𝑛𝑢𝑟 𝑥𝑀 )🠊( 𝑥 𝑛𝑜 𝑠𝑝𝑜𝑡𝑠 𝑀 )🠊(𝑃𝐻 ∉> 𝑥 ‪● < 𝑀,‬‬

‫‪2‬‬
‫𝑆𝐿 ∉ 𝑥𝑀 )🠊( 𝑆𝐿 ∉ 𝐿𝑀 𝑡𝑎‪(🠊)𝐿(𝑀𝑥) = 𝐿(𝑀𝐿 )(🠊)𝑊𝑒 𝑘𝑛𝑜𝑤 𝑡ℎ‬‬

‫‪2‬‬ ‫‪2‬‬
‫אנו יודעים כי 𝐸𝑅 ∉ 𝑃𝐻 ומאחר והוכחנו ברדוקציה 𝑆𝐿 ≤ 𝑃𝐻 אז קיבלנו גם ש‪ 𝐿𝑆 ∉ 𝑅𝐸 :‬כנדרש‪.‬‬

‫∎‬
‫מה קורה כאשר התכונה 𝑆 היא טריוויאלית?‬
‫אם נתון שתכונה 𝑆 טריוויאלית אז‪:‬‬
‫‪ .1‬אם 𝐸𝑅 = 𝑆‪ ,‬אז אפשר לקבל כל קידוד של מ"ט‪ .‬מכיוון שהנחנו כי כל מחרוזת מתארת מ"ט כלשהי‪,‬‬
‫⋆‬ ‫⋆‬
‫נקבל כי השפה 𝑆𝐿 מכילה את כל המחרוזות‪ ,‬כלומר ‪ 𝐿𝑆 = Σ‬ואכן 𝑅 ∈ ‪.Σ‬‬
‫‪ .2‬אם ∅ = 𝑆‪ ,‬אז אפשר לדחות כל קידוד של מ"ט‪ .‬כלומר‪ ,‬השפה 𝑆𝐿 לא מכילה מילים כלל‪ ,‬כלומר‬
‫‪ 𝐿𝑆 = φ‬ואכן 𝑅 ∈ ‪.φ‬‬
‫מסקנה ‪ :1‬אם התכונה 𝑆 היא טריוויאלית ‪ -‬משפט רייס "לא עובד"‪.‬‬

‫מסקנה ‪ 𝐿𝑆 ∈ 𝑅 :2‬כאשר 𝑆 טריוויאלית‪.‬‬
‫מתי מותר להשתמש במשפט רייס?‬

‫מותר להשתמש במשפט רייס רק כשהשפה הנתונה לנו 𝐿 היא אכן קבוצת אובייקטים של תכונה מסוימת של‬
‫שפות‪ ,‬כלומר‪ ,‬קיימת תכונה 𝑆 כך ש‪.𝐿 = 𝐿𝑆 = {< 𝑀 > | 𝐿(𝑀) ∈ 𝑆} -‬‬
‫לפעמים התכונה נראית מסובכת‪ ,‬אבל היא טריוויאלית‪.‬‬
‫● אם נרצה להגדיר את 𝑆 כתכונה של מכונה ‪ -‬משפט רייס לא יעבוד‪.‬‬
‫● אם נרצה להגדיר את 𝑆 כתכונה של שפה של מכונה ‪ -‬משפט רייס כן יעבוד‪.‬‬
‫שאלה‪ :‬איך מוכיחים שתכונה היא לא טריוויאלית?‬
‫תשובה‪ :‬מראים דוגמה לשפה שמקיימת את התכונה ושפה אחרת שלא מקיימת את התכונה‪.‬‬
‫דוגמה לתכונה של מכונה‪𝐿 = {< 𝑀 > | 𝑀 ℎ𝑎𝑙𝑡𝑠 𝑜𝑛 𝑒𝑣𝑒𝑟𝑦 𝑖𝑛𝑝𝑢𝑡} :‬‬

‫⋆‬
‫דוגמה לתכונה של שפה של מכונה‪𝐿 = {𝑤 ∈ Σ : |𝑤| 𝑖𝑠 𝑒𝑣𝑒𝑛} :‬‬
‫אבחנה‪ :‬אם התכונה המדוברת היא תכונה של מכונה ולא תכונה של שפה של המכונה אז משפט רייס לא עובד‪.‬‬
‫דוגמה לאבחנה‪ :‬נתונה השפה }𝑡𝑢𝑝𝑛𝑖 𝑦𝑟𝑒𝑣𝑒 𝑛𝑜 𝑠𝑡𝑙𝑎‪.𝐿 = {< 𝑀 > | 𝑀 ℎ‬‬
‫עצירה היא תכונה של מכונה ולא של שפה (כי שואלים מתי 𝑀 עוצרת)‪ ,‬בהינתן תכונה לא טריוויאלית 𝑆‪:‬‬
‫● יש מכונות שתמיד עוצרות שהשפה שלהן ב‪.𝑆-‬‬
‫● יש מכונות שמקבלות את אותה שפה שלא עוצרות על מילים שלא בשפה‪.‬‬
‫התכונה היחידה של משפט רייס שעשויה להתאים לשפה הנתונה 𝐿 היא 𝑅 = 𝑆‪.‬‬
‫אבל‪ ,‬אפשר לחשוב על מכונה שמקבלת שפה ב‪ 𝑅-‬ולא עוצרת על מילים שלא בשפה‪.‬‬
‫שאלה‪ :‬למה זה לא סותר את זה שהשפה ב‪?𝑅-‬‬
‫תשובה‪ :‬כי כדי להוכיח ששפה מסוימת היא ב‪ ,𝑅-‬מספיקה מכונה אחת‪ ,‬אבל יכול להיות שיש מכונה אחרת‬
‫שמקבלת את אותה השפה אבל היא לא מקיימת את התכונה שהיא תמיד עוצרת‪ .‬למשל‪ ,‬מכונה שעל כל מילה‬
‫שלא בשפה ‪ -‬תיכנס ללולאה אינסופית‪.‬‬
‫במקרה כזה‪ ,‬צריך להוכיח בדרכים שונות (כלומר ע"י רדוקציה)‪.‬‬
‫כמה דוגמאות‬
‫דוגמה ‪ - 1‬נתונה השפה‪.𝐿1 = {< 𝑀 > : |𝐿(𝑀)| = 3} :‬‬
‫● האם שייכת ל‪ - ? 𝑅-‬לא‪ ,‬כי כל מה שעובד ברייס ‪ -‬לא נמצא ב‪.𝑅-‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬לא‪ ,‬צריך להוכיח ברדוקציה ‪ -‬כי משפט רייס לא עוזר פה‪.‬‬
‫האם ניתן להשתמש ברייס? ‪ -‬כן‪ ,‬כי זה תנאי על השפה‪ .‬וזה לא טריוויאלי כי אפשר לחשוב על שפות‬ ‫●‬
‫שהגודל שלהם הוא בדיוק ‪ 3‬ואפשר לחשוב על אחרות שיש להם גודל שונה מ‪.3-‬‬
‫⋆‬
‫דוגמה ‪ - 2‬נתונה השפה‪𝐿2 = {< 𝑀 > : 𝐿(𝑀) ⊆ Σ } :‬‬
‫● האם שייכת ל‪ - ? 𝑅-‬כן‪ ,‬כי זה תכונה טריוויאלית‪.‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬כן‪ ,‬כי כל מה שמוכל ב‪ 𝑅-‬מוכל גם ב‪.𝑅𝐸-‬‬
‫⋆‬
‫האם ניתן להשתמש ברייס? ‪ -‬לא‪ ,‬כי זו תכונה טריוויאלית ‪ -‬כל שפה מוכלת ב‪ Σ -‬אז כל מכונה שנקבל‬ ‫●‬
‫⋆‬
‫השפה של המכונה תיהיה מוכלת ב‪.Σ -‬‬
‫דוגמה ‪ - 3‬נתונה השפה‪𝐿3 = {< 𝑀 > : 𝑀 𝑎𝑐𝑐𝑒𝑝𝑡𝑠 𝑡ℎ𝑒 𝑤𝑜𝑟𝑑 ε} :‬‬
‫● האם שייכת ל‪ - ? 𝑅-‬לא‪ ,‬כי זו תכונה לא טריוויאלית‪.‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬כן‪ ,‬אפשר להריץ את 𝑀 על ‪ ε‬ואז יכול להיות שיתקבל או שלא יעצור‪.‬‬
‫האם ניתן להשתמש ברייס? ‪ -‬כן‪ ,‬כי זה תנאי על השפה‪ .‬וזה לא טריוויאלי כי אפשר לחשוב על שפות ש‬ ‫●‬
‫𝐿 ∈ ‪ ε‬ואפשר לחשוב על אחרות שעבורם 𝐿 ∉ ‪.ε‬‬
‫דוגמה ‪ - 4‬נתונה השפה‪𝐿4 = {< 𝑀 > : 𝑀 𝑟𝑒𝑗𝑒𝑐𝑡𝑠 𝑡ℎ𝑒 𝑤𝑜𝑟𝑑 ε} :‬‬

‫● האם שייכת ל‪ - ? 𝑅-‬לבדוק‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬לבדוק‬
‫האם ניתן להשתמש ברייס? ‪ -‬לא‪ ,‬כי זה תכונה של המכונה‪ .‬למה? ‪ -‬בשפה ‪ 𝐿3‬כן אפשר להשתמש‬ ‫●‬
‫ברייס כי אם המילה ‪ ε‬התקבלה אז נעצור‪ .‬אבל ב‪ 𝐿4-‬אם המילה ‪ ε‬נדחתה‪ ,‬אז ייתכן שלא נעצור ונכנס‬
‫ללולאה אינסופית (לפי הגדרת 𝐸𝑅) ולכן זה תלוי במכונה ‪ -‬כי היא הכניסה אותנו לריצה אינסופית‪.‬‬
‫דוגמה ‪ -5‬נתונה השפה‪𝐿5 = {< 𝑀 > : ε ∈ 𝐿(𝑀)} :‬‬

‫● האם שייכת ל‪ - ? 𝑅-‬לא‪ ,‬כי זה לא טריוויאלי‪.‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬כן‪ ,‬אפשר להריץ את 𝑀 על ‪ ε‬ואז יכול להיות שיתקבל או שלא יעצור‪.‬‬
‫האם ניתן להשתמש ברייס? ‪ -‬כן‪ ,‬כי זה תכונה של שפה וזה לא טריוויאלי כי אפשר לחשוב על שפות‬ ‫●‬
‫𝐿 ∈ ‪ ε‬ומצד שני על שפות אחרות כך ש‪.ε ∉ 𝐿 :‬‬
‫דוגמה ‪ - 6‬נתונה השפה‪𝐿6 = {< 𝑀 > : 𝐿(𝑀) ∈ 𝑐𝑜𝑅𝐸} :‬‬

‫● האם שייכת ל‪ - ? 𝑅-‬לא‪ ,‬כי אם זה לא ב‪ 𝑅𝐸-‬זה בוודאות לא ב‪.𝑅-‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬לא‪ ,‬כי לפי רייס מורחב אם 𝑆 ∈ ‪ φ‬אז למדנו שבמקרה זה 𝐸𝑅 ∉ 𝑆‪ .‬ידוע כי‬
‫השפה הריקה נמצאת ב‪ 𝑅-‬ולכן היא בהכרח גם ב‪ 𝑐𝑜𝑅𝐸-‬כי היא מוכלת בתוכה‪.‬‬
‫האם ניתן להשתמש ברייס? ‪ -‬כן‪ ,‬כי זה תכונה של שפות והיא תכונה לא טריוויאלית כי 𝐸𝑅𝑜𝑐 ∉ 𝑃𝐻‬ ‫●‬
‫ויש לנו שפה אחרת 𝐸𝑅𝑜𝑐 ∈ ‪ φ‬ולכן התכונה לא טריוויאלית‪.‬‬
‫דוגמה ‪ - 7‬נתונה השפה‪𝐿7 = {< 𝑀 > : 𝐿(𝑀) ∉ 𝑅} :‬‬

‫● האם שייכת ל‪ - ? 𝑅-‬לא‪ ,‬כי זה לא שייך גם ל‪.𝑅𝐸-‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬לא‪ ,‬כי ‪ .φ ∉ 𝐿7‬אפשר להוכיח ברדוקציה על 𝑃𝐻 כי למדנו כבר ש 𝐸𝑅 ∉ 𝑃𝐻‪.‬‬
‫האם ניתן להשתמש ברייס? ‪ -‬כן‪ ,‬כי זה תכונה של שפות והיא תכונה לא טריוויאלית כי אפשר לבחור ב‪-‬‬ ‫●‬
‫𝑅 ∉ 𝑃𝐻 ובשפה אחרת 𝑅 ∈ ‪.φ‬‬
‫דוגמה ‪ - 8‬נתונה השפה‪𝐿8 = {< 𝑀 > : |𝐿(𝑀)| 𝑖𝑠 𝑜𝑑𝑑 𝑎𝑛𝑑 |< 𝑀 >| ≤ 1000} :‬‬
‫● האם שייכת ל‪ - ? 𝑅-‬כן‪ ,‬כי כל שפה סופית היא רגולרית וכל הרגולריות מוכלות ב‪.𝑅-‬‬
‫● האם שייכת ל‪ - ?𝑅𝐸-‬כן‪ ,‬כי זה שייך גם ל‪.𝑅-‬‬
‫האם ניתן להשתמש ברייס? ‪ -‬לא‪ ,‬כי זה טריוויאלי ‪ -‬השפה סופית שייכת ל‪.𝑅-‬‬ ‫●‬

‫נתונה השפה }‪ .𝐿3 = {< 𝑀 > : |𝐿(𝑀)| ≥ 3‬כלומר‪ ,‬המכונה מקבלת לפחות ‪ 3‬מילים‪.‬‬
‫אינטואיציה‪ :‬נרצה להבין מה התכונה של השפה ולפיה להבין לאיזה מחלקה השפה הזו שייכת‪ .‬ייתכן שהמכונה‬
‫תקבל פחות מ‪ 3-‬מילים אבל היא תמשיך לבדוק את שאר המילים‪ ,‬לא תקבל אף אחת מהם ותרוץ לאינסוף‪.‬‬
‫כלומר‪ ,‬לא ניתן להכריע את תנאי השפה ולכן נניח כי 𝑅 ∉ ‪ 𝐿3‬אך אכן ב‪ .𝑅𝐸-‬אנחנו צריכים להוכיח שאכן‬
‫𝑅 ∉ ‪ 𝐿3‬וגם ש‪.𝐿3 ∈ 𝑅𝐸 :‬‬
‫הוכחה ‪ :1‬נוכיח כי 𝐸𝑅 ∈ ‪ 𝐿3‬בעזרת בניית מ"ט המקבלת את השפה ‪( .𝐿3‬להשלים בבית)‪.‬‬
‫𝐿 באמצעות משפט רייס (זה הרבה יותר קל מרדוקציה)‪.‬‬ ‫הוכחה ‪ :2‬נוכיח כי 𝑅 ∉‬
‫‪3‬‬
‫‪ .1‬הגדרת תכונה ‪ :S‬התכונה היא }‪ 𝑆 = {𝐿 ∈ 𝑅𝐸: |𝐿| ≥ 3‬ואכן ‪.𝐿𝑆 = 𝐿3‬‬
‫‪ .2‬נוכיח ש‪ S-‬לא טריוויאלית‪ :‬כלומר‪ ,‬יש להראות דוגמה ללפחות שפה אחת 𝑆 ∈ ‪ 𝐿1‬המקיימת את‬
‫התכונה‪ ,‬ושפה אחרת 𝑆 ∉ ‪ 𝐿2‬שלא מקיימת אותה‪ .‬כאשר 𝐸𝑅 ∈ ‪.𝐿1, 𝐿2‬‬
‫⋆‬ ‫⋆‬
‫הערה‪ :‬ננסה לרוב להדגים עם ∅ וגם ‪ Σ‬כי הכי קל לנו לעבוד איתם (לרוב זה יצליח) וגם כי 𝐸𝑅 ∈ ∅ ‪.Σ ,‬‬
‫⋆‬
‫נשים לב ש‪( ∅ ∉ 𝑆 :‬כי הגודל של השפה הריקה הוא ‪ 0‬ולכן לא מקיים את התכונה) וגם 𝑆 ∈ ‪.Σ‬‬
‫לכן 𝑆 לא טריוויאלית‪.‬‬
‫‪ .3‬מסקנה‪ :‬לפי משפט רייס המורחב נובע ש אם 𝑆 ∉ ∅ אז גם 𝐸𝑅𝑜𝑐 ∉ 𝑆𝐿 ובפרט 𝑅 ∉ 𝑆𝐿‪.‬‬
‫בנוסף‪ ,‬הראנו שמתקיים ש‪ 𝐿3 = 𝐿𝑆 :‬ולכן גם 𝑅 ∉ ‪ 𝐿3‬כנדרש‪.‬‬

‫נתונה השפה }‪ .𝐿 = {< 𝑀 > : |𝐿(𝑀)| = 3‬כלומר‪ ,‬המכונה מקבלת ‪ 3‬מילים בלבד‪.‬‬
‫אינטואיציה‪:‬‬
‫● דבר ראשון‪ ,‬לא ניתן להכריע את השפה 𝐿 מכיוון שאי אפשר להכריע מתי נקבל רק ‪ 3‬מילים בשפת‬
‫המכונה‪ ,‬כי המכונה עלולה לא לעצור‪.‬‬
‫● דבר שני‪ ,‬גם אם המכונה 𝑀 תקבל את המילה שלישית שלה בקלט ה‪ ,𝑖-‬עדיין ייתכן שהיא תקבל עוד‬
‫⋆‬
‫מילה בקלט ה‪ .𝑖 + 1-‬במילים אחרות‪ ,‬המכונה צריכה לעבור על כל ‪ Σ‬שזה אינסוף מילים בשביל‬
‫לקבוע בוודאות שהמכונה קיבלה רק ‪ 3‬מילים‪ ,‬לכן זו שפה שלא קיים לה מכונה שתקבל אותה‪.‬‬
‫● לכן‪ ,‬האינטואיציה היא 𝑅 ∉ 𝐿 וגם 𝐸𝑅 ∉ 𝐿‪.‬‬
‫𝐿 באמצעות משפט רייס (זה הרבה יותר קל מרדוקציה)‪.‬‬ ‫הוכחה ‪ :1‬נוכיח כי 𝑅 ∉‬
‫‪ .1‬הגדרת תכונה ‪ :S‬התכונה היא }‪ 𝑆 = {𝐿': |𝐿'| = 3‬ואכן 𝐿 = 𝑆𝐿‪.‬‬
‫‪ .2‬נוכיח ש‪ S-‬לא טריוויאלית‪ :‬נשים לב ש‪( ∅ ∉ 𝑆 :‬כי הגודל של השפה הריקה הוא ‪ 0‬ולכן לא מקיים את התכונה) וגם‬
‫𝑆 ∈ }‪ .𝐿' = {0, 1, 01‬לכן 𝑆 לא טריוויאלית‪.‬‬
‫‪ .3‬מסקנה‪ .𝐿 ∉ 𝑅 :‬משל‪.‬‬
‫הוכחה ‪ :2‬נוכיח כי 𝐸𝑅 ∉ 𝐿‪.‬‬

‫‪ .1‬אינטואיציה‪ :‬התכונה והאי‪-‬טריוויאליות זהה להוכחה ‪ .1‬אך נשים לב ש‪ ∅ ∉ 𝑆 :‬ולפי משפט רייס‬
‫המורחב 𝐸𝑅𝑜𝑐 ∉ 𝐿‪ ,‬אך זה לא אומר ש‪ .𝐿 ∈ 𝑅𝐸 :‬לכן‪ ,‬משפט רייס לא מספיק כדי להוכיח שאכן‬
‫𝐸𝑅 ∉ 𝐿‪ .‬השיטה השניה עבור הוכחת אי‪-‬שייכות היא באמצעות רדוקציה‪.‬‬
‫כדי לעבוד עם רדוקציה‪ ,‬צריך לחשוב על שפה שהוכחנו כבר במהלך הקורס שלא שייכת ל‪.𝑅𝐸-‬‬
‫השפה הזו היא השפה }𝑥 𝑛𝑜 𝑝𝑜𝑡𝑠 𝑡'𝑛𝑠𝑒𝑜𝑑 𝑀 ‪.𝐻𝑃 = {< 𝑀, 𝑥 > :‬‬
‫הרעיון הוא כזה‪:‬‬
‫● אם 𝑀 לא עוצר על 𝑥 אז 𝑥𝑀 צריכה לקבל ‪ 3‬מילים בלבד וכך 𝐿 ∈> 𝑥𝑀 <‪.‬‬
‫● אם 𝑀 עוצר על 𝑥 אז 𝑥𝑀 צריכה לקבל אינסוף מילים וכך 𝐿 ∉> 𝑥𝑀 <‪.‬‬
‫‪ .2‬תיאור הרדוקציה‪ :‬נראה רדוקציה 𝐿 ≤ 𝑃𝐻‪.‬‬

‫‪ .a‬פונקציית הרדוקציה מוגדרת כך‪.𝑓(< 𝑀, 𝑥 >) =< 𝑀𝑥 > :‬‬
‫‪ 𝑀𝑥 .b‬על 𝑤 פועלת כך‪:‬‬
‫𝑥𝑀 מקבלת כל }‪.𝑤 ∈ {0, 1, ε‬‬ ‫‪.i‬‬
‫תסמלץ את 𝑀 על 𝑥‪.‬‬ ‫‪.ii‬‬
‫אם 𝑀 עצרה אז 𝑥𝑀 תקבל את 𝑤‪.‬‬ ‫‪.iii‬‬
‫‪ .3‬הוכחת פונקציית הרדוקציה‪:‬‬
‫‪ .a‬פונקציה מלאה‪ :‬לכל 𝑥 ‪ 𝑀,‬קיים מכונה 𝑥𝑀‪.‬‬
‫‪ .b‬פונקציה ניתנת לחישוב‪ :‬לכל מ"ט קיים קידוד בצורת מחרוזת‪.‬‬
‫‪ .c‬פונקציה פתירה‪:‬‬
‫אם 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת על 𝑥 ← 𝑥𝑀 מקבלת רק }‪← 𝑤 ∈ {0, 1, ε‬‬ ‫‪.i‬‬
‫|‬ ‫|‬
‫}‪ < 𝑀𝑥 >∈ 𝐿 ← 𝐿(𝑀𝑥) = 3 ← 𝐿(𝑀𝑥) = {0, 1, ε‬כנדרש‪.‬‬
‫⋆‬
‫אם 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 ← 𝑥𝑀 מקבלת כל ‪← 𝑤 ∈ Σ‬‬ ‫‪.ii‬‬
‫⋆‬
‫‪ ← 𝐿(𝑀𝑥) = Σ‬קיבלנו ששפת המכונה בגודל אינסופי ← 𝐿 ∉> 𝑥𝑀 <‪.‬‬
‫‪ .4‬סיכום‪ :‬הוכחנו ש‪ ,𝐻𝑃 ∉ 𝑅𝐸 :‬בהפעלת רדוקציה 𝑃𝐻 על 𝐿 אז גם 𝐸𝑅 ∉ 𝐿‪.‬‬
‫סכמת עבודה כללית‬

‫נתונה השפה‪.𝐿 = {< 𝑀 > : 𝐿(𝑀) ∈ 𝑅𝐸} :‬‬
‫האם 𝑅 ∈ 𝐿 ‪ ,‬האם 𝐸𝑅𝑜𝑐 ∈ 𝐿 ‪ ,‬האם 𝐸𝑅 ∈ 𝐿 ?‬
‫⋆‬
‫פתרון‪ , 𝐿 ∈ 𝑅 :‬אבל לא בגלל רייס! למעשה‪ 𝐿 = Σ ,‬מההגדרה של 𝐸𝑅‪.‬‬

‫=𝐿‬ ‫‪{ (< 𝑀1 >,‬‬ ‫)‬ ‫}‬
‫נתונה השפה‪< 𝑀2 >, 𝑥 | 𝑀1 𝑠𝑡𝑜𝑝𝑠 𝑜𝑛 𝑥 𝑎𝑛𝑑 𝑀2 𝑑𝑜𝑒𝑠𝑛'𝑡 𝑠𝑡𝑜𝑝𝑠 𝑜𝑛 𝑥 :‬‬
‫לאיזו מחלקה השפה שייכת?‬
‫אינטואיציה‪:‬‬
‫● אי אפשר להשתמש במשפט רייס מכיוון שהשפה תלויה במכונה ולא בשפה שלה‪.‬‬
‫● זה לא ב‪ 𝑅-‬כי אי אפשר לדעת מתי לעצור לכל 𝑥 כזה‪ .‬בנוסף אפשר לראות כי יש פה שילוב של שפות‬
‫שכבר הוכחנו שהם 𝑃𝐻 ‪ 𝐻𝑃,‬שדומות ל‪ 𝐿-‬וכבר הוכחנו עליהם שלא שייכות ל‪.𝑅-‬‬
‫● יש לנו חיבור של שפה 𝐸𝑅 ∈ 𝑃𝐻 עם שפה 𝐸𝑅𝑜𝑐 ∈ 𝑃𝐻 וחיבור כזה יכול להוביל אותנו שגם אם שיכול‬
‫להיות שנקבל ולא נעצור וגם נדחה ולא נעצור‪ ,‬כלומר ב‪ 2-‬המקרים ייתכן שלא נעצור‪.‬‬
‫● האינטואיציה אומרת לנו שייתכן שמדובר בשייכות למחלקה 𝐸𝑅𝑜𝑐 ∪ 𝐸𝑅‪.‬‬
‫● נוכיח על ידי שתי רדוקציות 𝐿 ≤ 𝑃𝐻 וגם 𝐿 ≤ 𝑃𝐻‪.‬‬
‫הוכחת רדוקציה ראשונה‪.𝐻𝑃 ≤ 𝐿 :‬‬

‫● אינטואיציה‪ :‬אנחנו צריכים מכונה שתעצור על 𝑥 ועוד מכונה שלא תעצור על 𝑥‪ .‬המכונה שתעצור על 𝑥‬
‫מבוססת על מכונות שמקבלות את השפה 𝑃𝐻 בעוד שהמכונות שלא עוצרות לכל 𝑥 נסמן ב‪.𝑀𝑙𝑜𝑜𝑝-‬‬
‫אם המכונה 𝑀 מקבלת את 𝑃𝐻 אז מעולה היא אכן תעצור על 𝑥‪ ,‬אין לנו צורך לתאר אותה‪.‬‬
‫כן נדאג לתאר את המכונה 𝑝𝑜𝑜𝑙𝑀 שתפקידה להיכנס ללולאה אינסופית לכל קלט 𝑤‪.‬‬
‫● תיאור הרדוקציה‪:‬‬
‫(‬ ‫)‬
‫○ פונקציית הרדוקציה‪𝑓(< 𝑀, 𝑥 >) = < 𝑀 >, < 𝑀𝑙𝑜𝑜𝑝 >, 𝑥 :‬‬
‫○ הפעלה‪ 𝑀𝑙𝑜𝑜𝑝 :‬על קלט 𝑤 תפעל כך‪:‬‬
‫■ נכנסת ללולאה אינסופית‬
‫● הוכחת נכונות הפונקציה‪:‬‬
‫○ הפונקציה מלאה‪ :‬כי צריך רק להעתיק את 𝑥 ‪𝑀, 𝑀𝑙𝑜𝑜𝑝,‬‬
‫○ הפונקציה ניתנת לחישוב‪ :‬לכל מ"ט יש קידוד‪.‬‬
‫○ הפונקציה פתירה‪:‬‬
‫■ 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 ו‪ 𝑀𝑙𝑜𝑜𝑝-‬לא עוצרת ←‬
‫(‬
‫𝐿 ∈ 𝑥 ‪. < 𝑀 >, < 𝑀𝑙𝑜𝑜𝑝 >,‬‬‫)‬
‫■ 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת על 𝑥 ו‪ 𝑀𝑙𝑜𝑜𝑝-‬לא עוצרת ←‬
‫(‬
‫𝐿 ∉ 𝑥 ‪. < 𝑀 >, < 𝑀𝑙𝑜𝑜𝑝 >,‬‬‫)‬
‫● סיכום‪ :‬הראינו רדוקציה 𝑃𝐻 על 𝐿 וכיוון ש‪ 𝐻𝑃 ∉ 𝑐𝑜𝑅𝐸 :‬אז גם 𝐸𝑅𝑜𝑐 ∉ 𝐿 כנדרש‪.‬‬
‫הוכחת רדוקציה שניה‪.𝐻𝑃 ≤ 𝐿 :‬‬

‫● אינטואיציה‪ :‬נראה רדוקציה 𝑃𝐻 על 𝐿 ונוכיח כי אם 𝐸𝑅 ∉ 𝑃𝐻 אזי גם 𝐸𝑅 ∉ 𝐿‪.‬‬
‫אנחנו צריכים מכונה שתעצור על 𝑥 ועוד מכונה שלא תעצור על 𝑥‪.‬‬
‫מכונה שתמיד עוצרת תהיה 𝑀𝐴𝑇𝑆𝑀 המקבלת כל דבר‪.‬‬
‫● תיאור הרדוקציה‪:‬‬
‫(‬ ‫)‬
‫○ פונקצית הרדוקציה‪𝑓(< 𝑀, 𝑥 >) = < 𝑀𝑆𝑇𝐴𝑀 >, < 𝑀 >, 𝑥 :‬‬
‫○ הפעלה‪ :‬מדובר במכונות מוכרות שהוכחנו כבר בעבר‪.‬‬
‫● הוכחת נכונות הרדוקציה‪:‬‬
‫○ הפונקציה מלאה‪ :‬צריך רק להעתיק 𝑥 ‪ < 𝑀𝑆𝑇𝐴𝑀 >, < 𝑀 >,‬היא מחרוזת קבועה‪.‬‬
‫○ הפונקציה ניתנת לחישוב‪ :‬אפשר לקודד כל מכונה‪.‬‬
‫■ 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת על 𝑥 ו‪ 𝑀𝑆𝑇𝐴𝑀-‬עוצרת תמיד ←‬
‫(‬ ‫)‬
‫𝐿 ∈ 𝑥 ‪. < 𝑀𝑆𝑇𝐴𝑀 >, < 𝑀 >,‬‬
‫■ 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 ו‪ 𝑀𝑆𝑇𝐴𝑀-‬עוצרת תמיד ←‬
‫(‬ ‫)‬
‫𝐿 ∉ 𝑥 ‪. < 𝑀𝑆𝑇𝐴𝑀 >, < 𝑀 >,‬‬
‫● סיכום‪ :‬הראינו רדוקציה 𝑃𝐻 על 𝐿 וכיוון ש‪ 𝐻𝑃 ∉ 𝑅𝐸 :‬אז גם 𝐸𝑅 ∉ 𝐿 כנדרש‪.‬‬
‫לכן‪ ,‬לפי משפט הרדוקציה נקבל ש‪ 𝐿 ∈ 𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸 :‬כנדרש‪.‬‬

‫∎‬
‫בעיית העצירה החסומה ‪BHP -‬‬

‫מבוא‬
‫בפרק זה נתעסק בשפות עצירה כאשר העצירה יכולה להתבצע מסיבות שונות‪ ,‬כמו למשל‪:‬‬
‫𝐿 שנציג בפרק‪( .‬צעדי המכונה‪/‬האלגוריתם)‪.‬‬ ‫‪ .1‬עצירה תחת הגבלת מספר צעדים ‪ -‬כמו למשל השפה‬
‫𝑐‬
‫עצירה תחת הגבלת מקום ‪ -‬כמו למשל השפה 𝑃𝐻𝐵 שנציג בפרק‪( .‬הגבלת המקום קשורה לסרט)‪.‬‬ ‫‪.2‬‬
‫השפה 𝑐𝐿‬
‫נתונה השפה }𝑠𝑝𝑒𝑡𝑠 ‪.𝐿𝑐 = {< 𝑀, 𝑥 > | 𝑀 ℎ𝑎𝑙𝑡𝑠 𝑜𝑛 𝑥 𝑤𝑖𝑡ℎ𝑖𝑛 𝑐 ∈ ℕ‬‬
‫במילים‪ :‬כל הקידודים > 𝑥 ‪ < 𝑀,‬כך ש‪ 𝑀-‬עוצרת על 𝑥 בתוך 𝑐 צעדים‪.‬‬
‫אינטואיציה‪ :‬למשל ‪ 𝐿1000‬זה כל הקידודים > 𝑥 ‪ < 𝑀,‬כך שבצעד ה‪ 1000-‬המכונה 𝑀 עוצרת על 𝑥‪.‬‬
‫השפה 𝑅 ∈ 𝑐𝐿 בגלל שאם נתון לנו ה‪ 𝑐-‬אז יש לנו מעין "חסם"‪ ,‬ולכן אפשר להכריע אותה כי אנחנו "נאחזים" ב‪-‬‬
‫𝑐 שתמיד מוגדר וסופי לכל מספר טבעי שנקבל עבורו‪ .‬שלב ‪ 1‬בהוכחה תמיד מסתיים‪ ,‬כי גם אם המכונה אמורה‬
‫לרוץ לאינסוף צעדים‪ ,‬בגלל שקבענו חסם עבור מספר הצעדים שלנו‪ ,‬אז המכונה תמיד תעצור‪.‬‬
‫השפה 𝑐𝐿 שייכת למחלקה 𝐸𝑅‪.‬‬
‫טענה‪.𝐿𝑐 ∈ 𝑅 :‬‬
‫הוכחה‪ :‬נוכיח כי 𝑅 ∈ 𝑐𝐿‪.‬‬
‫נתאר מכונה מכריעה‪:‬‬
‫𝑈 על קלט > 𝑥 ‪ < 𝑀,‬תבצע‪:‬‬
‫‪ .1‬הרץ את 𝑀 על הקלט 𝑥 למשך 𝑐 צעדים‪.‬‬
‫‪ .2‬אם 𝑀 עצרה על 𝑥 ‪ -‬קבל‪.‬‬
‫‪ .3‬אם 𝑀 לא עצרה על 𝑥 ‪ -‬דחה‪.‬‬
‫נכונות הבניה‪:‬‬
‫● אם 𝑐𝐿 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 בצעד ה‪ 𝑈 ← 𝑐-‬קיבל ← )𝑈(𝐿 ∈> 𝑥 ‪.< 𝑀,‬‬
‫● אם 𝑐𝐿 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת על 𝑥 או 𝑀 עוצרת אחרי יותר מ‪ 𝑐-‬צעדים ← 𝑈 לא תזהה עצירה‬
‫ותדחה ← )𝑈(𝐿 ∉> 𝑥 ‪.< 𝑀,‬‬
‫הוכחנו כי )𝑈(𝐿 = 𝑐𝐿 וכן 𝑈 מכריעה את השפה 𝑐𝐿 ומכאן 𝑅 ∈ 𝑐𝐿 כנדרש‪.‬‬
‫∎‬
‫השפה 𝑃𝐻𝐵‬
‫נתונה השפה‪:‬‬
‫‪2‬‬
‫}𝑒𝑝𝑎𝑡 𝑠𝑡𝑖 𝑓𝑜 𝑙𝑙𝑒𝑐 ‪𝐵𝐻𝑃 = {< 𝑀, 𝑥 > | 𝑀 ℎ𝑎𝑙𝑡𝑠 𝑜𝑛 𝑥, 𝑎𝑛𝑑 𝑀 𝑑𝑜𝑒𝑠𝑛'𝑡 𝑒𝑛𝑡𝑒𝑟 𝑡ℎ𝑒 (|𝑥| + 1)'𝑡ℎ‬‬
‫‪2‬‬
‫במילים‪ :‬תוודא ש‪ 𝑀-‬מסמלצת על 𝑥 ועוצרת‪ .‬ובנוסף‪ 𝑀 ,‬לא תעבור את התא ה‪ (|𝑥| + 1)-‬בסרט שלה‪.‬‬
‫טענה‪.𝐵𝐻𝑃 ∈ 𝑅 :‬‬
‫‪2‬‬
‫מבוא להוכחה‪ :‬כדי להוכיח 𝑅 ∈ 𝑃𝐻𝐵‪ ,‬נשים לב שמותר למכונה להשתמש בלכל היותר |𝑥| תאי זיכרון‪.‬‬
‫● המכונה יכולה לא לעצור‪ .‬מהם כל האפשרויות עבור המכונה (עוצרת או לא) וכיצד ניתן לזהות אותם?‪:‬‬
‫‪ .1‬כאשר 𝑀 נכנסת לתא האסור (בין אם עוצרת או לא)‪.‬‬
‫‪ .2‬כאשר 𝑀 עוצרת מבלי להיכנס לתא האסור‪.‬‬
‫‪ .3‬כאשר 𝑀 נכנסת ללולאה אינסופית בתוך התאים המותרים‪.‬‬
‫● תזכורת‪ :‬קונפיגורציה היא תיאור המצב הכללי של המכונה בנקודה הספציפית )𝑖 ‪.𝑐 = (α, 𝑞,‬‬
‫כאשר ‪ α‬הוא תוכן הסרט‪ 𝑞 ,‬הוא המצב הנוכחי ו‪ 𝑖 -‬הוא המיקום (האינדקס) של הראש של הסרט‪.‬‬
‫‪2‬‬
‫במקרה שלנו‪ ,‬מכיוון שכמות התאים המותרים לשימוש מוגבלת ע"י |𝑥|‪ ,‬ניתן לחשב חסם עליון למספר‬
‫הקונפיגורציות השונות האפשריות‪.‬‬
‫● למה הקונפיגורציות האלה מעניינות אותנו?‪ :‬אנחנו רוצים לזהות את כל האפשרויות שהמכונה תבצע‬
‫בשביל שנוכל להכריע את השפה‪ ,‬אמרנו שאחד מהאפשרויות האלה היא כאשר 𝑀 נכנסת ללולאה‬
‫אינסופית בתוך התאים המותרים‪ .‬לכן כדי לזהות את המקרים שנכנס ללולאה אז אפשר להשתמש‬
‫בקונפיגורציות‪ .‬בהרצאה ‪ ,1‬הוכחנו עם עקרון שובך היונים שאם עברנו על כל הקונפיגורציות‬
‫האפשריות‪ ,‬אז הקונפיגורציה הבאה תסגור לנו מעגל כי נפגשנו בקונפיגורציה הזאת בעבר‪ .‬לכן‪,‬‬
‫נשתמש בשיטה הזאת כדי לזהות כאשר המכונה 𝑀 נכנסת ללולאה ואז נוכל לעצור‪.‬‬
‫‪2‬‬
‫● חסם לכמות הקונפיגורציות השונות האפשריות בתוך |𝑥| תאים‪ :‬נרצה לחשב את מספר כל‬
‫הקונפיגורציות האפשריות שלנו‪:‬‬
‫‪2‬‬
‫|𝑥|‬
‫|‪.#(α) ≤ |Γ‬‬ ‫○ מספר כל הקלטים האפשריים הוא‬
‫○ מספר כל הקבוצות האפשריות הוא |𝑄| ≤ )𝑞(‪.#‬‬
‫‪2‬‬
‫○ מספר כל התאים האפשריים על הסרט הוא |𝑥| ≤ )𝑖(‪.#‬‬
‫‪2‬‬
‫|𝑥|‬ ‫‪2‬‬
‫|‪.𝑇 = |Γ‬‬ ‫לכן החסם הכללי 𝑇 לכמות הקונפיגורציות השונות‪× |𝑄| × |𝑥| :‬‬
‫● אבחנה‪ :‬אם נריץ את המכונה ל‪ 𝑇 + 1-‬צעדים אז בהכרח קיימת קונפיגורציה שהמכונה ביקרה‬
‫פעמיים‪.‬‬
‫● אם המכונה הייתה באותה קונפיגורציה פעמיים‪ ,‬אפשר להסיק שהמסלול של המכונה מכיל מעגל‪ .‬נניח‬
‫שקיימים 𝑗 ‪ 𝑖,‬כך ש‪ .𝑐𝑖 = 𝑐𝑗 :‬לכן‪ ,‬קיום המעגל נובע מכך שפונקציית המעברים היא דטרמיניסטית‪.‬‬
‫אינטואיציה‪ :‬הצגנו במבוא להוכחה כי ניתן לזהות כל מקרה אפשרי של המכונה ולכן עבור כל זיהוי שכזה נוכל‬
‫להבטיח שהאלגוריתם תמיד יעצור וכך המכונה תכריע את השפה‪ .‬כלומר 𝑅 ∈ 𝑃𝐻𝐵‪.‬‬
‫אנחנו הצגנו במבוא ‪ 3‬אפשרויות וכעת נראה איך האלגוריתם בהוכחה נותנת עבורם מענה‪:‬‬
‫● כאשר 𝑀 נכנסת לתא האסור (בין אם עוצרת או לא) ‪ -‬אז נדחה בשלב (‪ )a‬באלגוריתם‪.‬‬
‫● כאשר 𝑀 עוצרת על 𝑥 מבלי להיכנס לתא האסור ‪ -‬אז נקבל בשלב (‪ )b‬באלגוריתם‪.‬‬
‫● כאשר 𝑀 נכנסת ללולאה אינסופית בתוך התאים המותרים ‪ -‬אז נדחה בשלב (‪ )3‬באלגוריתם‪.‬‬
‫הוכחה‪ :‬נוכיח כי 𝑅 ∈ 𝑃𝐻𝐵‪ .‬נתאר מכונה מכריעה‪:‬‬

‫𝑈 על קלט > 𝑥 ‪ < 𝑀,‬תפעל‪:‬‬
‫𝑇 צעדים‪( .‬בטוח נכנס ללולאה)‪.‬‬ ‫‪ .1‬תסמלץ את 𝑀 על הקלט 𝑥 למשך ‪+ 1‬‬
‫‪ .2‬בכל צעד‪:‬‬
‫‪2‬‬
‫‪ .a‬אם 𝑀 נכנסה לתא ה‪( |𝑥| + 1-‬התא האסור) ‪ -‬דחה‪.‬‬
‫‪ .b‬אם 𝑀 עצרה על 𝑥 ‪ -‬קבל‪.‬‬
‫‪ .3‬אם הסתיימו ‪ 𝑇 + 1‬צעדים ללא עצירה ‪ -‬דחה‪.‬‬
‫נוכיח את נכונות הבניה (צריך להוכיח כי )𝑈(𝐿 = 𝑃𝐻𝐵)‪:‬‬
‫‪2‬‬
‫● אם 𝑃𝐻𝐵 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 תוך לכל היותר 𝑇 צעדים וגם לא עוברת את התא ה‪|𝑥| -‬‬
‫← המכונה 𝑈 תקבל ← )𝑈(𝐿 ∈> 𝑥 ‪.< 𝑀,‬‬
‫● אם 𝑃𝐻𝐵 ∉> 𝑥 ‪← < 𝑀,‬‬
‫‪2‬‬
‫מקרה א'‪ 𝑀 :‬חורגת לתא ה‪ |𝑥| + 1-‬לפני הצעד ה‪.𝑇 + 1-‬‬ ‫↲‬
‫‪2‬‬
‫מקרה ב'‪ 𝑀 :‬נכנסת ללולאה בתוך ה‪ |𝑥| -‬התאים החוקיים ולכן 𝑀 יכולה לבצע יותר מ‪-‬‬ ‫↲‬
‫‪ 𝑇 + 1‬צעדים‪ .‬המכונה 𝑈 תסיים את ריצת כל ה‪ 𝑇 + 1-‬צעדים בלי לזהות עצירה‪.‬‬
‫← בשני המקרים 𝑈 תתדחה ← )𝑈(𝐿 ∉> 𝑥 ‪.< 𝑀,‬‬
‫הוכחנו ש‪ 𝐵𝐻𝑃 = 𝐿(𝑈) :‬ובנוסף הראנו שהמכונה 𝑈 היא מכונה מכריעה כי היא תמיד עוצרת ולכן 𝑅 ∈ 𝑃𝐻𝐵‬
‫∎‬
‫שאלה לתרגול‬
‫נתונה השפה }𝑙𝑙𝑒𝑐 ‪.𝐿 = {< 𝑀 > | 𝑤ℎ𝑒𝑛 𝑟𝑢𝑛𝑛𝑖𝑛𝑔 𝑜𝑛 𝑡ℎ𝑒 𝑖𝑛𝑝𝑢𝑡 ε, 𝑀 𝑑𝑜𝑒𝑠𝑛'𝑡 𝑒𝑛𝑡𝑒𝑟 𝑡ℎ𝑒 10'𝑡ℎ‬‬
‫הוכיחו כי 𝑅 ∈ 𝐿‪.‬‬
‫‪2‬‬
‫|𝑥|‬ ‫‪2‬‬
‫|‪.𝑇 = |Γ‬‬ ‫הוכחה‪ :‬נוכיח כי 𝑅 ∈ 𝐿‪ .‬החסם הכללי 𝑇 לכמות הקונפיגורציות השונות‪× |𝑄| × |𝑥| :‬‬
‫נתאר מכונה מכריעה‪:‬‬
‫𝑈 על קלט > 𝑀 < תבצע‪:‬‬
‫‪ .1‬תסמלץ את 𝑀 על ‪ ε‬למשך ‪ 𝑇 + 1‬צעדים‪.‬‬
‫‪ .2‬בכל צעד‪:‬‬
‫‪ .a‬אם 𝑀 נכנסה לתא ‪ - 10‬דחה‪.‬‬
‫‪ .b‬אם 𝑀 עצרה ‪ -‬קבל‪.‬‬

‫‪ .3‬אם 𝑀 לא עצרה אחרי ‪ 𝑇 + 1‬צעדים ‪ -‬קבל‪.‬‬
‫נוכיח את נכונות הבניה (צריך להוכיח כי )𝑈(𝐿 = 𝐿)‪:‬‬
‫● 𝐿 ∈> 𝑀 < ←‬
‫○ מקרה א'‪ 𝑀 :‬עצרה בתוך לכל היותר 𝑇 צעדים ולא עברה את התא ה‪.9-‬‬
‫○ מקרה ב'‪ 𝑀 :‬לא עצרה בתוך גם לאחר ‪ 𝑇 + 1‬צעדים ולא עברה את התא ה‪.9-‬‬
‫← ב‪ 2-‬המקרים 𝑈 מקבלת ← )𝑈(𝐿 ∈> 𝑀 <‪.‬‬
‫● 𝐿 ∉> 𝑀 < ← 𝑀 נכנסה לתא ה‪ ← 10-‬המכונה 𝑈 תדחה ← )𝑈(𝐿 ∉> 𝑀 <‪.‬‬
‫הוכחנו ש‪ 𝐿 = 𝐿(𝑈) :‬ובנוסף הראנו שהמכונה 𝑈 היא מכונה מכריעה כי היא תמיד עוצרת ולכן 𝑅 ∈ 𝐿‪.‬‬
‫∎‬
‫הערה לפתרון‪ :‬התרגיל הזה בוחן את הערנות שלנו‪ .‬נשים לב שלשפה הנתונה 𝐿 אין התייחסות בכלל לעצירה‪,‬‬
‫החסם היחידי הוא בנפח‪ ,‬כלומר בהגבלת השימוש של התאים של הסרט‪ .‬לכן‪ ,‬אנחנו נקבל בין אם 𝑀 עצרה בין‬
‫התאים ‪ 1-9‬או בין אם לא עצרה‪ .‬למה עדיין היה חשוב לנו להתייחס לעניין ה‪ ?𝑇 + 1-‬כי אנחנו רוצים להוכיח‬
‫שקיים מכונה שמכריעה את השפה‪ ,‬כדי שהמכונה תכריעה היא חייבת לזהות כל תרחיש אפשרי עבורה למשל‬
‫מתי היא עוצרת או לא וכו'‪...‬‬
‫מכונות טיורינג אי‪-‬דטרמיניסטיות‬

‫מבוא‬
‫● כל אלגוריתם ניתן לתיאור על ידי מודל מתמטי מופשט‬
‫המכונה מכונת טיורינג‪.‬‬
‫● מכונת טיורינג הסטנדרטית (דטרמיניסטית) היא‬
‫מכונת מצבים מוגדרת היטב‪ ,‬כלומר לכל מצב של‬
‫המכונה ברור באופן מוחלט מה יהיה הצעד הבא של‬
‫המכונה‪.‬‬
‫● מכונת טיורינג לא‪-‬דטרמיניסטית היא הרחבה של‬
‫המודל הסטנדרטי‪ ,‬בה הצעד הבא של המכונה הוא מצב‬
‫מסוים מתוך קבוצה של מצבים אפשריים‪ ,‬הנבחר בצורה "שרירותית"‪.‬‬
‫● מכונה אי‪-‬דטרמיניסטית היא בעיקר כלי חשיבתי‪ ,‬שאינו ניתן למימוש בפועל‪.‬‬
‫● לא ברור האם למכונות אי‪-‬דטרמיניסטיות יש "יעילות חישוב" יותר טובה מאשר מכונות דטרמיניסטיות‪.‬‬
‫● השאלה האם מכונות אי‪-‬דטרמיניסטיות מחשבות בעיות "יותר מהר" היא שאלה פתוחה חשובה במדעי‬
‫המחשב ומכונה בעיית ‪.P=NP‬‬
‫דוגמה פרקטית לשימוש במ"ט אי‪-‬דטרמיניסטית‪ :‬נביט לדוגמה על מכונה א"ד למציאת מעגל בגרף‪.‬‬
‫● בהינתן גרף מכוון‪ ,‬מעגל הוא מסלול לא‪-‬ריק אשר מתחיל ומסתיים באותו צומת‪.‬‬
‫● אלגוריתם 𝑁 לא‪-‬דטרמיניסטי לדוגמה‪ ,‬יקבל כקלט את הגרף 𝐺‪" ,‬ינחש" צומת מוצא 𝑠𝑞‪ ,‬ובכל צעד‬
‫"ינחש" את הצומת הבא במעגל‪ .‬אם המכונה חזרה לצומת ממנו התחילה‪ ,‬היא מסיימת במצב מקבל‪.‬‬
‫● אם קיים מעגל‪ ,‬הרי שמכונה שתנחש צומת שנמצא על המעגל‪ ,‬ובכל צעד תנחש את הצומת הבא‬
‫במסלול המעגלי‪ ,‬תגיע בסופו של דבר אל צומת המוצא 𝑠𝑞‪ ,‬ותסיים במצב מקבל‪.‬‬
‫● לכן קלט 𝐺 כנ"ל מוגדר כקלט שהתקבל על ידי המכונה‪ ,‬כלומר‪ ,‬יש בו מעגל (יש לשים לב‪ ,‬ששאר‬
‫הניחושים חסרי משמעות‪ ,‬מכיוון שנדרש שיהיה קיים חישוב אחד שיסיים במצב מקבל)‪.‬‬
‫● מצד שני‪ ,‬אם אין בגרף הקלט 𝐺 מעגל‪ ,‬אף ניחוש לא יכול להחזיר אותנו אל צומת המוצא 𝑠𝑞‪ .‬כלומר כל‬
‫החישובים לא יסתיימו במצב מקבל‪ ,‬והגרף מוגדר כקלט שנדחה על ידי המכונה‪ ,‬כלומר שאין בו מעגל‪.‬‬
‫מכונות לא דטרמיניסטיות‬
‫למדנו בקורס "אוטומטים" על מודלים לא דטרמיניסטים‪:‬‬
‫● אוטומט סופי לא דטרמיניסטי )𝐴𝐹𝑁( שקול בכוחו לאוטומט סופי דטרמיניסטי )𝐴𝐹𝐷(‪.‬‬
‫● אוטומט מחסנית לא דטרמיניסטי חזק יותר מאוטומט מחסנית דטרמיניסטי‪.‬‬
‫פונקצית המעברים של מכונת טיורינג אי‪-‬דטרמיניסטית‬

‫במצב נתון בו מכונה נמצאת במצב 𝑞 והראש הקורא‪-‬כותב שלה קורא את הסמל 𝑎‪ ,‬אז היא יכולה לבצע אחד‬
‫מכמה צעדים אפשריים‪ .‬הפונקציה מוגדרת בצורה הבאה‪:‬‬
‫)}𝑅 ‪δ: 𝑄' × Γ → 𝑃(𝑄 × Γ × {𝐿, 𝑆,‬‬
‫● הקבוצה 𝐹\𝑄 = '𝑄 כלומר היא קבוצת מצבים לא סופיים‪.‬‬
‫● קלט‪ :‬מצב לא סופי '𝑄 ∈ 𝑞 ואות ‪σ ∈ Γ‬‬
‫● פלט‪ :‬ומחזירה לנו שלשה של מצב 𝑄 ∈ 𝑝‪ ,‬אות ‪ β ∈ Γ‬ותזוזה }𝑅 ‪ 𝑑 ∈ {𝐿, 𝑆,‬כלומר )𝑑 ‪ .(𝑝, β,‬אבל‬
‫עבור אותו הקלט היא יכולה להחזיר כמה שלשות שונות (לפי ניחוש בבחירה שרירותית)‪.‬‬
‫● לפי ההגדרה הפורמלית‪ ,‬אפשרית גם קבוצה ריקה של צעדים אפשריים‪ ,‬אבל אנחנו נניח שתמיד יש‬
‫לפחות צעד אפשרי אחד‪.‬‬
‫שפה של מכונת טיורינג אי‪-‬דטרמיניסטית‬

‫נאמר שמכונת טיורינג אי‪-‬דטרמיניסטית 𝑁 מקבלת מילה 𝑥 אם בריצה של 𝑁 על 𝑥 קיימת סדרת צעדים חוקית‬
‫המסתיימת במצב 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪.‬‬
‫השפה של מ"ט 𝑁 לא דטרמיניסטית מוגדרת בדומה לשפה של מ"ט דטרמיניסטית‪:‬‬
‫⋆‬
‫{‬
‫𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑁 | ‪𝐿(𝑁) = 𝑥 ∈ Σ‬‬ ‫}‬
‫● במכונה דטרמיניסטית‪ ,‬אמרנו שכל הרצה של המכונה על קלט מסוים היא בעצם סדרה של‬
‫קונפיגורציות עוקבות‪ ,‬כלומר ‪ -‬מסלול חישוב‪.‬‬
‫● בדומה‪ ,‬במכונה אי‪-‬דטרמיניסטית‪ ,‬כל הרצה של מכונה על קלט מסוים נותנת עץ חישוב‪ .‬כאשר‬
‫ההרצה הספציפית היא בחירה שרירותית של מסלול יחיד בעץ החישוב‪.‬‬
‫● העץ המתקבל במ"ט א"ד הוא עץ בינארי (לא בהכרח מלא)‪.‬‬
‫תזכורת חשובה ‪ -‬הכוח של מודלים לא דטרמיניסטים נובע מן ההגדרה שמילה מתקבלת אם יש לה מסלול‬
‫חישוב מקבל אחד לפחות (מסלול חישוב שמסתיים במצב המקבל)‪ .‬זה תקף גם אם מסלולי חישוב רבים לא‬
‫מסתיימים במצב מקבל‪( .‬ייתכן אינסוף מסלולי חישוב כאלה)‪.‬‬
‫שאלה לדיון‪ :‬מתי מילה לא מתקבלת ע"י מכונה לא דטרמיניסטית?‬

‫תשובה‪ :‬אם לא קיים אף מסלול בעץ החישוב שיקבל את המילה‪.‬‬
‫מסלול חישוב לעומת עץ חישוב‬

‫מסלול חישוב‬ ‫עץ חישוב‬
‫חישוב של מ"ט דטרמיניסטית‪ :‬אפשר להסתכל על‬ ‫חישוב של מ"ט לא דטרמיניסטית‪ :‬אפשר להסתכל‬
‫החישוב כעל מסלול במרחב הקונפיגורציות‪:‬‬ ‫על החישוב כעל עץ במרחב הקונפיגורציות‪:‬‬
‫‪ .1‬מתחילים בקונפיגורציה ההתחלתית‪.‬‬ ‫‪ .1‬מתחילים בקונפיגורציה ההתחלתית‪.‬‬
‫‪ .2‬לכל קונפיגורציה יש קונפיגורציה עוקבת אחת‬ ‫‪ .2‬לכל קונפיגורציה יכולות להיות כמה‬
‫לכל היותר‪.‬‬ ‫קונפיגורציה עוקבות‪.‬‬
‫אי‪-‬סימטריה של מכונות לא דטרמיניסטיות‬

‫אבחנה חשובה‪ :‬אם הרצנו מכונה אי‪-‬דטרמיניסטית על קלט 𝑥‪ ,‬יש כמה אפשרויות‪:‬‬
‫‪ .1‬המכונה קיבלה ‪( -‬עצרה ב‪ )𝑞𝑎𝑐𝑐𝑒𝑝𝑡-‬ואפשר להסיק ש‪ 𝑥-‬שייך לשפת המכונה‪.‬‬
‫אינטואיציה‪ :‬בביטוי בוליאני )?( ∨ )?( ∨ )𝑇( = 𝐵 אז מספיק ונפגשנו ב‪ 𝑇-‬בהתחלה כדי לקבל‪.‬‬
‫‪ .2‬המכונה דחתה ‪ -‬ואי אפשר לדעת אם 𝑥 שייך לשפה או לא כי יכול להיות שקיים מסלול אחר שהמכונה‬
‫𝑞 ולקבל‪( .‬בהמשך נראה שצריך הרצה מבוקרת למקרים כאלה)‪.‬‬ ‫כן יכולה לעצור בו ב‪-‬‬
‫𝑡𝑝𝑒𝑐𝑐𝑎‬
‫אינטואיציה‪ :‬בביטוי בוליאני )?( ∨ )?( ∨ )𝐹( = 𝐵 לא מספיק להיפגש ב‪ 𝐹-‬ראשון‪ ,‬צריך הכל 𝐹‪.‬‬
‫‪ .3‬המכונה נכנסה ללולאה ‪ -‬אי אפשר לדעת כלום…‬
‫דוגמה ‪1‬‬
‫הגדרה‪ :‬מעגל המילטוני הוא מסלול בגרף העובר בכל צומת פעם אחת פרט לצומת שממנו יצא‪.‬‬
‫תרגיל‪ :‬בנו מ"ט א"ד המקבלת כל גרף המכיל מעגל המילטון והוכיחו נכונות‪.‬‬
‫אינטואיציה‪ :‬אנחנו רוצים מ"ט שמקבלת קידוד של גרף‪ .‬אם יהיה בגרף הזה מעגל המילטוני אז נדע לזהות‬
‫ולקבל ואם אין אז נדחה בכל המסלולים‪.‬‬
‫● אם בגרף יש מסלול המילטון‪ ,‬אז לכל פרמוטציה מתוך !𝑛 אם יש סידור כלשהו שיהווה מעגל המילטוני‪,‬‬
‫אז נכנס למסלול הזה‪ ,‬נראה שכל הצלעות קיימות לפי ההגדרה של המעגל ונעבור למצב מקבל‪.‬‬
‫● מצד שני‪ ,‬אם אין מסלול המילטוני אז כל פרמוטציה לא תהווה לנו מעגל המילטוני בגרף ולכן נדחה לכל‬
‫מסלול‪.‬‬
‫● בתרגילים כאלה‪ ,‬כשנרצה קיימות של תכונה בגרף‪ ,‬אז ננחש סידור כלשהו של הגרף מתוך כל ה‪|𝑉|!-‬‬
‫פרמוטציות ואז נבדוק אם הסידור הזה עונה על הדרישות של התכונה‪.‬‬
‫פתרון‪ 𝑀 :‬על )> 𝐺 <(‪:‬‬

‫‪ .1‬נחש סידור של קודקודי 𝐺 מהצורה )𝑛𝑣 ‪.(𝑣1,...,‬‬
‫‪ .2‬בדוק לכל ]‪ 𝑖 ∈ [1, 𝑛 − 1‬שהצלע )𝐺(𝐸 ∈ )‪ (𝑣𝑖, 𝑣𝑖+1‬וגם שהצלע )𝐺(𝐸 ∈ )𝑛𝑣 ‪.(𝑣1,‬‬
‫‪ .3‬אם חסרה צלע ‪ -‬דחה‪.‬‬
‫‪ .4‬אחרת ‪ -‬קבל‪.‬‬
‫𝑖𝑢 ← באחת מהרצות המכונה ננחש את‬ ‫אם 𝐿 ∈> 𝐺 < ← ב‪ 𝐺-‬יש מעגל המילטוני מהסידור‪{ }𝑛𝑖=1:‬‬ ‫●‬
‫הפרמוטציה הנכונה ← כל הצלעות קיימות ← ‪.< 𝐺 >∈ 𝐿(𝑀) ← 𝑀(𝐺) = 1‬‬

‫● אם 𝐿 ∉> 𝐺 < ← ב‪ 𝐺-‬לא קיים אף סידור שיקיים מסלול המילטוני ← לכל ניחוש יהיה לפחות צלע‬
‫אחת חסרה ← 𝑀 ידחה לכל ריצה או לא תחזיר כלום (לא יעצור) ← )𝑀(𝐿 ∉> 𝐺 <‪.‬‬
‫הערה‪ :‬הרעיון באי‪-‬דטרמיניזם זה לא לעבור על כל הפרמוטציות עד שנתפוס אחד שתקבל בשפה אלא אנחנו‬
‫ננחש שרירותית רק פרמוטציה אחת בלבד (לא רצים במקביל על כמה פרמוטציות)‪ ,‬והפרמוטציה הזאת תקבע‬
‫לנו לפי הניחוש אם קיים מעגל או לא‪ .‬כלומר‪ ,‬בשלב (‪ )1‬באלגוריתם שהצגנו אנחנו מנחשים ניחוש אחד בלבד!‬
‫דוגמה ‪2‬‬
‫⋆‬
‫כדוגמה פשוטה‪ ,‬נסתכל על השפה‪.𝐿 = {𝑤 ∈ {0, 1} | 𝑤 𝑠𝑡𝑎𝑟𝑡𝑠 𝑎𝑛𝑑 𝑒𝑛𝑑𝑠 𝑖𝑛 𝑡ℎ𝑒 𝑠𝑎𝑚𝑒 𝑏𝑖𝑡} :‬‬
‫במודל הדטרמיניסטי‪ ,‬המילים 𝐿 ∈ ‪ 1001‬וגם 𝐿 ∉ ‪ .1000‬כנ"ל במודל האי‪-‬דטרמיניסטי‪.‬‬
‫אבל‪ ,‬כדי לגלות כי 𝐿 ∉ ‪ ,1000‬נצטרך לנסות את כל מסלולי החישוב האפשריים של המכונה‪ ,‬ורק כשכולם‬
‫דוחים אז נוכל לדעת כי 𝐿 ∉ ‪.1000‬‬
‫‪2‬‬
‫‪ .1‬מודל שקול למ"ט א"ד הוא אי‪-‬דטרמיניזם מוגבל‪.δ: 𝑄' × Γ → (𝑄 × Γ × {𝐿, 𝑆, 𝑅}) :‬‬
‫‪ .2‬נוח לחשוב על עץ ההרצות הזה בתור עץ בינארי‪.‬‬
‫‪ .3‬שימו לב‪ ,‬שכאשר מריצים מכונה בהרצה בודדת‪ ,‬המכונה רצה על מסלול חישוב יחיד המוגדר לפי‬
‫הבחירות שלה בכל הצמתים‪ .‬היא לא רצה במקביל בכל העץ!‪.‬‬
‫קבלת שפות ע"י מכונה לא דטרמיניסטית‬

‫הגדרה‪ :‬מכונת טיורינג אי‪-‬דטרמיניסטית 𝑁 מקבלת שפה 𝐿 אם‪:‬‬
‫‪ .1‬לכל 𝐿 ∈ 𝑥 קיים מסלול מקבל בעץ החישוב של 𝑁 על 𝑥‪.‬‬
‫𝑥 לא קיים מסלול מקבל בעץ החישוב של 𝑁 על 𝑥‪( .‬יכולים להיות מסלולים אינסופיים)‪.‬‬ ‫‪ .2‬לכל 𝐿 ∉‬
‫מבנה הוכחה‪:‬‬
‫● אם 𝐿 ∈ 𝑥 ‪ -‬קיים מסלול מקבל בעץ החישוב של המכונה 𝑁 על הקלט 𝑥‪.‬‬
‫● אם 𝐿 ∉ 𝑥 ‪ -‬כל מסלולי החישוב בעץ החישוב של המכונה 𝑁 על הקלט 𝑥 דוחים או אינסופיים‪.‬‬
‫אם )𝑁(𝐿 ∉ 𝑥 אז כל מסלול לא מקבל‬ ‫אם )𝑁(𝐿 ∈ 𝑥 אז קיים מסלול מקבל בעץ‬
‫הכרעת שפות ע"י מכונה לא דטרמיניסטית‬

‫הגדרה‪ :‬מכונת טיורינג אי‪-‬דטרמיניסטית 𝑁 מכריעה שפה 𝐿 אם‪:‬‬
‫‪ .1‬לכל 𝐿 ∈ 𝑥 קיים מסלול מקבל בעץ החישוב של 𝑁 על 𝑥‪.‬‬
‫‪ .2‬לכל 𝐿 ∉ 𝑥 לא קיים מסלול מקבל בעץ החישוב של 𝑁 על 𝑥 (כל המסלולים דוחים)‪.‬‬
‫⋆‬
‫‪ .3‬כל המסלולים סופיים בעץ החישוב של 𝑁‪ ,‬וזה נכון לכל קלט ‪.𝑥 ∈ Σ‬‬
‫מבנה הוכחה‪:‬‬
‫● אם 𝐿 ∈ 𝑥 ‪ -‬כל המסלולים סופיים וקיים לפחות מסלול אחד מקבל‪.‬‬
‫● אם 𝐿 ∉ 𝑥 ‪ -‬כל המסלולים סופיים וכל המסלולים דוחים‪.‬‬
‫אם )𝑁(𝐿 ∉ 𝑥 אז כל מסלול דוחה‬ ‫אם )𝑁(𝐿 ∈ 𝑥 אז קיים מסלול מקבל בעץ‬
‫דוגמה לקבלת שפה‬

‫עבור מ"ט א"ד 𝑀 ומילה 𝑥 נגדיר‪:‬‬
‫}𝑥 𝑛𝑜 𝑔𝑛𝑖𝑛𝑛𝑢𝑟 𝑛𝑒‪𝐿4 = {(𝑀, 𝑥) | 𝑀 ℎ𝑎𝑠 𝑎𝑡 𝑙𝑒𝑎𝑠𝑡 4 𝑑𝑖𝑓𝑓𝑒𝑟𝑒𝑛𝑡 𝑎𝑐𝑐𝑒𝑝𝑡𝑖𝑛𝑔 𝑝𝑎𝑡ℎ𝑠 𝑤ℎ‬‬
‫בנו מ"ט 𝑈 שתקבל את ‪.𝐿4‬‬
‫𝑈 על קלט )𝑥 ‪ (< 𝑀 >,‬תבצע‪:‬‬
‫‪ .1‬נחש ‪ 4‬מחרוזות אקראיות‪.‬‬
‫‪ .2‬וודא שהן שונות זו מזו‪.‬‬
‫‪ .3‬סמלץ את 𝑀 על 𝑥 בהרצה מבוקרת לפי המחרוזות האקראיות‪.‬‬
‫‪ .4‬אם ב‪ 4-‬הדרכים המילה התקבלה ‪ -‬קבל‪.‬‬
‫הסבר‪ :‬נבחר ‪ 4‬מחרוזות אקראיות ושונות זו מזו‪.‬‬

‫כל מחרוזת כזו תתאר לנו מסלול בעץ‪.‬‬
‫נשים לב שכל מחרוזת היא סופית ולכן אין לנו בכלל‬
‫התייחסות למסלולים אינסופיים‪ ,‬לכן מספיק לנו רק‬
‫להתייחס למקרים סופיים ‪ -‬מקבל או דוחה‪.‬‬
‫אנחנו נעבור על רביעיות של מחרוזות עד שנמצא ‪4‬‬
‫מחרוזות כך שכל אחת מהן מגיעה למצב מקבל עם 𝑥‪.‬‬
‫הערה‪ :‬הקלט 𝑥 לא מתאר לנו מסלול בעץ!‬
‫משפט שקילות‬
‫משפט‪ :‬מכונת טיורינג לא דטרמיניסטית שקולה בכוח החישוב שלה למכונה דטרמיניסטית‪.‬‬
‫● כיוון א'‪ :‬פשוט ‪ -‬מכונה דטרמיניסטית 𝐷 היא מקרה פרטי של‬
‫מכונה לא דטרמיניסטית 𝑁‪( .‬כל האפשרויות הנוספות ‪-‬‬
‫זהות לאפשרות המקורית)‪.‬‬
‫● כיוון ב'‪ :‬נסביר כיצד אפשר לבנות‪ ,‬לכל מכונה לא‬
‫דטרמיניסטית 𝑁‪ ,‬מכונה דטרמיניסטית 𝐷 שתהיה שקולה ל‪-‬‬
‫𝑁‪ .‬כלומר 𝐷 תבצע סימולציה ותעקוב אחרי כל מסלולי החישוב של המכונה 𝑁‪.‬‬
‫הרעיון של כיוון ב'‪:‬‬
‫○ 𝐷 תנסה את כל ענפי החישוב של 𝑁 על מילת הקלט 𝑤‪.‬‬
‫○ אם נמצא מסלול חישוב שמסתיים במצב המקבל (של 𝑁) אז 𝐷 תקבל (מצב מקבל שלה)‪.‬‬
‫○ אם כל מסלולי החישוב של 𝑁 מסתיימים במצב הדוחה (של 𝑁) אז 𝐷 תדחה (מצב דוחה שלה)‪.‬‬
‫○ אם יש ל‪ 𝑁-‬מסלולי חישוב לא עוצרים (אינסופיים) ואין לה מסלול חישוב מקבל ‪ 𝐷 -‬לא תעצור‪.‬‬
‫● בהמשך הפרק נציג את השלבים כיצד להוכיח את כיוון ב'‪.‬‬
‫חיפוש לרוחב ולא לעומק‬

‫חישוב של 𝑁 על 𝑤 הוא עץ במרחב הקונפיגורציות‪.‬‬
‫● כל צומת בעץ הזה הוא קונפיגורציה‪.‬‬
‫● שורש העץ הוא הקונפיגורציה ההתחלתית ‪ 𝑐0‬של 𝑁 על 𝑤‪.‬‬
‫● כל ענף בעץ הזה הוא חישוב חלקי אפשרי של 𝑁 על 𝑤‪.‬‬
‫הערה ‪ -‬בחיפוש לעומק אנחנו עלולים לסרוק לעומק למסלול אינסופי‪.‬‬
‫תרגיל‪ :‬הסבירו למה המכונה הדטרמיניסטית 𝐷 לא תנסה לבצע חיפוש לעומק בעץ הקונפיגורציות?‬
‫פתרון‪ :‬מיד נראה שחיפוש לרוחב 𝑆𝐹𝐵 בעץ‬
‫הזה כן יהיה טוב‪ .‬באופן אינטואיטיבי‪ ,‬אם‬
‫נסתכל על הציור משמאל עבור 𝑆𝐹𝐵‪ ,‬אפשר‬
‫לשער שצריך לעבור על כל קונפיגורציה‬
‫אפשרית בכל רמה ולהחליט מי מביניהם יכול‬
‫להתאים‪.‬‬
‫המכונה הדטרמיניסטית‬
‫למכונה 𝐷 יהיו שלושה סרטים‪.‬‬
‫‪ .1‬סרט הקלט ‪ -‬שעליו רשומה מילת הקלט‪ .‬זהו סרט לקריאה בלבד (לא משנים בו דבר)‪.‬‬
‫‪ .2‬סרט הסימולציה ‪ -‬לחיקוי מסלול חישוב חלקי של 𝑁‪ .‬נעדכן בו את הקונפיגורציות‪.‬‬
‫‪ .3‬סרט הכתובות ‪ -‬שיציין את מסלול הבחירות הלא דטרמיניסטיות של החישוב החלקי הנוכחי‪.‬‬
‫סרט הכתובות‬
‫לכל צומת פנימית 𝑖𝑐 (לכל קונפיגורציה) בעץ החישוב יש לכל‬
‫⋆‬
‫היותר ‪ 2‬בנים‪ ,‬לכן מילה }‪ 𝑤 ∈ {0, 1‬יכולה לציין מסלול‬
‫חישוב חלקי מהשורש עד הצומת 𝑖𝑐 בעץ‪ .‬לכן‪ ,‬המילה 𝑤 היא‬
‫הכתובת של הצומת בעץ‪ .‬לדוגמה בציור משמאל המחרוזת‬
‫‪ 𝑤 = 011‬תביא אותנו מהשורש אל צומת פנימית‪.‬‬
‫כתובות לא חוקיות‪ :‬מאחר ולקונפיגורציה ההתחלתית ‪ 𝑐0‬יש רק שתי קונפיגורציות עוקבות (כי לשורש העץ יש‬
‫שני בנים)‪ ,‬אז כל כתובת שמתחילה ב‪ 2-‬ומעלה איננה חוקית‪ .‬כלומר אם אמרנו שהמחרוזות מורכבות מ‪-‬‬
‫⋆‬
‫}‪ 𝑤 ∈ {0, 1‬אז לא יכול להיות לנו מחרוזת למשל מהצורה ‪.𝑤 = 0112230110‬‬
‫פתרון‪ :‬המכונה 𝐷 תתייחס לכתובת לא חוקית כאל ענף חישוב שהסתיים בדחייה‪.‬‬
‫הסימולציה של ‪D‬‬
‫תזכורת‪ :‬אנחנו צריכים להוכיח את כיוון ב' ‪ -‬לכל מכונה לא דטרמיניסטית 𝑁 נבנה מכונה דטרמיניסטית 𝐷‬
‫ששקולה ל‪.𝑁-‬‬
‫אתחול‪ :‬בתחילת הריצה של 𝐷‪.‬‬
‫‪ .1‬מילת הקלט רשומה על סרט ‪ 1‬שהוא סרט הקלט‪.‬‬
‫‪ .2‬סרט הסימולציה (סרט ‪ )2‬וסרט הכתובות (סרט ‪ )3‬ריקים (יש ‾𝑏 בכל התאים בסרטים האלה)‪.‬‬
‫שלב בסימולציה‪:‬‬
‫‪ .1‬מעתיקים את תוכן סרט ‪( 1‬הקלט) לסרט ‪.2‬‬
‫‪ .2‬מבצעים את הצעדים של 𝑁 על סרט ‪ 2‬לפי הבחירות הלא דטרמיניסטיות הרשומות בסרט ‪( 3‬לפי‬
‫הכתובות)‪( .‬כלומר מעדכנים את הקונפיגורציות לרוחב על סרט ‪.)2‬‬
‫‪ .3‬אם 𝑁 הגיעה למצב המקבל שלה‪ ,‬מקבלים‪ .‬כלומר 𝐷 נכנסת למצב המקבל שלה‪ ,‬והחישוב מסתיים‪.‬‬
‫‪ .4‬אחרת‪ ,‬עוברים לבצע סימולציה של ענף החישוב הבא‪.‬‬
‫הסברים‪:‬‬
‫● מה פירוש "אחרת"? מה יכול לקרות?‪:‬‬
‫○ יכול לקרות ש‪ 𝐷-‬סיימה לבצע את הצעדים שהיו רשומים בכתובות ולא הגיעה למצב עצירה‪.‬‬
‫○ ייתכן כי 𝑁 נכנסה למצב הדוחה שלה באיזשהו צעד בענף החישוב הנוכחי‪.‬‬
‫ייתכן שהכתובת בסרט השלישי לא חוקית (למשל מכילה '‪ '3‬אבל המחרוזת צריכה להיות בינארית)‪.‬‬ ‫○‬
‫● איך עוברים לענף החישוב הבא?‪:‬‬
‫○ מוחקים את תוכן סרט הסימולציה‪.‬‬
‫○ עוברים לכתובת הבאה בסרט הכתובות‪.‬‬
‫○ מתחילים את הסימולציה של ענף החישוב הבא‪.‬‬
‫סיכום הוכחת כיוון ב' של השקילות שעשינו‬

‫● אם )𝑁(𝐿 ∈ 𝑥 🠈 קיים לפחות מסלול אחד מקבל בעץ החישוב של 𝑁 על 𝑥 🠈 ‪ 🠈𝑁(𝑥) = 1‬בזמן‬
‫סופי‪ 𝐷 ,‬תסרוק את העץ עד לרמת הקונפיגורציה המקבלת 🠈 בזמן סופי‪ ,‬הגיעה לקונפיגורציה מקבלת‬
‫ותקבל 🠈 ‪ 𝐷(𝑥) = 1‬כלומר )𝐷(𝐿 ∈ 𝑥‪.‬‬
‫● אם )𝑁(𝐿 ∉ 𝑥 🠈 כל המסלולים דוחים או אינסופיים 🠈 מקרה א'‪ :‬אם כל המסלולים דוחים אז בשלב‬
‫מסויים נסיים לסרוק את העץ‪ ,‬לא נגיע למצב מקבל ולכן נדחה‪ .‬מקרה ב'‪ :‬אם יש מסלול אחד אינסופי‬
‫והיתר דוחים אז נמשיך לרוץ על המסלול האינסופי ולא נקבל דבר‪ 🠈 .‬בשני המקרים )𝐷(𝐿 ∉ 𝑥‪.‬‬
‫מסקנה מן השקילות‬
‫‪ .1‬כדי להוכיח ש‪ 𝐿 ∈ 𝑅𝐸 :‬אפשר לתאר מכונה לא דטרמיניסטית שמקבלת את 𝐿‪.‬‬
‫משום שלכל מכונה כזו אפשר לבנות מכונה דטרמיניסטית שתקבל את 𝐿‪.‬‬
‫‪ .2‬כדי להוכיח ש‪ 𝐿 ∈ 𝑅 :‬אפשר לתאר מכונה לא דטרמיניסטית שמכריעה את 𝐿‪.‬‬
‫עץ החישוב במקרה זה יהיה סופי לכל קלט‪.‬‬
‫הערה על זמן הריצה‪:‬‬

‫המכונה 𝐷 שתיארנו לא יעילה מבחינת זמן הריצה כי יש בה חזרות על חלקים של חישובים‪.‬‬
‫אפשר לייעל את פעולתה של 𝐷‪ ,‬אך עדיין זמן הריצה של כל סימולציה מוכרת של מכונה לא דטרמיניסטית ע"י‬
‫מכונה דטרמיניסטית הוא לפחות מעריכי (אקספוננציאלי) בזמן הריצה של המכונה הלא דטרמיניסטית‪.‬‬
‫כלומר‪ ,‬תהליך הסימלוץ של 𝐷 על 𝑁 הוא יקר בזמן הריצה‪ ,‬כלומר הוא לפחות בזמן אקספוננציאלי‪.‬‬
‫מכונה דטרמיניסטית מכריעה ‪ -‬זמן הריצה הוא מספר הקונפיגורציות בסדרה עד לקונפיגורציה הסופית‪.‬‬
‫מכונה לא דטרמיניסטית מכריעה ‪ -‬זמן הריצה של 𝑁 על מילה 𝑥 מוגדר כמספר הצעדים במסלול החישוב‬
‫הארוך ביותר בעץ עבור 𝑁 על 𝑥‪.‬‬
‫שימושי המודל הלא דטרמיניסטי‬

‫למה בכלל שנרצה להשתמש במודל לא דטרמיניסטי? הרי הוא לא מציאותי ולא שימושי וגם מספר המסלולים‬
‫הדוחים יכול להיות גדול‪ .‬אחד היתרונות לשימוש במודל א"ד הוא היכולת לנחש מחרוזות וככה לחסוך בהרצה‬
‫מבוקרת‪ .‬אפשר לנחש בנוסף מסלול ריצה‪.‬‬
‫לדוגמה‪ :‬נתונה השפה }∅ ≠ )𝑀(𝐿 ‪.𝐿 = {< 𝑀 > :‬‬
‫● במודל הדטרמיניסטי היינו צריכים לעשות הרצה מבוקרת חזקה‪ ,‬כלומר לעבור על כל המילים ולהבטיח‬
‫שקיימת מילה שמתקבלת בשפה‪.‬‬
‫● במודל הלא דטרמיניסטי אפשר לנחש מילה 𝑥‪ ,‬לסמלץ אותה על 𝑀‪ ,‬אם היא התקבלה אז תקבל‬
‫ואחרת תדחה‪ .‬לכן אם קיים מסלול בעץ החישוב שיקבל את המילה 𝑥 אז שפת המכונה לא ריקה‪.‬‬
‫דוגמה ‪ - 1‬לשימוש במכונה לא דטרמיניסטית‬

‫⋆‬
‫הקדמה‪ :‬פונקציה של מ"ט 𝑀 היא 𝑀𝑓‪ .‬נתונה השפה‪.𝐿 = {< 𝑀 > : ∃𝑥 ∈ Σ , 𝑓𝑀(𝑥) = 𝑥} :‬‬
‫כלומר שקיימת לפונקציה של המכונה נקודת שבת‪ .‬אנחנו רוצים ליצור מכונה א"ד לשפה הזאת‪.‬‬
‫● כדי להוכיח 𝐸𝑅 ∈ 𝐿 במודל הדטרמיניסטי היינו צריכים לבצע הרצה מבוקרת חזקה של כל המילים‬
‫בסיגמא כוכבית‪.‬‬
‫● לעומת זאת‪ ,‬בעזרת ניחוש‪ ,‬אפשר לחסוך את ההרצה המבוקרת החזקה הזאת‪.‬‬
‫⋆‬
‫כלומר‪ ,‬אנחנו נרצה לנחש ‪ 𝑥 ∈ Σ‬שעבורו נפעיל את 𝑀 ונקבל בהתאם לפלט של 𝑀‪.‬‬
‫הוכחה‪ :‬נרצה להוכיח כי 𝐸𝑅 ∈ 𝐿 ולכן נבנה מכונת טיורינג לא דטרמיניסטית 𝑁 המקבלת את 𝐿‪:‬‬
‫המכונה 𝑁 על הקלט > 𝑀 < תבצע‪:‬‬
‫⋆‬
‫‪ .1‬נחש מילה }‪𝑥 ∈ {0, 1‬‬
‫‪ .2‬סמלץ את 𝑀 על 𝑥‪:‬‬
‫‪ .a‬אם 𝑥 = )𝑥(𝑀𝑓 אז קבל‪.‬‬
‫‪ .b‬אם 𝑥 ≠ )𝑥(𝑀𝑓 אז דחה‪.‬‬
‫נוכיח את נכונות המכונה 𝑁‪ ,‬כלומר נוכיח כי 𝐿 = )𝑁(𝐿‪:‬‬
‫⋆‬
‫● אם 𝐿 ∈> 𝑀 < ← אז קיים (לפי ניחוש שרירותי) מילה }‪ 𝑥 ∈ {0, 1‬כך ש‪ ← .𝑓𝑀(𝑥) = 𝑥 :‬בעץ‬
‫החישוב בהפעלת המכונה 𝑁 על הקלט > 𝑀 < קיים מסלול שבו הניחוש של 𝑁 הוא בדיוק 𝑥 ←‬
‫המסלול המדובר הוא מסלול מקבל ← )𝑁(𝐿 ∈> 𝑀 <‪.‬‬
‫⋆‬
‫● אם 𝐿 ∉> 𝑀 < ← אז לכל }‪ 𝑥 ∈ {0, 1‬מתקיים 𝑥 ≠ )𝑥(𝑀𝑓 ← בעץ החישוב בהפעלת המכונה 𝑁‬
‫⋆‬
‫על הקלט > 𝑀 < לכל }‪ 𝑥 ∈ {0, 1‬לא קיים מסלול שבו הניחוש של 𝑁 הוא בדיוק 𝑥 ← כל‬
‫המסלולים של 𝑁 הם דוחים או אינסופיים ← )𝑁(𝐿 ∉> 𝑀 <‪.‬‬
‫∎‬
‫הערה חשובה‬
‫● פונקציית הרדוקציה היא תמיד דטרמיניסטית!‬
‫● יכול להיות שבפונקצית הרדוקציה תהיה מכונה א"ד אבל הפונקציה עצמה היא דטרמיניסטית‪.‬‬
‫● תוצאת פונקצית הרדוקציה יכולה להיות קידוד של מ"ט א"ד‪.‬‬
‫דוגמה ‪ - 2‬לשימוש במכונה לא דטרמיניסטית‬

‫מודל נוסף למ"ט א"ד‪:‬‬
‫}𝑥 𝑛𝑜 𝑔𝑛𝑖𝑛𝑛𝑢𝑟 𝑛𝑒‪𝐿4 = {< 𝑀, 𝑥 > | 𝑀 ℎ𝑎𝑠 𝑎𝑡 𝑙𝑒𝑎𝑠𝑡 4 𝑑𝑖𝑓𝑓𝑒𝑟𝑒𝑛𝑡 𝑎𝑐𝑐𝑒𝑝𝑡𝑖𝑛𝑔 𝑝𝑎𝑡ℎ𝑠 𝑤ℎ‬‬
‫}𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 | > 𝑥 ‪𝐿𝑢 = {< 𝑀,‬‬
‫הוכיחו שקילות בין מודלים‪.‬‬
‫פתרון‪ :‬נרצה לעשות רדוקציה ‪ 𝐿𝑢 ≤ 𝐿4‬ואחר כך נעשה גם הפוך 𝑢𝐿 ≤ ‪.𝐿4‬‬
‫הוכחה כיוון א'‪:‬‬
‫● אינטואיציה‪ :‬אנחנו רוצים שאם מכונה 𝑀 תקבל‬
‫את 𝑥 אז יהיה לנו מכונה אחרת '𝑀 שתקבל את 𝑥‬
‫‪ 4‬פעמים שונים‪ .‬בתיאור הרדוקציה‪ ,‬אנחנו נרצה‬
‫לשכפל את המסלולים‪ ,‬כלומר נשכפל פעמיים‬
‫כאשר כל שכפול פותח לנו רמה חדשה בעץ‬
‫‪2‬‬
‫החישוב‪ ,‬לכן עבור ‪ 2‬שכפולים נקבל ‪2 = 4‬‬
‫צמתים ‪ -‬כלומר צמתים סופיים ונרצה שמכל הארבעה אלו ימשיך מסלול המקבל את 𝑥 על 𝑀‪.‬‬
‫● תיאור הרדוקציה‪ :‬נראה ברדוקציה ‪.𝐿𝑢 ≤ 𝐿4‬‬
‫○ פונקצית הרדוקציה היא‪𝑓(< 𝑀, 𝑥 >) =< 𝑀', 𝑦 >, :‬‬
‫○ המכונה '𝑀 על הקלט 𝑦‪:‬‬
‫■ תנחש ‪ 0‬או ‪1‬‬
‫■ תנחש ‪ 0‬או ‪1‬‬
‫■ סמלץ את 𝑀 על 𝑥 וענה כמותו‪.‬‬
‫● הוכחת נכונות פונקציית הרדוקציה‪:‬‬
‫○ הפונקציה מלאה‪ :‬לכל 𝑥 ‪ 𝑀,‬ניתן ליצור 𝑦 ‪.𝑀',‬‬
‫○ הפונקציה ניתנת לחישוב‪ :‬לכל מ"ט קיים קידוד במיוצג כמחרוזת‪.‬‬
‫■ 𝑢𝐿 ∈> 𝑥 ‪ ← 𝑥 ∈ 𝐿(𝑀) ← < 𝑀,‬קיים לפחות מסלול אחד מקבל בחישוב 𝑀 על𝑥‬
‫← קיימים ‪ 4‬מסלולים מקבלים ← ‪.< 𝑀', 𝑥 >∈ 𝐿4‬‬
‫■ 𝑢𝐿 ∉> 𝑥 ‪ ← 𝑥 ∉ 𝐿(𝑀) ← < 𝑀,‬כל מסלול בחישוב 𝑀 על𝑥 או דוחה או אינסופי‬
‫← קיימים ‪ 4‬מסלולים דוחים או אינסופיים ← ‪.< 𝑀', 𝑥 >∉ 𝐿4‬‬
‫● לסיכום‪ :‬הראנו רדוקציה 𝑢𝐿 מעל ‪ 𝐿4‬והוכחנו ש‪.𝐿4 = 𝐿(𝑀') :‬‬
‫הוכחה כיוון ב'‪ :‬נראה ברדוקציה 𝑢𝐿 ≤ ‪ .𝐿4‬להשלים‪.‬‬
‫הוכחת שקילות בין המודלים‬

‫זה גרסה שלא נלמדה הסמסטר אבל למדו אותה בשנים קודמות והיא יותר מפשטת ‪( -‬לא מתקבל במבחן)‪.‬‬
‫טענה‪ :‬מודל מ"ט א"ד שקול מבחינה חישובית למ"ט דטרמיניסטית‪.‬‬

‫כלומר‪ ,‬תהי 𝑁 מ"ט א"ד ‪ ,‬אזי קיימת מ"ט דטרמיניסטית 𝐷 כך שמתקיים‪.𝐿(𝐷) = 𝐿(𝑁) :‬‬
‫● ניתן לייצג את ריצת 𝑁 על 𝑤 כעץ העובר בין הקונפיגורציות של המכונה (יתכן שהעץ הוא אינסופי)‬
‫● נתאר את 𝐷 על קלט 𝑤‪:‬‬
‫○ סרוק לרוחב את עץ החישוב של 𝑁 על 𝑤 בעזרת 𝑆𝐹𝐵‪.‬‬
‫○ אם זיהית קונפיגורציה מקבלת ‪ -‬קבל‪.‬‬
‫○ אם סרקת את כל העץ ולא מצאת קונפיגורציה מקבלת ‪ -‬דחה‪.‬‬
‫● נכונות ‪ -‬אם קיים מסלול מקבל בריצת 𝑁 על 𝑤‪ ,‬אזי 𝐷 מגיע בסופו של דבר לקונפיגורציה מקבלת‬
‫ותקבל את 𝑤‪ .‬אחרת תדחה‪.‬‬
‫∎‬
‫שאלה ‪ - 1‬תרגול ‪( 4‬שאלת מבחן מועד א' ‪ -‬קיץ ‪)2019‬‬

‫בהינתן מכונת טיורינג אי‪-‬דטרמיניסטית 𝑀‪ ,‬נגדיר‪ :‬המכונה ההופכית של 𝑀‪ ,‬הינה מכונה הזהה בפעולתה‬
‫לפעולת 𝑀‪ ,‬למעט החלפת המצב המקבל והמצב הדוחה אחד בשני‪ .‬נסמן את המכונה ההופכית ב‪.𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒-‬‬
‫)𝑀(𝐿 (השפה ההופכית של שפת המכונה 𝑀‪ ,‬שווה לשפת המכונה ההופכית)‪.‬‬ ‫סעיף א'‪ :‬הוכיחו או הפריכו‪= 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) :‬‬
‫סעיף ב'‪ :‬האם קיימת מכונה 𝑀‪ ,‬כך שמתקיים‪ ?𝐿(𝑀) = 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) :‬אם כן‪ ,‬תנו דוגמא‪ ,‬אם לא‪ ,‬הוכיחו‪.‬‬
‫פתרון סעיף א'‪:‬‬

‫● אינטואיציה‪ :‬המכונה אי דטרמיניסטית ולכן יכול להיות שעבור 𝑥 מסוים מהשפה נקבל מסלול מקבל‬
‫ומצד שני יהיה עבורו מסלול אחר שהוא דוחה‪ .‬לכן זה הפרכה ‪ -‬צריך לתת דוגמה נגדית‪.‬‬
‫● הפרכה‪:‬‬
‫○ נניח שקיים 𝑥 כך שב‪ 𝑀-‬על 𝑥 ישנו מסלול מקבל ומסלול דוחה‪ .‬מכאן ש‪ 𝑥 ∈ 𝐿(𝑀) :‬כלומר‬
‫)𝑀(𝐿 ∉ 𝑥‪.‬‬
‫○ נתבונן בריצת המכונה 𝑒𝑠𝑟𝑒𝑣𝑛𝑖𝑀 על 𝑥‪:‬‬
‫■ עבור המסלול הדוחה של 𝑀 על 𝑥 ‪ 𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒 -‬יקבל את 𝑥‪.‬‬
‫■ עבור המסלול המקבל של 𝑀 על 𝑥 ‪ 𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒 -‬ידחה את 𝑥‪.‬‬
‫בכל אופן‪( 𝑥 ∈ 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) ,‬כי קיים לו מסלול מקבל)‪.‬‬
‫○ מכאן ש‪ 𝐿(𝑀) ≠ 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) :‬כי הראנו ש‪ 𝑥 ∈ 𝐿(𝑀) :‬וגם ש‪.𝑥 ∈ 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) :‬‬
‫● שאלת צד‪ :‬מתי זה נכון? ‪ -‬כאשר כל המצבים סופיים וזהים (כולם מקבלים או כולם דוחים)‪.‬‬

‫● קיים מכונה כזאת‪.‬‬
‫● אופציה א'‪ :‬נדאג שבמכונה שלנו על כל 𝑥 קיימים מסלולים גם מקבלים וגם דוחים‪.‬‬
‫⋆‬
‫○ מצד אחד‪.𝐿(𝑀) = Σ :‬‬
‫○ מצד שני עבור 𝑒𝑠𝑟𝑒𝑣𝑛𝑖𝑀 קיימים מצבים מקבלים לכל 𝑥 (המצבים שדחו קודם) כלומר‬
‫⋆‬
‫‪.𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) = Σ‬‬
‫⋆‬
‫בכל מקרה‪( .𝐿(𝑀) = 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) = Σ ,‬כי אם קיימים מסלולים מקבלים וגם דוחים אז שנהפוך‬
‫מקבל מסלולים דוחים וגם מקבלים‪ ,‬ככה או ככה קיים לנו לפחות מסלול מקבל אחד)‪.‬‬
‫● אופציה ב'‪ :‬מכונה שעל כל 𝑥 בכל המסלולים נכנסת ללולאה‪.‬‬
‫○ מצד אחד‪.𝐿(𝑀) = ∅ :‬‬
‫○ מצד שני‪.𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) = ∅ :‬‬
‫בכל מקרה‪( .𝐿(𝑀) = 𝐿(𝑀𝑖𝑛𝑣𝑒𝑟𝑠𝑒) = ∅ ,‬כי ההפך של "לא מוגדר" הוא "לא מוגדר")‪.‬‬
‫שאלה ‪ - 2‬תרגול ‪4‬‬

‫נתונה השפה }𝑖 = 𝑖𝑤 ‪.𝐿 = {(𝑤1, 𝑤2,..., 𝑤𝑛) | ∃𝑖 𝑠. 𝑡.‬‬
‫הוכיחו כי 𝑅 ∈ 𝐿‪.‬‬
‫אינטואיציה‪ :‬אם היינו עובדים עם מכונה דטרמיניסטית אז המכונה הייתה עוברת בלולאה לינארית מ‪ 1-‬עד 𝑛‬
‫ובודקת עבור כל צעד האם 𝑖 = 𝑖𝑤‪ .‬מצד שני‪ ,‬אם נעבוד עם מכונה אי‪-‬דטרמיניסטית אז אפשר לנחש ולכן זה‬
‫יותר קל למימוש כי לא צריך לולאות‪ .‬אנחנו בונים על זה שהניחוש יהיה נכון‪.‬‬
‫אלגוריתם‪ :‬נתאר מכונה א"ד 𝑀 המכריעה את השפה 𝐿‪.‬‬
‫𝑀 על קלט )𝑛𝑤 ‪:(𝑤1, 𝑤2,...,‬‬
‫‪ .1‬נחש אינדקס 𝑛 ≤ 𝑖 ≤ ‪:1‬‬
‫‪ .a‬אם 𝑖 = 𝑖𝑤 ‪ -‬קבל‪.‬‬
‫‪ .b‬אחרת‪ ,‬דחה‪.‬‬
‫הוכחת נכונות‪:‬‬
‫● 𝐿 ∈ )𝑛𝑤 ‪ ← (𝑤1, 𝑤2,...,‬קיים 𝑖 שעבורו 𝑖 = 𝑖𝑤 ← קיים ניחוש (מסלול חישוב מקבל) שעבורו 𝑀‬
‫מקבל ← )𝑀(𝐿 ∈ )𝑛𝑤 ‪.(𝑤1, 𝑤2,...,‬‬
‫● 𝐿 ∉ )𝑛𝑤 ‪ ← (𝑤1, 𝑤2,...,‬לא קיים אף 𝑖 שעבורו 𝑖 = 𝑖𝑤 ← לכל ניחוש (מסלול חישוב מקבל) שעבורו‬
‫𝑀 דוחה ← )𝑀(𝐿 ∉ )𝑛𝑤 ‪.(𝑤1, 𝑤2,...,‬‬
‫∎‬
‫נתונה מכונה א"ד‪:‬‬
‫אלגוריתם‪ 𝑁 :‬על קלט )𝑥 ‪:(< 𝑀 >,‬‬

‫‪ .1‬מנחשת מספר 𝑛‪.‬‬
‫‪ .2‬מריצה את 𝑀 על 𝑥 למשך 𝑛 צעדים‪.‬‬
‫‪ .a‬אם 𝑀 עצרה ‪ -‬אז 𝑁 תקבל‪.‬‬
‫‪ .b‬אם 𝑀 לא עצרה ‪ -‬אז 𝑁 תדחה‪.‬‬
‫השאלה‪ :‬מהי השפה של 𝑁?‪.‬‬

‫תשובה‪.𝐿(𝑁) = 𝐻𝑃 :‬‬
‫הסבר‪ :‬ההגבלה פה לא קשורה בצעדים‪ ,‬כי אם היא מקבלת אז קיים 𝑛 מספיק גדול כדי שיהיה מספיק צעדים‬
‫לרוץ ואם היא דוחה אז לא משנה כמה 𝑛 מספיק גדול ‪ -‬היא לא תעצור לעולם‪.‬‬
‫● 𝑃𝐻 ∈ )𝑥 ‪ 𝑀 ← (< 𝑀 >,‬עוצרת על 𝑥 ← נניח ש‪ 𝑀 :‬עוצרת על 𝑥 לאחר 𝑡 צעדים ← לכל ניחוש של‬
‫𝑛 כך ש‪ ,𝑛 ≥ 𝑡 :‬המכונה 𝑁 תעצור ותקבל‪ ← .‬קיים מסלול חישוב שבו 𝑁 תקבל ←‬
‫)𝑁(𝐿 ∈ )𝑥 ‪.(< 𝑀 >,‬‬
‫● 𝑃𝐻 ∉ )𝑥 ‪ 𝑀 ← (< 𝑀 >,‬לא עוצרת על 𝑥 ← 𝑀 לא עוצרת על 𝑥 לכל ניחוש 𝑛 ← לא קיים אף‬
‫מסלול חישוב שבו 𝑁 תקבל ← )𝑁(𝐿 ∉ )𝑥 ‪.(< 𝑀 >,‬‬
‫∎‬

‫נתונה השפה‪.𝐶𝑂𝑀𝑃𝑂𝑆𝐼𝑇𝐸 = {𝑛 | 𝑛 𝑖𝑠 𝑐𝑜𝑚𝑝𝑜𝑠𝑖𝑡𝑒} :‬‬
‫הוכיחו‪.𝐶𝑂𝑀𝑃𝑂𝑆𝐼𝑇𝐸 ∈ 𝑅 :‬‬
‫תזכורת‪ :‬מספר ָּפ ִריק הוא מספר שלם חיובי שאפשר לכתוב אותו כמכפלה של שני שלמים גדולים מ‪ .1-‬מספרים‬
‫אלה נקראים 'גורמים' של המספר הנתון‪ .‬כל מספר שלם גדול מ‪ 1-‬הוא או ראשוני או פריק‪.‬‬
‫לדוגמה‪ ,‬המספר ‪ 14‬הוא פריק מכיוון שאפשר לפרק אותו כמכפלה של ‪ 2‬ו‪ ,7-‬ולכן ‪ 2‬ו‪ 7 -‬הם הגורמים של ‪.14‬‬
‫הוכחה‪ :‬נתאר מ"ט א"ד 𝑀 המכריעה את השפה 𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶‪.‬‬
‫אלגוריתם‪ 𝑀 :‬על קלט 𝑛 (או שניתן לסמן )𝑛(𝑀) תבצע‪:‬‬
‫‪ .1‬תנחש מספר 𝑘 כך ש‪.1 < 𝑘 < 𝑛 :‬‬
‫‪ .2‬אם ‪ 𝑘%𝑛 == 0‬אז 𝑀 תקבל‪.‬‬
‫‪ .3‬אחרת ‪ 𝑀 -‬תדחה‪.‬‬
‫● 𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶 ∈ 𝑛 ← קיים 𝑘 שמחלק את 𝑛 ← קיים ניחוש של 𝑀 עבורו יקבל ← )𝑀(𝐿 ∈ 𝑛‪.‬‬
‫● 𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶 ∉ 𝑛 ← לא קיים אף 𝑘 שמחלק את 𝑛 ← לכל ניחוש של 𝑘 כזה‪ 𝑀 ,‬תדחה ←‬
‫)𝑀(𝐿 ∉ 𝑛‪.‬‬
‫∎‬

‫נתונה מכונה ‪ 𝑀0‬ונתון קבוע טבעי ‪.𝑐 ∈ ℕ‬‬
‫נתונה השפה‪.𝐿𝑀 ,𝑐 = {< 𝑀 > |𝐿(𝑀) = 𝐿(𝑀0) 𝑎𝑛𝑑 |< 𝑀 >| = 𝑐} :‬‬
‫‪0‬‬
‫שאלה‪ :‬באיזו מחלקה חישובית השפה נמצאת?‬

‫תשובה‪.𝐿𝑀 ,𝑐 ∈ 𝑅 :‬‬
‫‪0‬‬
‫הסבר‪ :‬למה זה ב‪ .?𝑅-‬בפרק של 𝑃𝐻𝐵 הראנו שפות שאם יש להם חסם אז אפשר להכריע אם הקלט עקף את‬
‫𝑐‬
‫החסם או לא וככה להכריע‪ .‬מאחר ויש מספר סופי של מחרוזות בינאריות באורך 𝑐‪ ,‬כלומר ‪ 2‬מחרוזות האלה‪,‬‬
‫אז זו שפה סופית ← רגולרית ← שייכת ל‪.𝑅-‬‬
‫נקודה חשובה‪ :‬אם היה בשפה ‪ or‬במקום ‪ and‬אז זה היא לא הייתה סופית ובכלל לא ב‪.𝑅-‬‬ ‫‪-‬‬
‫שאלה ‪ - 6‬תרגול ‪( 4‬שאלת מבחן)‬

‫נתונה שפה‪:‬‬
‫}> '𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 𝑟𝑜 𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 '𝑀 ‪𝐿 = {< 𝑀, 𝑥 > | ∃ 𝑎 𝑇𝑢𝑟𝑖𝑛𝑔 𝑀𝑎𝑐ℎ𝑖𝑛𝑒 𝑀', 𝑠. 𝑡.‬‬
‫שאלה‪ :‬באיזו מחלקה השפה?‪.‬‬
‫⋆‬
‫תשובה‪ .𝐿 ∈ 𝑅 :‬למעשה זו ‪ Σ‬כי ניתן תמיד לבחור 𝑀𝐴𝑇𝑆𝑀 = '𝑀 שתקבל את 𝑥‪.‬‬
‫הסבר‪ :‬אכן קיימת מכונה '𝑀 שיכולה לקבל כל קלט שהיא מקבלת‪ ,‬זוהי המכונה 𝑀𝐴𝑇𝑆𝑀‪ .‬גם אם התנאי השני‬
‫(צד ימין של ה‪ )or-‬לא מקבל‪ ,‬זה בסדר כי 𝑀𝐴𝑇𝑆𝑀 תמיד תקבל את 𝑥‪ .‬מכונה שמקבלת כל קלט זו מכונה‬
‫⋆‬
‫שמכריעה את השפה ‪.Σ‬‬
‫שאלה ‪ - 7‬תרגול ‪( 4‬שאלת מבחן)‬

‫נתונה שפה (אותו שפה כמו שאלה ‪ 6‬אבל עם ‪ and‬במקום ‪:)or‬‬
‫}> '𝑀 < 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 𝑀 𝑑𝑛𝑎 𝑥 𝑠𝑡𝑝𝑒𝑐𝑐𝑎 '𝑀 ‪𝐿 = {< 𝑀, 𝑥 > | ∃ 𝑎 𝑇𝑢𝑟𝑖𝑛𝑔 𝑀𝑎𝑐ℎ𝑖𝑛𝑒 𝑀', 𝑠. 𝑡.‬‬
‫שאלה‪ :‬באיזה מחלקה השפה?‪.‬‬
‫תשובה‪.𝐿 ∈ 𝑅𝐸 :‬‬
‫● אלגוריתם‪ :‬נתאר מ"ט א"ד 𝑁 שמקבלת את 𝐿‪.‬‬
‫𝑁 על קלט > 𝑥 ‪:< 𝑀,‬‬
‫‪ .1‬תנחש מכונה '𝑀‪.‬‬
‫‪ .2‬תסמלץ מכונה '𝑀 על 𝑥‪ ,‬אם '𝑀 דחתה את 𝑥 ‪ 𝑁 -‬דוחה‪.‬‬
‫‪ .3‬תסמלץ מכונה 𝑀 על > '𝑀 <‪ ,‬אם 𝑀 דחתה את > '𝑀 < ‪ 𝑁 -‬דוחה‪.‬‬
‫‪ .4‬אחרת‪ 𝑁 ,‬מקבלת‪.‬‬
‫● נכונות הבניה‪:‬‬
‫○ 𝐿 ∈> 𝑥 ‪ ← < 𝑀,‬קיים מכונה '𝑀 שעונה על דרישות השפה ← 𝑁 תנחש את '𝑀 עבורו קיים‬
‫מסלול חישוב מקבל ← 𝑁 תקבל ← )𝑁(𝐿 ∈> 𝑥 ‪.< 𝑀,‬‬
‫○ 𝐿 ∉> 𝑥 ‪ ← < 𝑀,‬לא קיים מכונה '𝑀 שעונה על דרישות השפה ← לכל ניחוש (מסלול‬
‫חישוב)‪ 𝑁 ,‬תדחה או לא תעצור ← )𝑁(𝐿 ∉> 𝑥 ‪.< 𝑀,‬‬
‫שיעורי בית‪ :‬הוכיחו שהשפה לא ב‪( .R-‬ברדוקציות ‪ -‬אפשר מ‪ HP-‬או מקור אחר)‪.‬‬

‫נתונה השפה (כאשר 𝑁 היא מכונה א"ד)‪:‬‬
‫}‪𝐿 = {< 𝑁, 𝑥 > | 𝑁 𝑟𝑢𝑛𝑛𝑖𝑛𝑔 𝑜𝑛 𝑥 ℎ𝑎𝑠 𝑎𝑛 𝑎𝑐𝑐𝑒𝑝𝑡𝑖𝑛𝑔 𝑝𝑎𝑡ℎ 𝑎𝑛𝑑 𝑎 𝑟𝑒𝑗𝑒𝑐𝑡𝑖𝑛𝑔 𝑝𝑎𝑡ℎ‬‬
‫הוכיחו שהשפה 𝑅 ∉ 𝐿‪.‬‬
‫● אינטואיציה‪ :‬השפה ב‪ .𝑅𝐸-‬נוכיח באינדוקציה ש‪ 𝐿 ∉ 𝑅:‬ונשתמש בשפה 𝑅 ∉ 𝑃𝐻‪ .‬בתיאור הרדוקציה‬
‫נפעיל את 𝑀 על 𝑥‪ ,‬אם הוא עצר (לפי 𝑃𝐻) אז הגענו במסלול החישוב שלנו לצומת שבה צריך לקבוע‬
‫מה הצעד הבא של האלגוריתם ‪ -‬האם נקבל או נדחה?‪ .‬לכן‪ ,‬מאחר ש‪ 𝑁-‬א"ד אז נגריל‪/‬ננחש את הענף‬
‫הבא במסלול החישוב שיקבע אם נקבל או נדחה (‪ == 0‬דוחה || ‪ == 1‬מקבל)‪.‬‬
‫● תיאור הרדוקציה‪ :‬נראה רדוקציה 𝐿 ≤ 𝑃𝐻‪.‬‬
‫○ פונקציית הרדוקציה‪.𝑓(< 𝑀, 𝑥 >) =< 𝑁, 𝑦 > :‬‬
‫○ 𝑁 על קלט 𝑦 תפעל‪:‬‬
‫■ תסמלץ את 𝑀 על 𝑥‪.‬‬
‫■ מגרילה ביט 𝑏‪.‬‬
‫■ אם ‪ 𝑏 = 0‬אז 𝑁 דוחה‪.‬‬
‫■ אם ‪ 𝑏 = 1‬אז 𝑁 מקבלת‪.‬‬
‫● הוכחת נכונות הפונקציה‪:‬‬
‫○ הפונקציה מלאה‪ :‬לכל 𝑥 ‪ 𝑀,‬ניתן ליצור 𝑦 ‪.𝑁,‬‬
‫○ הפונקציה ניתנת לחישוב‪ :‬לכל מ"ט קיים קידוד‪.‬‬
‫■ 𝑃𝐻 ∈> 𝑥 ‪ 𝑀 ← < 𝑀,‬עוצרת על 𝑥 ← 𝑁 יכולה לקבל או לדחות ← יש ל‪ 𝑁-‬מסלול‬
‫חישוב מקבל ומסלול חישוב דוחה ← במ"ט א"ד מספיק מסלול מקבל אחד בשביל‬
‫לקבל את המילה ← )𝑁(𝐿 ∈> 𝑥 ‪.< 𝑁,‬‬
‫■ 𝑃𝐻 ∉> 𝑥 ‪ 𝑀 ← < 𝑀,‬לא עוצרת ← אין ל‪ 𝑁-‬מסלול חישוב מקבל ←‬
‫)𝑁(𝐿 ∉> 𝑥 ‪.< 𝑁,‬‬
‫● סיכום‪ :‬מאחר ו‪ 𝐻𝑃 ∉ 𝑅-‬והראנו ברדוקציה 𝐿 ≤ 𝑃𝐻 אזי גם 𝑅 ∉ 𝐿‪.‬‬
‫∎‬
‫תרגילים ‪ -‬חישוביות‬
‫תרגיל ‪ :1‬כתבו מכונת טיורינג המחשבת את הפונקציה 𝑥‪.𝑓(𝑥) = 2‬‬
‫𝑖‬
‫הערה‪ 𝑥 :‬הוא מחרוזת בינארית של מספר חיובי‪ .‬תזכורת‪ :‬הכפלה בינארית ב‪ 2 -‬דורש הזזת 𝑖 צעדים שמאלה‪.‬‬
‫תרגיל ‪ :2‬מודל מכונת טיורינג בגיל העמידה הוא מודל זהה למודל הרגיל של מ"ט לחישוב פונקציות פרט‬
‫לשינויים הבאים‪:‬‬
‫‪ .1‬למכונה אין מצבים סופיים‪ ,‬ולכן המכונה לעולם לא עוצרת‪.‬‬
‫‪ .2‬נגיד שמכונה נעמדת בצעד החישוב ה‪ 𝑡-‬אם מצעד חישוב זה והלאה המכונה מבצעת אך ורק תזוזה‬
‫𝑦𝑎𝑡𝑆 (ולעולם לא תבצע יותר תזוזות 𝑡𝑓𝑒𝐿 או 𝑡‪.)𝑅𝑖𝑔ℎ‬‬
‫‪ .3‬עבור קלט 𝑥 הפלט של המכונה הוא המילה 𝑦 שנמצאת משמאל לראש כאשר המכונה נעמדת‪.‬‬
‫הוכיחו‪/‬הפריכו‪ :‬מודל גיל העמידה שקול למודל הרגיל‪.‬‬
‫𝑅‬
‫תרגיל ‪ :3‬כתבו מכונת טיורינג שמחשבת את הפונקציה‪.𝑓(𝑤) = 𝑤 :‬‬
‫תרגיל ‪ :4‬הוכיחו כי 𝐸𝑅 סגורה לחיתוך‪.‬‬
‫תרגיל ‪ :5‬יהיו 𝑅\𝐸𝑅 ∈ ‪ 𝐿1, 𝐿2‬האם ייתכן ש‪:‬‬

‫‪.𝐿1 ∩ 𝐿2 ∈ 𝑅 .1‬‬
‫‪.𝐿1 ∪ 𝐿2 ∈ 𝑅 .2‬‬
‫קבעו את תשובתכם‪ ,‬במידה וכן הראו שפות כאלה‪( .‬שאלה אונ' תל אביב מטלה ‪.)2006a ,5‬‬
‫תרגיל ‪ :6‬קבעו עבור השפות הבאות האם שייכות ל‪ .(𝑅, 𝑐𝑜𝑅𝐸, 𝑅𝐸) -‬הוכיחו‪.‬‬
‫}𝑥 𝑛𝑜 𝑠𝑡𝑙𝑎‪𝐿1 = {𝑀 | ∃𝑥 𝑠. 𝑡. 𝑀 ℎ‬‬
‫}‪𝐿2 = {𝑀 | |𝐿(𝑀)| ≤ 3‬‬
‫(שאלה אונ' תל אביב מטלה ‪.)2008a ,3‬‬
‫תרגיל ‪ :7‬שאלת מבחן ‪ -‬מועד ב'‪ ,‬קיץ ‪2020‬‬

‫לכל אחד מהסעיפים הבאים‪ ,‬קבעו האם נכון או לא נכון‪.‬‬
‫אם הטענה נכונה ‪ -‬הסבירו‪ .‬אם טענה אינה נכונה ‪ -‬תנו דוגמה נגדית‪:‬‬
‫א‪ .‬לכל שפה 𝑅 ∈ 𝐿 מתקיים 𝑃𝐻 ≤ 𝐿 וגם 𝑢𝐿 ≤ 𝐿‪.‬‬
‫ב‪ .‬אם 𝑅\𝐸𝑅 ∈ ‪ 𝐿1‬וגם 𝑅\𝐸𝑅𝑜𝑐 ∈ ‪ 𝐿2‬אז מתקיים 𝑅 ∉ ‪.𝐿1 ∪ 𝐿2‬‬
‫ג‪ .‬אם 𝐸𝑅 ∈ ‪ 𝐿1‬וגם 𝐸𝑅𝑜𝑐 ∈ ‪ 𝐿2‬אז מתקיים 𝑅 ∈ ‪.𝐿1 ∩ 𝐿2‬‬
‫תרגיל ‪ :8‬שאלת מבחן ‪ -‬מועד א'‪ ,‬קיץ ‪2020‬‬

‫לכל אחת מהשפות הבאות‪ ,‬קבעו האם היא ב‪ ?𝑅-‬והאם היא ב‪ ?𝑅𝐸-‬הוכיחו את תשובתכם‪.‬‬
‫א‪.𝐿1 = {< 𝑀, 𝑥1, 𝑥2 > | 𝑀 𝑎𝑐𝑐𝑒𝑝𝑡𝑠 𝑥1 𝑎𝑛𝑑 𝑟𝑒𝑗𝑒𝑐𝑡𝑠 𝑥2} .‬‬
‫|‬
‫ב‪.𝐿3 = {< 𝑀1 >< 𝑀2 > : 𝐿(𝑀1) ∩ 𝐿(𝑀2) = ∞} .‬‬ ‫|‬
‫תרגיל ‪ :9‬שאלת מבחן ‪ -‬מועד א'‪ ,‬קיץ ‪2020‬‬
‫הוכיחו או הפריכו את הטענות הבאות‪:‬‬
‫⋆‬
‫א‪ .‬אם 𝑅 ∈ 𝐿 וגם ‪ 𝐿 ≠ φ, Σ‬אז ‾𝐿 ≤ 𝐿‪.‬‬
‫ב‪ .‬אם 𝑅 ∉ 𝐿 וגם ‾𝐿 ≤ 𝐿 אז 𝐸𝑅𝑜𝑐 ∪ 𝐸𝑅 ∈ 𝐿‪.‬‬
‫תרגיל ‪ :10‬קבעו עבור השפות הבאות האם שייכות ל‪ .(𝑅, 𝑐𝑜𝑅𝐸, 𝑅𝐸) -‬הוכיחו‪.‬‬
‫}𝑠𝑒𝑚𝑖𝑡 ‪𝐿1 = {< 𝑀 > | 𝑤ℎ𝑒𝑛 𝑀 𝑟𝑢𝑛𝑛𝑖𝑛𝑔 ε, 𝑡ℎ𝑒 ℎ𝑒𝑎𝑑 𝑚𝑜𝑣𝑒𝑠 𝑙𝑒𝑓𝑡 𝑎𝑡 𝑚𝑜𝑠𝑡 2022‬‬
‫}𝑡𝑓𝑒𝑙 𝑤𝑜𝑟 𝑎 𝑛𝑖 𝑠𝑒𝑚𝑖𝑡 𝑒𝑒𝑟‪𝐿2 = {< 𝑀 > | 𝑤ℎ𝑒𝑛 𝑀 𝑟𝑢𝑛𝑛𝑖𝑛𝑔 ε, 𝑡ℎ𝑒 ℎ𝑒𝑎𝑑 𝑛𝑒𝑣𝑒𝑟 𝑚𝑜𝑣𝑒𝑠 𝑡ℎ‬‬
‫(שאלה אונ' תל אביב מטלה ‪.)2014b ,5‬‬
‫תרגיל ‪ :11‬הוכיחו או הפריכו‪ :‬קיימת שפה שלמה ב‪.𝑐𝑜𝑅𝐸-‬‬
‫תרגיל ‪ :12‬עבור השפה הבאה ענו האם היא ב‪ 𝑅-‬והאם היא ב‪.𝑅𝐸-‬‬
‫}𝑠𝑡𝑢𝑝𝑛𝑖 𝑙𝑙𝑎 𝑛𝑜 𝑠𝑡𝑙𝑎‪𝐿 = {< 𝑀 > |𝑀 ℎ‬‬
‫(מטלה ‪ - 2‬אריאל תש"ף)‪.‬‬
‫תרגיל ‪ :13‬קבעו לאיזה מחלקות )𝐸𝑅 ‪ (𝑅, 𝑐𝑜𝑅𝐸,‬השפות הבאות שייכות‪:‬‬

‫}𝑡𝑢𝑝𝑛𝑖 𝑒𝑛𝑜 𝑡𝑠𝑎𝑒𝑙 𝑡𝑎 𝑛𝑜 𝑠𝑡𝑙𝑎‪𝐿1 = {< 𝑀 > | 𝑀 ℎ‬‬
‫}𝑡𝑢𝑝𝑛𝑖 𝑒𝑛𝑜 𝑡𝑠𝑜𝑚 𝑡𝑎 𝑛𝑜 𝑠𝑡𝑙𝑎‪𝐿2 = {< 𝑀 > | 𝑀 ℎ‬‬
‫(שאלת מבחן אריאל מועד ב' תשע"ז)‪.‬‬
‫תרגיל ‪ :14‬תהיינה ‪ 𝐿1, 𝐿2‬שפות כך ש‪ 𝐿1 ∈ 𝑅𝐸 :‬וגם 𝐸𝑅𝑜𝑐 ∈ ‪ 𝐿2‬בנוסף נתון כי ‪.𝐿1 ≤ 𝐿2‬‬
‫עבור כל אחת מהטענות הבאות הוכיחו האם היא תמיד נכונה‪ ,‬תמיד לא נכונה או שקיימות שפות המקיימות את‬
‫התנאים עבורן הטענה נכונה‪ ,‬וקיימות שפות המקיימות את התנאים עבורן הטענה לא נכונה‪.‬‬
‫‪ 𝐿1 .1‬היא 𝐸𝑅 משלימה‪.‬‬
‫‪ .𝐿2 ∈ 𝑅 .2‬כלומר ‪ 𝐿2‬כריעה‪.‬‬
‫‪ ,𝐿1 ∉ 𝑅 .3‬כלומר ‪ 𝐿1‬לא כריעה‪.‬‬

‫(מבחן אריאל תשע"ז קיץ מועד א שאלה ‪.)4‬‬
‫}‪.{< 𝑀 > | |𝐿(𝑀)| ≥ 3‬‬ ‫≤‬ ‫תרגיל ‪ :15‬הראו ש‪{< 𝑀 > | |𝐿(𝑀)| ≥ 6} :‬‬
‫(מבחן אריאל תשע"ח קיץ מועד א' שאלה ‪2‬ג')‪.‬‬
‫מבוא לסיבוכיות‬
‫מבוא‬
‫חישוביות‪ :‬בחלק הקודם‪ ,‬התעסקנו בשאלה "מה בכלל אפשר לחשב בעזרת מכונות?"‪.‬‬
‫● איזה פונקציות ניתנות לחישוב ואיזה לא?‬
‫● איזה שפות ניתנות להכרעה (לזיהוי) ואיזה לא?‬
‫סיבוכיות‪ :‬בחלק זה‪ ,‬נעסוק‪:‬‬
‫● בפונקציות הניתנות לחישוב ובשפות הכריעות‪.‬‬
‫● בשאלה של כמויות המשאבים הדרושות לחישובים (משאבי זמן וזיכרון הדרושים)‪.‬‬
‫סיבוכיות זמן‬
‫בסיבוכיות זמן נשאל מהו הזמן הדרוש למימוש כל אלגוריתם‪.‬‬
‫המודל החישובי שאיתו נמדוד את סיבוכיות הזמן הוא מכונת טיורינג והסיבות לכך הן‪:‬‬
‫‪ .1‬סיבוכיות הזמן נמדדת כפונקציה של גודל הקלט ובמכונת טיורינג גודל הקלט מוגדר היטב (מספר‬
‫התאים בסרט)‪.‬‬
‫‪ .2‬זמן הריצה יוגדר כמספר הצעדים שמבצעת המכונה במהלך ריצתה (צעד החישוב במ"ט מוגדר היטב)‪.‬‬
‫דוגמה ‪ - 1‬לחישוב זמן ריצה‬

‫𝑚 𝑚‬
‫כמה זמן נדרש להכריע שייכות לשפה }‪ 𝐿1 = {𝑎 𝑏 |𝑚 ≥ 0‬במ"ט חד‪-‬סרטית (סרט אחד בלבד)?‬
‫האלגוריתם‪ :‬נתאר את ‪ 𝑀1‬על מילת הקלט 𝑤‪:‬‬
‫‪ .1‬עבור על הקלט עד סופו‪ ,‬ודחה אם יש 𝑎 מימין ל‪.𝑏-‬‬
‫‪ .2‬על עוד יש 𝑎‪-‬ים ו‪-𝑏-‬ים‪ ,‬עבור על תוכן הסרט‪ ,‬ומחק 𝑎 אחד ו‪ 𝑏-‬אחד בכל מעבר כזה‪.‬‬
‫‪ .3‬אם נמחקו כל ה‪-𝑎-‬ים וכל ה‪-𝑏-‬ים‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫זמן הריצה‪ :‬זמן הריצה של ‪ 𝑀1‬הוא )‪( 2‬‬
‫𝑛 𝑂 כאשר 𝑛 הוא גודל הקלט‪.‬‬
‫הגדרה ‪ -‬זמן הריצה במקרה הגרוע ביותר‬

‫הגדרת זמן הריצה במקרה הגרוע ביותר‪ :‬תהי 𝑀 מ"ט דטרמיניסטית‪ ,‬ותהי פונקציה ‪.𝑡: ℕ → ℕ‬‬
‫נאמר שזמן הריצה של המכונה 𝑀 הוא )𝑛(𝑡 אם לכל קלט 𝑤 באורך 𝑛‪ ,‬מספר צעדי הריצה של 𝑀 על 𝑤 הוא‬
‫לכל היותר )𝑛(𝑡‪.‬‬
‫לדוגמה‪ :‬בדוגמה הקודמת אפשר להגיד שמספר צעדי הריצה של 𝑀 על 𝑤 הוא לכל היותר‬
‫‪2‬‬ ‫‪2‬‬
‫) 𝑛(𝑂 = ) )𝑛(𝑡 (𝑂‪ .‬כי אמנם גודל הקלט הוא 𝑛 אבל נדרש מהמכונה ‪ 𝑀1‬לכל היותר 𝑛 צעדי ריצה‪.‬‬
‫הגדרה ‪ -‬מחלקה של שפות‬

‫הגדרה ‪ -‬מחלקה של שפות‪ :‬תהי פונקציה ‪.𝑡: ℕ → ℕ‬‬
‫נסמן ב‪ 𝐷𝑇𝐼𝑀𝐸(𝑡(𝑛))-‬את מחלקת השפות שיש להן מכונת טיורינג דטרמיניסטית מכריעה שזמן הריצה שלה‬
‫הוא ))𝑛(𝑡(𝑂‪.‬‬
‫פורמלית‪.𝐷𝑇𝐼𝑀𝐸(𝑡(𝑛)) = {𝐿 | 𝐿 𝑖𝑠 𝑎 𝑙𝑎𝑛𝑔𝑢𝑎𝑔𝑒, 𝑑𝑒𝑐𝑖𝑑𝑒𝑑 𝑏𝑦 𝑎𝑛 𝑂(𝑡(𝑛)) − 𝑡𝑖𝑚𝑒 𝐷𝑇𝑀} :‬‬
‫‪2‬‬ ‫‪2‬‬ ‫𝑚 𝑚‬
‫דוגמה‪ :‬השפה }‪ 𝐿1 = {𝑎 𝑏 |𝑚 ≥ 0‬שייכת למחלקה ) 𝑛(𝐸𝑀𝐼𝑇𝐷‪ ,‬כלומר ) 𝑛(𝐸𝑀𝐼𝑇𝐷 ∈ ‪.𝐿1‬‬
‫דוגמה ‪ - 2‬לחישוב זמן ריצה‬

‫𝑚 𝑚‬
‫האם אפשר להכריע את השפה מדוגמה ‪ 𝐿1 = {𝑎 𝑏 |𝑚 ≥ 0} :1‬באופן מהר יותר?‬
‫‪2‬‬
‫כלומר‪ ,‬האם קיים אלגוריתם שפותר את הבעיה בזמן פחות מ‪ - ?𝑂(𝑛 )-‬כן‪.‬‬
‫אלגוריתם‪ 𝑀2 :‬על מילת קלט 𝑤 תבצע‪:‬‬

‫‪ .1‬עבור על הקלט 𝑤‪ ,‬אם יש 𝑎 מימין ל‪ 𝑏-‬אז דחה‪.‬‬
‫‪ .2‬חזור על הפעולות הבאות כל עוד יש 𝑎‪-‬ים ו‪-𝑏-‬ים‪:‬‬
‫‪ .a‬עבור על תוכן הסרט‪ :‬אם מספר כל ה‪-𝑎-‬ים וה‪-𝑏-‬ים הוא אי זוגי‪ ,‬אז דחה‪.‬‬
‫‪ .b‬עבור על תוכן הסרט‪ :‬מחק את ה‪ 𝑎-‬הראשון‪ ,‬השלישי‪ ,‬החמישי וכך הלאה‪ ,‬וכך גם ביחס ל‪-𝑏-‬ים‪.‬‬
‫‪ .3‬אם נמחקו כל ה‪-𝑎-‬ים וה‪-𝑏-‬ים‪ ,‬אז קבל‪.‬‬
‫‪ .4‬אם לא נמחקו כל ה‪-𝑎-‬ים וה‪-𝑏-‬ים‪ ,‬אז דחה‪.‬‬
‫זמן הריצה‪ :‬זמן הריצה של המכונה ‪ 𝑀2‬היא‪:‬‬

‫● שלב ‪ :1‬מעבר על כל הקלט עולה לנו )𝑛(𝑂 צעדים‪.‬‬
‫● שלב ‪ :2‬נכנסים ללולאה שתבצע לכל היותר ))𝑛(‪ 𝑂(log‬צעדים‪.‬‬
‫○ שלב ‪ :a‬עוברים על תוכן הסרט שעולה )𝑛(𝑂 צעדים‪.‬‬
‫○ שלב ‪ :b‬עוברים על תוכן הסרט שעולה )𝑛(𝑂 צעדים‪.‬‬
‫● שלב ‪ :3-4‬עוברים על תוכן הסרט כדי לוודא שהכל נמחק ‪ -‬עולה לנו )𝑛(𝑂 צעדים‪.‬‬
‫סך הכל‪ ,‬זמן הריצה של המכונה ‪ 𝑀2‬הוא במקרה הגרוע ביותר ))𝑛(‪.𝑂(2𝑛 log(𝑛) + 2𝑛) ≈ 𝑂(𝑛 log‬‬
‫‪2‬‬
‫מסקנה‪ 𝐿1 ∈ 𝐷𝑇𝐼𝑀𝐸(𝑛 · log(𝑛)) :‬וגם ) 𝑛(𝐸𝑀𝐼𝑇𝐷 ∈ ‪.𝐿1‬‬
‫‪2‬‬
‫תרגיל‪ :‬האם כל שפה ששייכת ל‪ 𝐷𝑇𝐼𝑀𝐸(𝑛 · log(𝑛))-‬שייכת גם ל‪.?𝐷𝑇𝐼𝑀𝐸(𝑛 )-‬‬
‫‪2‬‬
‫תשובה‪ :‬כן‪ ,‬אפשר לייצר צעדים מיותרים ב‪ 𝑛 · log(𝑛)-‬כדי להפוך אותו ל‪.𝑛 -‬‬
‫משפטים‬
‫משפט ‪ :1‬אם ))𝑛(‪ 𝑡1(𝑛) = 𝑂(𝑡2‬אז ))𝑛(‪.𝐷𝑇𝐼𝑀𝐸(𝑡1(𝑛)) ⊆ 𝐷𝑇𝐼𝑀𝐸(𝑡2‬‬
‫חסמים אסימפטוטיים‪:‬‬
‫● 𝑂 ‪ -‬חסום מלמעלה‪ .‬למשל )𝑛 ‪ 𝑛 = 𝑂(𝑛 log‬אז נאמר ש‪ 𝑛 " :‬חסום ב‪."𝑛 log 𝑛-‬‬
‫● ‪ - Ω‬חסום מלמטה‪.‬‬
‫‪ ,‬כלומר אפשר לחסום גם מלמעלה וגם מלמטה‪.‬‬ ‫‪ - Θ‬חסום הדוק‪ .‬למשל ) 𝑛(‪( ) = Θ‬‬
‫𝑛‬
‫𝑘‬
‫𝑘‬
‫●‬
‫‪2‬‬ ‫‪2‬‬ ‫‪2‬‬
‫● 𝑜 ‪ -‬קטן ממש‪ .‬למשל ) 𝑛(𝑜 = )𝑛(‪ 𝑡1‬אז נאמר ש‪ 𝑡1" :‬קטן ממש מ‪ "𝑛 -‬ונסמן 𝑛 ≪ ‪.𝑡1‬‬
‫‪2‬‬ ‫‪2‬‬ ‫‪2‬‬
‫● ‪ - ω‬גדול ממש‪ .‬למשל ) 𝑛(‪ 𝑡1(𝑛) = ω‬אז נאמר ש‪ 𝑡1" :‬גדול ממש מ‪ "𝑛 -‬ונסמן 𝑛 ≫ ‪𝑡1‬‬
‫𝑚 𝑚‬
‫שאלה‪ :‬האם אפשר להכריע את }‪ 𝐿1 = {𝑎 𝑏 |𝑚 ≥ 0‬עוד יותר מהר? בזמן )𝑛 ‪?𝑜(𝑛 log‬‬
‫תשובה‪ :‬לא במכונה עם סרט אחד! ‪.‬‬
‫משפט ‪ :2‬שפה שניתנת להכרעה בזמן ))𝑛(‪ 𝑂(𝑛 · log‬במכונה עם סרט אחד היא בהכרח רגולרית‪.‬‬
‫דוגמה ‪ - 3‬מכונה עם שני סרטים‬

‫𝑚 𝑚‬
‫למה שלא נבנה מכונה עם שני סרטים להכרעת השפה }‪?𝐿1 = {𝑎 𝑏 |𝑚 ≥ 0‬‬
‫𝑚 𝑚‬
‫תארו מכונה עם שני סרטים להכרעת }‪ 𝐿1 = {𝑎 𝑏 |𝑚 ≥ 0‬והראו שזמן הריצה שלה הוא )𝑛(𝑂‪.‬‬
‫אלגוריתם‪ :‬המכונה ‪ 𝑀3‬על הקלט 𝑤 תבצע‪:‬‬
‫‪ .1‬עבור על סרט הקלט (סרט ‪:)1‬‬
‫‪ .a‬סרוק עד ה‪ 𝑏-‬הראשון וממנו העתק את כל ה‪-𝑏-‬ים לסרט השני‪.‬‬
‫‪ .b‬אם במהלך ההעתקה נפגשת ב‪ 𝑎-‬לאחר ה‪-𝑏-‬ים ‪ -‬אז דחה‪.‬‬
‫‪ .2‬עבור במקביל על סרט ‪ 1‬וסרט ‪:2‬‬
‫‪ .a‬אם מספר התא של ה‪ 𝑏‾-‬הראשון של הסרט הראשון הוא גם מספר התא של ה‪ 𝑏‾-‬הראשון של‬
‫הסרט השני ‪ -‬אז קבל‪.‬‬
‫‪ .b‬אחרת ‪ -‬דחה‪.‬‬
‫זמן ריצה‪ :‬מבצעים מעברים ליניאריים על הסרטים ולכן זמן הריצה של ‪ 𝑀3‬הוא )𝑛(𝑂‪.‬‬
‫במכונה חד‪-‬סרטית הזמן הטוב ביותר הוא ))𝑛(‪.𝑂(𝑛 · log‬‬
‫הבדל בין חישוביות וסיבוכיות‬

‫בחישוביות‪ :‬כל המודלים הסבירים שקולים ולכן כל מה שאפשרי לביצוע באחד המודלים אפשרי לביצוע גם בכל‬
‫המודלים האחרים‪.‬‬
‫בסיבוכיות‪ :‬גם אם המודלים ‪ 𝑀1, 𝑀2‬שקולים‪( ,‬בה"כ) בחירת ‪ 𝑀1‬משפיעה על זמן הריצה מבחירת ‪.𝑀2‬‬
‫כלומר‪ ,‬בסיבוכיות לבחירת המודל יש השפעה על זמן הריצה‪.‬‬
‫בעיה‪ :‬תלות במודל‬

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

‫כדי לחקות צעד אחד של פעולת המכונה‬
‫𝑀 (רב סרטית)‪ ,‬המכונה 𝑆 (החד‪-‬סרטית)‬
‫עוברת על הסרט שלה מספר פעמים‬
‫שחסום על ידי קבוע‪.‬‬
‫אם מספר הצעדים של 𝑀 הוא )𝑛(𝑡‪ ,‬אז‬
‫מספר התאים המקסימלי שעליהם הראש של 𝑆 עובר במעבר אחד על הסרט הוא ))𝑛(𝑡(𝑂‪.‬‬
‫למה? ‪ -‬כי הוכחנו בתחילת הקורס עבור שקילות רב‪-‬סרטי‪ ,‬שהמכונה החד‪-‬סרטית תעתיק לימין כל סרט מהרב‬
‫סרטי לסרט היחיד שלה‪ ,‬ועבור כל העתקה חדשה היא תכתוב בסימן מיוחד ש‪" :‬כאן מתחיל סרט כלשהו"‪..‬‬
‫כלומר המכונה החד‪-‬סרטית תכיל "שרשור" של סרטים מהרב סרטי‪ .‬לכן‪ ,‬מספר הצעדים של 𝑀 הוא יהיה מספר‬
‫התאים המקסימלי של הסרט של 𝑆‪.‬‬
‫‪2‬‬
‫מסקנה‪ :‬זמן הסימולציה של מכונה מרובת סרטית ע"י מכונה חד‪-‬סרטית הוא ריבועי לכל היותר‪.𝑂(𝑡(𝑛) ) :‬‬
‫למה?‪ :‬כי לכל סרט 𝑖 ב‪ ,𝑀-‬צריך לעבור ב‪ 𝑆-‬על כל ה‪ 1 ≤ 𝑗 ≤ 𝑖-‬סרטים כדי לגשת אליו‪.‬‬
‫הפער הריבועי הוא הדוק‬

‫כמו שראינו‪ ,‬הפער בין מכונה מרובת סרטים למכונה עם סרט אחד הוא לכל היותר ריבועי‪.‬‬
‫למעשה‪ ,‬יש שפות שהוכח עליהן שזהו הפער‪.‬‬
‫למשל‪ ,‬שפת הפלינדרומים מעל }𝑏 ‪:{𝑎,‬‬
‫‪ .1‬ניתנת להכרעה במכונה דו‪-‬סרטית בזמן שהוא )𝑛(𝑂‪.‬‬
‫‪2‬‬
‫‪ .2‬ניתנת להכרעה במכונה חד‪-‬סרטית בזמן שהוא ) 𝑛(𝑂‪.‬‬
‫‪2‬‬
‫‪ .3‬לא ניתנת להכרעה במכונה חד‪-‬סרטית בזמן שהוא ) 𝑛(𝑜 ‪ -‬כלומר "או‪-‬קטן"‪.‬‬
‫מודלים לא דטרמיניסטיים‬
‫הראינו שזמן הריצה לא שונה באופן מהותי במודלים דטרמיניסטיים שונים‪.‬‬
‫מצד שני‪ ,‬בחירת מודלים אי‪-‬דטרמיניסטיים היא בחירה קריטית שיכולה להשפיע רבות על זמן הריצה‪.‬‬
‫תחילה עלינו להגדיר מהו זמן הריצה במקרה זה‪ - .‬נדבר רק על מכונות מכריעות‪:‬‬
‫‪ .1‬כל ענפי החישוב מסתיימים בעצירה (במצב המקבל או הדוחה)‪.‬‬
‫‪ .2‬נסתכל על זמן החישוב הארוך ביותר‪.‬‬
‫הגדרה‪ :‬זמן ריצה לא דטרמיניסטי‬

‫תהי 𝑁 מ"ט א"ד ותהי פונקציה ‪ 𝑡: ℕ → ℕ‬המתארת את מספר הצעדים של המכונה‪.‬‬
‫נאמר שזמן הריצה של 𝑁 הוא )𝑛(𝑡‪ ,‬אם לכל קלט 𝑤 באורך 𝑛‪ ,‬מספר צעדי הריצה של 𝑁 על 𝑤 הוא לכל היותר‬
‫)𝑛(𝑡‪ ,‬בכל אחד ממסלולי החישוב של 𝑁 על 𝑤‪.‬‬
‫הערה‪ :‬מסתכלים על זמן הריצה של כל מסלולי החישוב‪ ,‬גם של אלה שמסתיימים בדחייה‪.‬‬
‫דטרמיניסטי ולא דטרמיניסטי‬

‫נשים לב שבמסלולי חישוב לא מקבלים‪ ,‬המכונה הלא‬
‫דטרמיניסטית חייבת להגיע ל‪ 𝑞𝑟𝑒𝑗𝑒𝑐𝑡-‬בתוך מגבלת הזמן‪.‬‬
‫תזכורת לסימולציה‬
‫המכונה הדטרמיניסטית 𝐷 שמסמלצת את המכונה הלא‬
‫דטרמיניסטית 𝑁‪ .‬המכונה 𝐷 שתיארנו בחישוביות לא‬
‫יעילה מבחינת זמן הריצה כי יש בה חזרות על חלקים של‬
‫חישובים‪ .‬אפשר לייעל את פעולתה של 𝐷‪ ,‬אך עדיין זמן‬
‫הריצה של כל סימולציה אפשרית של מכונה לא‬
‫דטרמיניסטית על ידי מכונה דטרמיניסטית הוא לפחות‬
‫מעריכי (אקספוננציאלי) בזמן הריצה של המכונה הלא‬
‫דטרמיניסטית‪ .‬כי אם אנחנו סורקים בצורה‬
‫דטרמיניסטית את המכונה האי דטרמיניסטית אז אנחנו‬
‫בעץ ולכן זו סריקה בזמן אקספוננציאלי‪.‬‬
‫זמן הריצה של מכונה א"ד מכריעה 𝑁 על מילה 𝑤 מוגדר כמספר הצעדים במסלול החישוב הארוך‬ ‫‪-‬‬
‫ביותר של 𝑁 על 𝑤 (מקבל או דוחה)‪.‬‬
‫אבחנה חשובה‬
‫● יש לכל היותר פער פולימוניאלי בין מכונה‬
‫מרובת סרטים למכונה עם סרט אחד‪.‬‬
‫● יש לכל היותר פער אקספוננציאלי בין מכונה‬
‫א"ד למכונה דטרמיניסטית‪.‬‬
‫● יש הבדל עצום בין הגידול של זמני ריצה‬
‫‪3‬‬
‫פולינומיאליים טיפוסיים כמו 𝑛 לבין הגידול‬
‫של זמני ריצה אקספוננציאליים טיפוסיים‬
‫𝑛‬
‫כמו ‪.2‬‬
‫אקספוננציאלי לעומת פולינומיאלי‬

‫● זמן ריצה אקספוננציאלי מצביע‪ ,‬על סריקה ממצה של כל מרחב הפתרונות (למשל חיפוש שלם)‪.‬‬
‫● זמן ריצה פולינומיאלי מצביע על הבנה מעמיקה יותר של הבעיה‪.‬‬
‫● כל המודלים החישוביים הדטרמיניסטיים "הסבירים" שקולים פולינומיאלית‪.‬‬
‫כל אחד מהם יכול לסמלץ כל אחד אחר בהפסק זמן פולינומי‪ .‬הפסק הזמן הוא לא יותר מאשר ריבועי‪.‬‬
‫השגת אי‪-‬תלות במודל‬

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

‫𝑐‬
‫● מ"ט דטרמיניסטית 𝑀 תקרא פולינומית‪ ,‬אם קיים פולינום 𝑛 = )𝑛(𝑝 עבור ‪ 𝑐 ∈ ℝ‬כך שלכל מילה‬
‫⋆‬
‫‪ ,𝑥 ∈ Σ‬המכונה 𝑀 עוצרת על 𝑥 בתוך לכל היותר )|𝑥|(𝑝 צעדים‪.‬‬
‫● במילים‪ :‬מ"ט דטרמיניסטית 𝑀 תקרא פולינומית‪ ,‬אם יש איזשהו פולינום )𝑛(𝑝 שחוסם את זמן הריצה של‬
‫⋆‬
‫𝑀 לכל קלט ‪.𝑥 ∈ Σ‬‬
‫⋆‬ ‫𝑐‬
‫● מ"ט א"ד 𝑀 תקרא פולינומית‪ ,‬אם קיים פולינום 𝑛 = )𝑛(𝑝 עבור ‪ 𝑐 ∈ ℝ‬כך שלכל מילה ‪,𝑥 ∈ Σ‬‬
‫המכונה 𝑀 עוצרת על 𝑥 בתוך לכל היותר )|𝑥|(𝑝 צעדים‪ ,‬בכל מסלולי החישוב שלה‪.‬‬
‫𝑐‬
‫● הפולינום 𝑛 = )𝑛(𝑝 יקרא חסם זמן הריצה של 𝑀‪.‬‬
‫מבנה הוכחת נכונות של מכונה פולינומית‬

‫מכונה דטרמיניסטית פולינומית מכריעה‪:‬‬
‫‪ .1‬הוכחת נכונות‪:‬‬
‫‪𝑀(𝑥) = 1 ← 𝑥 ∈ 𝐿 .a‬‬
‫‪𝑀(𝑥) = 0 ← 𝑥 ∉ 𝐿 .b‬‬
‫‪ .2‬הוכחת סיבוכיות‪ :‬להוכיח שלכל קלט 𝑥‪ ,‬זמן הריצה של המכונה על 𝑥 חסום ע"י פולינום כלשהו )|𝑥|(𝑝‪.‬‬
‫מכונה א"ד פולינומית מכריעה‪:‬‬

‫‪ .1‬הוכחת נכונות‪:‬‬
‫‪ ← 𝑥 ∈ 𝐿 .a‬אז קיים מסלול מקבל בעץ החישוב של המכונה על 𝑥‪.‬‬
‫‪ ← 𝑥 ∉ 𝐿 .b‬אז כל המסלולים בעץ החישוב של המכונה על 𝑥 דוחים‪.‬‬
‫‪ .2‬הוכחת סיבוכיות‪ :‬להוכיח שלכל קלט 𝑥‪ ,‬ולכל מסלול בעץ החישוב‪ ,‬זמן הריצה של המכונה על 𝑥 חסום‬
‫ע"י פולינום כלשהו )|𝑥|(𝑝‪.‬‬
‫המחלקות ‪ P‬ו‪NP-‬‬
‫הגדרה‪ :‬המחלקה ‪P‬‬
‫הגדרה‪ :‬המחלקה 𝑃 היא מחלקת השפות כך שלכל שפה‪:‬‬
‫‪ .1‬יש מכונת טיורינג דטרמיניסטית מכריעה‪.‬‬
‫‪ .2‬זמן הריצה של המכונה הוא פולינומיאלי (בגודל הקלט)‪.‬‬
‫𝑘‬
‫) 𝑛(𝐸𝑀𝐼𝑇𝐷 ‪𝑃 = ∪𝑘≥0‬‬
‫הסבר‪ 𝐿 ∈ 𝑃 :‬אם יש אלגוריתם בעל זמן ריצה פולינומיאלי להכרעת השייכות ל‪.𝐿-‬‬
‫𝑘‬
‫כלומר‪ ,‬קיים אלגוריתם שזמן ריצתו ) 𝑛(𝑂 ל‪ 𝑘-‬קבוע טבעי כלשהו‪.‬‬
‫חשיבות המחלקה ‪P‬‬

‫המחלקה 𝑃 היא מחלקה חשובה של שפות‪.‬‬
‫‪ .1‬שייכות של שפה למחלקה 𝑃 לא תלויה במודל (במספר הסרטים של המכונה שמכריעה שייכות לשפה)‪.‬‬
‫‪ .2‬שייכות של שפה למחלקה 𝑃 לא תלויה במודל החישובי‪ ,‬כל עוד הוא שקול פולינומיאלי למ"ט‪.‬‬
‫‪ .3‬המחלקה 𝑃 מתאימה למחלקת הבעיות הפתירות באופן מעשי במחשב (כל מה שאנחנו יודעים‬
‫לפתור‪ ,‬למשל 𝑎𝑟𝑡𝑠𝑘𝑗𝑖𝐷 ‪ 𝐵𝐹𝑆, 𝐷𝐹𝑆,‬נמצאות ב‪ 𝑃-‬כי הם פתירות באופן מעשי)‪.‬‬
‫המחלקה מתאימה למציאות‬

‫‪100‬‬
‫𝑛(𝑂 גם ב‪?𝑃-‬‬ ‫שאלה‪ :‬האם )‬
‫תשובה‪ :‬כן‪ .‬זה ייחשב בזמן ריצה פולינומיאלי‪ .‬אבל במציאות זמן הריצה של אלגוריתמים הוא או פולינומיאלי‬
‫עם פולינום צנוע או על‪-‬פולינומיאלי (אקספוננציאלי)‪.‬‬
‫הערה‪ :‬הניסיון מראה שהסף שאותו צריך לעבור הוא המעבר מזמן ריצה אקספוננציאלי לפולינומיאלי‪.‬‬
‫ברגע שהמעבר הזה קורה‪ ,‬נמצאים אלגוריתמים יותר ויותר יעילים‪.‬‬
‫דוגמאות לבעיות ב‪P-‬‬

‫‪ .1‬אריתמטיקה‪ :‬חיבור‪ ,‬חיסור‪ ,‬כפל‪ ,‬חילוק עם שארית וכו'‪...‬‬
‫‪ .2‬מספרים‪ :‬מציאת מחלק משותף מקסימלי (𝐷𝐶𝐺)‪.‬‬
‫‪ .3‬חקר ביצועים‪ :‬זרימה ברשתות‪ ,‬תכנון ליניארי‪.‬‬
‫‪ .4‬אלגברה‪ :‬כפל מטריצות‪ ,‬דטרמיננטות וכו'‪...‬‬
‫‪ .5‬גרפים‪ ,𝐷𝐹𝑆, 𝐵𝐹𝑆 :‬מציאת עץ פורש מינימלי (קרוסקל)‪ ,‬מעגל אוילר ועוד…‬
‫ניתוח טיפוסי של זמן ריצה‬

‫‪ .1‬מחלקים את האלגוריתם לשלבים‪.‬‬
‫‪ .2‬מראים שזמן הריצה של כל שלב פולינומיאלי‪.‬‬
‫‪ .3‬מראים שמספר הפעמים שכל שלב מתבצע הוא פולינומיאלי‪.‬‬
‫‪ .4‬מסיקים שזמן הריצה של האלגוריתם כולו פולינומיאלי‪:‬‬
‫‪ .a‬סכום של פולינומים הוא פולינום‪.‬‬
‫‪ .b‬כפל של פולינומים הוא פולינום‪.‬‬
‫‪ .c‬הרכבת פולינומים הוא פולינום‪.‬‬
‫קידוד הקלט‬
‫זמן הריצה מוגדר כפונקציה של גודל הקלט (מספר הביטים)‪ .‬לכן‪ ,‬צריך לבחור קידוד סביר לקלט ולא קידוד‬
‫שיגדיל באופן מלאכותי את גודל הקלט‪( .‬למרות שמלאכותי זמן הריצה ייראה טוב יותר ‪ -‬זה נקרא "ריפוד")‪.‬‬
‫דוגמה ‪ -‬קידוד של גרף‪ :‬רשימה של צמתים ורשימה של קשתות‪ ,‬או מטריצת שכנויות‪.‬‬
‫‪ .1‬אפשר לעבור מקידוד מסוים לקידוד אחר בזמן פולינומיאלי‪ ,‬והגודל של כל קידוד פולינומיאלי בגודל‬
‫של הקידוד האחר‪.‬‬
‫‪ .2‬אנחנו רגילים לחשב את זמן הריצה כפונקציה של מספר הצמתים‪ .‬זה לא גודל הקלט‪ ,‬אבל גודל‬
‫‪2‬‬
‫הקלט פולינומיאלי במספר הזה‪ .‬למשל גרף הנתון כמטריצת שכנויות‪ :‬גודל הקלט‪.𝑂(|𝑉| ) :‬‬
‫דוגמה‪ :‬מספרים יכולים להיות מיוצגים בבינארי או בעשרוני‪ ,‬אבל לא באונרי‪.‬‬

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

‫כל ההכלות בין המחלקות הן הכלות ממש‪.‬‬
‫למה 𝑃 בתוך 𝑅? ‪ -‬כי אמרנו ש‪ 𝑃-‬זה מחלקה של שפות כך‬
‫שלכל שפה קיימת מ"ט דטרמיניסטית פולינומית המכריעה‬
‫אותה‪ .‬לכן‪ ,‬כל 𝑃 נמצא ב‪ .𝑅-‬נשים לב ש‪ 𝑃 ⊂ 𝑅 :‬כלומר‬
‫𝑅 ≠ 𝑃‪.‬‬
‫דוגמה עם הסבר (לא מההרצאה)‬

‫בעיית ה‪ 𝑃𝐴𝑇𝐻-‬נועדה כדי להכריע האם קיים מסלול מכוון בגרף בין הצמתים 𝑠 ל‪.𝑡-‬‬
‫}𝑡 𝑜𝑡 𝑠 𝑚𝑜𝑟𝑓 ‪𝑃𝐴𝑇𝐻 = {< 𝐺, 𝑠, 𝑡, > | 𝐺 𝑖𝑠 𝑎 𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ𝑎𝑡 ℎ𝑎𝑠 𝑎 𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑝𝑎𝑡ℎ‬‬
‫טענה‪.𝑃𝐴𝑇𝐻 ∈ 𝑃 :‬‬
‫רעיון ההוכחה‪ :‬נוכיח את הטענה ע"י הצגת אלגוריתם (מכונה) מכריע לשפה 𝐻𝑇𝐴𝑃 בזמן ריצה פולינומי‪.‬‬
‫לפני שנתאר את האלגוריתם‪ ,‬נראה למה אלגוריתם 𝑒𝑐𝑟𝑜𝐹 𝑒𝑡𝑢𝑟𝐵 לא מהיר מספיק עבור הבעיה הזאת‪.‬‬
‫אלגוריתם 𝑒𝑐𝑟𝑜𝐹 𝑒𝑡𝑢𝑟𝐵 עבור 𝐻𝑇𝐴𝑃 בוחן את כל המסלולים הפוטנציאלים ב‪ 𝐺-‬וקובע האם אחד מהם יש‬
‫מסלול מכוון בין 𝑠 ל‪ .𝑡-‬מסלול פוטנציאלי הוא סדרה של צמתים ב‪ 𝐺-‬באורך של לכל היותר 𝑚 = |)𝐺(𝑉|‪.‬‬
‫𝑚‬
‫אבל מספר המסלולים הפוטנציאלים האלה הם לכל היותר 𝑚‪ ,‬שזה אקספוננציאלי במספר הצמתים ב‪.𝐺-‬‬
‫לכן‪ ,‬אלגוריתם 𝑒𝑐𝑟𝑜𝐹 𝑒𝑡𝑢𝑟𝐵 משתמש בזמן ריצה אקספוננציאלי ‪ -‬לא רלוונטי לפתרון שלנו‪.‬‬
‫כדי ליצור אלגוריתם (מכונה) מכריע עבור 𝐻𝑇𝐴𝑃 בזמן ריצה פולינומי‪ ,‬אנחנו חייבים למנוע ממנו להיות‬
‫𝑒𝑐𝑟𝑜𝐹 𝑒𝑡𝑢𝑟𝐵‪ .‬אחת הדרכים למנוע דבר כזה הוא באמצעות שיטה לחיפוש בגרף בשם 𝑆𝐹𝐵‪ .‬כאן‪ ,‬אנחנו נסמן‬
‫את כל הצמתים לאורך המסלול המכוון החל מ‪ .𝑠-‬ככה אפשר יהיה לחסום את זמן הריצה לפולינומיות‪.‬‬
‫הוכחה‪ :‬האלגוריתם 𝑀 על 𝐻𝑇𝐴𝑃 עובד בזמן פולינומי לפי התיאור הבא‪:‬‬
‫המכונה 𝑀 על הקלט > 𝑡 ‪ < 𝐺, 𝑠,‬מבצעת‪:‬‬
‫‪ .1‬סמן את הצומת ההתחלתית 𝑠‪.‬‬
‫‪ .2‬חזור על השלבים הבאים עד שלא נותרו צמתים נוספים לסימון‪:‬‬
‫עבור על כל הצלעות של 𝐺‪ .‬אם צומת )𝑏 ‪ (𝑎,‬נמצאה שעוברת מהצומת המסומנת 𝑎 לצומת‬ ‫‪.3‬‬
‫הלא‪-‬מסומנת 𝑏‪ ,‬אז סמן גם את 𝑏‪.‬‬
‫‪ .4‬אם 𝑡 סומנה‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫כעת ננתח את האלגוריתם כדי להראות שהוא רץ בזמן פולינומי‪ .‬שלבים ‪ 1‬ו‪ 4-‬פועלים רק פעם אחת‪ .‬שלב ‪ 3‬רץ‬
‫לכל היותר |)𝐺(𝑉| פעמים כי בכל צעד חוץ מהאחרון‪ ,‬נסמן צומת נוספת‪ .‬לכן‪ ,‬מספר הצעדים הוא לכל היותר‬
‫‪ ,|𝑉(𝐺)| + 1 + 1‬שזה פולינומיאלי בגודל של 𝐺‪ .‬שלב ‪ 3‬מבצע חיפוש בהתאם לקלט ובוחן האם צמתים‬
‫מסוימים סומנו‪ ,‬לכן זה ניתן למימוש בזמן פולינומי‪.‬‬
‫ומכאן 𝑀 הוא אלגוריתם בזמן פולינומי המכריע את השפה 𝐻𝑇𝐴𝑃‪ ,‬כלומר 𝑃 ∈ 𝐻𝑇𝐴𝑃‪.‬‬
‫תכונות סגירות של ‪P‬‬

‫תרגיל‪ :‬הוכיחו שהמחלקה 𝑃 סגורה ל‪:‬‬
‫‪ .1‬איחוד‬
‫‪ .2‬חיתוך‬
‫‪ .3‬משלים‬
‫‪ .4‬שרשור ‪ -‬אם יש ‪ 2‬בעיות שצריך לפתור ואנחנו משרשרים אותם‪ ,‬אז יש לנו אלגוריתם פולינומים לבעיה‬
‫הראשונה‪ ,‬נריץ אותה‪ :‬אם תקין‪ ,‬אז נעבור לאלגוריתם הפולינומי של המכונה השניה ונריץ גם אותו‪ :‬אם‬
‫תקין אז גם נשארנו פולינומי ולכן נשארנו ב‪.𝑃-‬‬
‫‪ .5‬איטרציה ‪ -‬בעזרת אלגוריתם מסוג תכנות דינאמי (לא צריך להוכיח את זה בקורס)‪.‬‬
‫הערה‪ ,𝑃 ≠ 𝑅 :‬כי 𝑅 ⊂ 𝑃‪.‬‬
‫המחלקה ‪NP‬‬
‫תזכורת ‪ -‬מחלקת השפות לדטרמיניסטי‪ :‬תהי פונקציה ‪ .𝑡: ℕ → ℕ‬נסמן ב‪ 𝐷𝑇𝐼𝑀𝐸(𝑡(𝑛))-‬את מחלקת‬
‫השפות שיש להן מכונת טיורינג דטרמיניסטית מכריעה שזמן הריצה שלה הוא ))𝑛(𝑡(𝑂‪.‬‬
‫פורמלית‪.𝐷𝑇𝐼𝑀𝐸(𝑡(𝑛)) = {𝐿 | 𝐿 𝑖𝑠 𝑎 𝑙𝑎𝑛𝑔𝑢𝑎𝑔𝑒, 𝑑𝑒𝑐𝑖𝑑𝑒𝑑 𝑏𝑦 𝑎𝑛 𝑂(𝑡(𝑛)) − 𝑡𝑖𝑚𝑒 𝐷𝑇𝑀} :‬‬
‫הגדרה ‪ -‬מחלקת השפות לא"ד‪ :‬תהי פונקציה ‪ .𝑡: ℕ → ℕ‬נסמן ב‪ 𝑁𝑇𝐼𝑀𝐸(𝑡(𝑛))-‬את מחלקת השפות שיש‬
‫להן מכונת טיורינג לא דטרמיניסטית מכריעה שזמן הריצה שלה הוא ))𝑛(𝑡(𝑂‪.‬‬
‫פורמלית‪.𝑁𝑇𝐼𝑀𝐸(𝑡(𝑛)) = {𝐿 | 𝐿 𝑖𝑠 𝑎 𝑙𝑎𝑛𝑔𝑢𝑎𝑔𝑒, 𝑑𝑒𝑐𝑖𝑑𝑒𝑑 𝑏𝑦 𝑎𝑛 𝑂(𝑡(𝑛)) − 𝑡𝑖𝑚𝑒 𝑁𝑇𝑀} :‬‬
‫תזכורת‪ :‬זמן הריצה של מכונה א"ד מוגדר לפי מסלול החישוב הארוך ביותר על המילה‪.‬‬
‫הגדרה‪ :‬המחלקה 𝑃𝑁 היא מחלקת השפות כך שלכל שפה‪:‬‬

‫‪ .1‬יש מכונת טיורינג לא‪-‬דטרמיניסטית מכריעה‪.‬‬
‫‪ .2‬זמן הריצה של המכונה הוא פולינומיאלי (בגודל הקלט)‪.‬‬
‫𝑘‬
‫) 𝑛(𝐸𝑀𝐼𝑇𝑁 ‪𝑁𝑃 = ∪𝑘≥0‬‬
‫הסבר לא פורמלי של ‪" - NP‬עד" ומוודא ‪Validator -‬‬

‫השפה 𝑃𝑁 ∈ 𝐿 אם לכל מילה 𝐿 ∈ 𝑤 יש דרך לוודא במהירות ש‪ 𝑤-‬שייכת לשפה הזאת‪.‬‬
‫‪" .1‬במהירות" == בזמן פולינומיאלי בגודל הקלט‪.‬‬
‫‪ .2‬לכל מילה בשפה יש "תעודת שייכות" שמשכנעת שהמילה שייכת לשפה‪.‬‬
‫‪ .3‬לכל מילה שלא שייכת לשפה אין תעודת שייכות כזאת‪.‬‬
‫‪ .4‬לפעמים נקרא לתעודה זו "עד" או באנגלית‪.witness :‬‬
‫תעודת שייכות‬
‫אמרנו שלכל מילה בשפה יש "תעודת שייכות" שמשכנעת שהמילה שייכת לשפה‪.‬‬
‫למשל‪ ,‬באלגוריתם למציאת מעגל המילטון בגרף‪ ,‬נרצה לנחש את פרמוטציית הסידור הנכונה מתוך כל ה‪|𝑉|!-‬‬
‫פרמוטציות‪ ,‬שתגיד לנו "קיים מעגל המילטון בגרף"‪.‬‬
‫● אם המילה בשפה‪ ,‬אז הסידור שניחשנו הוא "תעודת השייכות" שלנו שמשכנעת ש‪.< 𝐺 >∈ 𝐿 :‬‬
‫● אם המילה לא בשפה‪ ,‬אז לא משנה איזה "עד" ניתן‪ ,‬לא קיימת אף "תעודת שייכות" שתשתכנע אותנו‬
‫שאכן קיים מעגל המילטון בגרף ומכאן 𝐿 ∉> 𝐺 <‪ .‬כלומר לא משנה איזה סידור ננחש‪ ,‬לעולם לא‬
‫קיים מעגל המילטון בגרף‪.‬‬
‫תכונות של המחלקות ‪P,NP‬‬

‫תכונה ‪ 𝑃 ⊆ 𝑅 :1‬וגם 𝑅 ⊆ 𝑃𝑁‪.‬‬
‫הסבר ‪ :1‬מכיוון ששתי ההגדרות של 𝑃 ו‪ 𝑁𝑃-‬מתייחסות למ"ט המכריעות שפות‪ ,‬אז הם מוכלות ב‪.𝑅-‬‬
‫תכונה ‪.𝑃 ⊆ 𝑁𝑃 :2‬‬

‫רעיון הוכחת תכונה ‪ :2‬הוכחנו שהמודל הדטרמיניסטי שקול למודל הלא דטרמיניסטי‪ .‬ובפרט‪ ,‬ראינו שקל‬
‫להפוך כל מכונה דטרמיניסטית למכונה לא דטרמיניסטית‪ .‬אבל‪ ,‬כעת צריך לשים לב לחסם הפולינומי לזמן‬
‫הריצה של המכונה‪.‬‬
‫הוכחת תכונה ‪ :2‬תהי 𝑃 ∈ 𝐿 ותהי 𝐿𝑀 מ"ט דטרמיניסטית פולינומית המכריעה את 𝐿‪.‬‬
‫יהי )𝑛(𝑝 חסם בזמן הריצה הפולינומי של 𝐿𝑀‪.‬‬
‫‪ .1‬נתאר מכונה א"ד פולינומית '𝐿𝑀 המכריעה את 𝐿‪.‬‬
‫‪ .2‬המכונה '𝐿𝑀 תהיה זהה ל‪ 𝑀𝐿-‬למעט שינוי פורמלי בהגדרת פונקציית המעברים של המכונה 𝐿𝑀 (כדי‬
‫שתתאים למודל הא"ד)‪.‬‬
‫⋆‬
‫‪ .3‬נשים לב שלכל קלט ‪ 𝑥 ∈ Σ‬עומק העץ חסום ע"י החסם של המכונה המקורית‪.𝑝(|𝑥|) ,‬‬
‫~‬
‫● 𝐿 ∈ 𝑥 ← ‪ ← 𝑀𝐿(𝑥) = 1‬קיים מסלול בעץ ‪ δ‬כך ש‪.𝑀𝐿'(𝑥) = 1 :‬‬
‫~‬
‫● 𝐿 ∉ 𝑥 ← ‪ ← 𝑀𝐿(𝑥) = 0‬לכל מסלול בעץ ‪ δ‬כך ש‪.𝑀𝐿'(𝑥) = 0 :‬‬
‫האם 𝑃 ⊆ 𝑃𝑁?‬
‫במילים אחרות ‪ -‬האם אפשר להמיר מ"ט א"ד פולינומית למ"ט דטרמיניסטית פולינומית?‪.‬‬
‫תשובה‪ :‬לא ידוע‪ .‬כשהוכחנו בשיעור הקודם (של מ"ט א"ד) ראינו שניתן לסמלץ מ"ט א"ד ע"י מ"ט‬
‫דטרמיניסטית‪ ,‬התעלמנו מכמות המשאבים הדרושים לכך‪ .‬לכן‪ ,‬אם נרצה לסרוק את כל עץ החישוב של‬
‫)𝑛(𝑝‬
‫‪ - Ω(2‬וזה‬ ‫המכונה הלא דטרמיניסטית הפולינומית‪ ,‬נקבל זמן ריצה פרופורציונלי לגודל העץ‪ ,‬כלומר )‬
‫אקספוננציאלי!‪ .‬השאלה הזו נקראת שאלת ‪ ?P=NP‬זו שאלה פתוחה במדמ"ח שלא הצליחו להוכיח‪/‬להפריך‪.‬‬
‫דוגמא לשפה ב‪( NP-‬השפה ‪)IS‬‬

‫הגדרה‪ :‬בתורת הגרפים‪ ,‬קבוצה בלתי תלויה (‪ )IS - Independent set‬היא‬
‫קבוצת קודקודים בגרף‪ ,‬אשר אין זוג מביניהם המחוברים ישירות דרך קשת אחת‪.‬‬
‫למשל בציור משמאל‪ :‬כל הצמתים הכחולים נמצאים בקבוצה 𝑆𝐼 כי בין כל צומת‬
‫כחול אין שכן שהוא גם כחול‪.‬‬
‫}𝑘 𝑒𝑧𝑖𝑠 𝑓𝑜 𝑡𝑒𝑠 𝑡𝑛𝑒𝑑𝑛𝑒𝑝𝑒𝑑𝑛𝑖 𝑛𝑎 𝑠𝑛𝑖𝑎𝑡𝑛𝑜𝑐 𝑡𝑎‪.𝐼𝑆 = {< 𝐺, 𝑘 > | 𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ‬‬
‫טענה ‪.𝐼𝑆 ∈ 𝑅 :1‬‬

‫רעיון ההוכחה ‪ - 1‬אלגוריתם חיפוש שלם ‪-‬‬
‫אפשרויות לבחירת 𝑘 קודקודים מהגרף‪.‬‬ ‫אלגוריתם של חיפוש מלא יכול לעבור על כל ה‪( ) -‬‬
‫𝑛‬
‫𝑘‬ ‫‪.1‬‬
‫‪ .2‬לכל אפשרות כזו‪ ,‬לבדוק האם היא קבוצה ב"ת (לבדוק שכל זוג צמתים בקבוצה לא מחוברים בצלע)‪.‬‬
‫‪ .3‬אם מצאנו אפשרות שכזו ‪ -‬קבל‪.‬‬
‫‪ .4‬אם עברנו על כל האפשרויות ולא מצאנו ‪ -‬דחה‪.‬‬
‫תתי קבוצות בגודל 𝑘‪ ,‬איזה אחד מהם אנחנו צריכים? ‪ -‬אנחנו צריכים לעבור על כולם ולכן‬ ‫הערה ‪ :1‬יש לנו ) (‬
‫𝑛‬
‫𝑘‬
‫)(‬
‫𝑛‬
‫𝑘‬
‫‪ 2‬בחיפוש שלם‪.‬‬ ‫צריך לעבור על‬
‫טענה ‪.𝐼𝑆 ∈ 𝑁𝑃 :2‬‬

‫רעיון ההוכחה ‪ :2‬במקום חיפוש מלא‪ ,‬ניתן לנחש קבוצה המועמדת להיות קבוצה ב"ת בגרף ולבדוק רק אותה‪.‬‬
‫הערה ‪ :2‬אם שפה ב‪ 𝑁𝑃-‬אז יש לנו "תעודת שייכות" שיגיד "אני ב‪ ,"𝑁𝑃-‬במקרה שלנו מהי התעודה?‪" :‬קבוצה‬
‫של 𝑘 קודקודים"‪ .‬מ"ט תריץ מסלול פשוט‪ .1 :‬לעבור על ה‪ 𝑘-‬צמתים מהקבוצה‪ .2 .‬לכל צומת לוודא שאין‬
‫‪2‬‬ ‫‪2‬‬
‫|‬ ‫|‬
‫שכנים בקבוצה‪ .‬לכן זמן הריצה במקרה זה יהיה ) 𝑘(𝑂‪ .‬אם כך‪ 𝑘 ≤ |𝑉(𝐺)| ,‬וגם ) )𝐺(𝑉 (𝑂 = |𝐺|‪.‬‬
‫הוכחה פורמלית של טענה ‪ :2‬נתאר מ"ט א"ד פולינומית המכריעה את השפה 𝑆𝐼‪ .‬נוכיח ש‪.𝐼𝑆 ∈ 𝑁𝑃 :‬‬
‫אלגוריתם‪ 𝑁 :‬על קלט > 𝑘 ‪ < 𝐺,‬תבצע‪:‬‬
‫‪ .1‬נחש תת קבוצה 𝑆 של צמתי 𝐺‪( .‬בדוק שגודל הקבוצה הינו 𝑘)‪.‬‬
‫‪ .2‬לכל זוג צמתים מהקבוצה 𝑆 ∈ ‪ ,𝑣1, 𝑣2‬בדוק שאכן )𝐺(𝐸 ∉ }‪.{𝑣1, 𝑣2‬‬
‫‪ .a‬אם לאחת הצלעות גילינו ש‪ - {𝑣1, 𝑣2} ∈ 𝐸(𝐺) :‬אז דחה‪.‬‬
‫‪ .3‬אם עברנו על כל הזוגות ולא דחינו ‪ -‬אז קבל‪.‬‬
‫נכונות האלגוריתם‪:‬‬
‫● אם 𝑆𝐼 ∈> 𝑘 ‪ < 𝐺,‬אזי קיימת תת‪-‬קבוצה 𝑉 ⊆ 𝑆 בגודל 𝑘 שהיא ב"ת‪ ← .‬קיים מסלול חישוב שבו‬
‫המכונה 𝑁 מנחשת בדיוק את הקבוצה 𝑆 ← במסלול זה‪ ,‬הבדיקה של 𝑁 על הקבוצה 𝑆 יוצאת תקינה‬
‫ולכן 𝑁 מקבלת‪ ← .‬קיים מסלול מקבל‪ < 𝐺, 𝑘 >∈ 𝐿(𝑁) ← .‬כנדרש‪.‬‬
‫● אם 𝑆𝐼 ∉> 𝑘 ‪ < 𝐺,‬אזי לכל תת‪-‬קבוצה 𝑉 ⊆ 𝑆 בגודל 𝑘 שהיא תלויה‪ ← .‬לכל ניחוש של קבוצה 𝑆‪,‬‬
‫המכונה 𝑁 תזהה שקיימת צלע ב‪ 𝑆-‬ותדחה ← כל המסלולים דוחים ← )𝑁(𝐿 ∉> 𝑘 ‪ < 𝐺,‬כנדרש‪.‬‬
‫הוכחנו כי )𝑁(𝐿 = 𝑆𝐼 ולכן המכונה 𝑁 אכן מכריעה את השפה 𝑆𝐼‪.‬‬
‫סיבוכיות האלגוריתם‪ :‬הסיבוכיות של ניחוש הוא כגודל הניחוש (במקרה זה )𝑘(𝑂)‪.‬‬
‫‪2‬‬
‫● גודל הקלט‪( - 𝑂(𝑛 ) :‬מטריצת שכנויות) כאשר 𝑛 הינו מספר הצמתים בגרף הנתון‪.‬‬
‫● נניח כי 𝑛 ≤ 𝑘‪.‬‬
‫● בשלב ‪ :1‬ניחוש קבוצה בגודל 𝑘 עולה לנו )𝑘(𝑂‪.‬‬
‫𝑂 זוגות של צמתים‪.‬‬ ‫)) ( (‬

‫𝑘‬
‫‪2‬‬
‫‪2‬‬
‫● בשלב ‪ :2‬עוברים על ) 𝑘(𝑂 =‬
‫‪2‬‬ ‫‪2‬‬
‫● סך הכל‪ - 𝑂(𝑘 + 𝑘) = 𝑂(𝑘 ) :‬זמן ריצה פולינומי‪.‬‬
‫∎‬
‫ניסוח שקול לשאלת ‪P=NP‬‬

‫שאלה‪ :‬האם וידוא יעיל גורר חיפוש יעיל?‬
‫תשובה‪ :‬וידוא יעיל הוא מאפיין מרכזי של 𝑃𝑁‪( .‬כלומר‪ ,‬בהינתן הצעה לפתרון אפשרי‪ ,‬ניתן בזמן פולינומי לוודא‬
‫שהפתרון המוצע נכון)‪.‬‬
‫דוגמה‪ :‬משחק סודוקו‪ ,‬בהינתן פתרון של סודוקו‪ ,‬אפשר בקלות יחסית (=באופן פולינומי) לוודא שהפתרון נכון‪.‬‬
‫השאלה היא‪ :‬אם התכונה הנ"ל גם אומרת שמציאת הפתרון יכולה להתבצע ביעילות?‬
‫דוגמה לבעיה כריעה שאיננה ב‪ :NP-‬משחק שחמט‪ .‬אם במהלך המשחק יציגו לנו צעד שאותו יש לבצע כדי‬
‫לנצח‪ ,‬אין לנו אפשרות לדעת בקלות שהצעד המדובר באמת יביא לנו ניצחון‪( .‬כלומר גם בדיקה של פתרון‬
‫אופציונלי דורשת הרבה עבודה)‪.‬‬
‫המחלקה ‪coNP‬‬
‫מחלקת השפות 𝑃𝑁𝑜𝑐‪ :‬השפות שהמשלימה שלהן שייכת ל‪ .𝑁𝑃-‬כלומר }𝑃𝑁 ∈ ‾𝐿 |𝐿{ = 𝑃𝑁𝑜𝑐‪.‬‬
‫באופן לא פורמלי‪ ,‬שפה 𝐿 שייכת למחלקה 𝑃𝑁𝑜𝑐 אם לכל מילה 𝑤 שלא שייכת ל‪ 𝐿-‬יש דרך מהירה לוודא ש‪𝑤-‬‬
‫לא שייכת ל‪.𝐿-‬‬
‫תרגיל‪ :‬אלו שפות נראות קשות יותר‪ ,‬אלה שב‪ 𝑁𝑃-‬או אלה שב‪?𝑐𝑜𝑁𝑃-‬‬
‫הקבלה לשפות מתורת החישוביות‬

‫המחלקות 𝑃 ‪ 𝑐𝑜𝑁𝑃, 𝑁𝑃,‬מזכירות מחלקות מתורת החישוביות‪.‬‬
‫● המחלקה 𝑃 מקבילה למחלקת השפות ב‪( .𝑅 -‬כי יש לשפה מכונה מכריעה)‪.‬‬
‫● המחלקה 𝑃𝑁 מקבילה למחלקת השפות ב‪( .𝑅𝐸-‬כי יש לשפה מאמת)‪.‬‬
‫● המחלקה 𝑃𝑁𝑜𝑐 מקבילה למחלקת השפות ב‪.𝑐𝑜𝑅𝐸-‬‬
‫משפט‪( 𝑃 ⊆ 𝑐𝑜𝑁𝑃 :‬ההוכחה בהמשך הקובץ ‪ -‬שאלה ‪ - 11‬תרגול ‪.)5‬‬
‫יחס 𝐿𝑅‬
‫הגדרה‪ :‬שפה 𝑃𝑁 ∈ 𝐿 אם קיים יחס דו‪-‬מקומי 𝐿𝑅 המכיל זוגות )𝑦 ‪ (𝑥,‬כך שמתקיים‪:‬‬
‫‪.𝑥 ∈ 𝐿 .1‬‬
‫‪ 𝑦 .2‬הינו "עד" עבור 𝑥‪( .‬כלומר‪ 𝑦 ,‬הוא אובייקט המעיד על השייכות של 𝑥 לשפה 𝐿)‪.‬‬
‫היחס 𝐿𝑅 מקיים‪:‬‬
‫‪ 𝑅𝐿 .3‬חסום פולינומית‪.‬‬
‫כלומר‪ :‬לכל זוג 𝐿𝑅 ∈ )𝑦 ‪ (𝑥,‬קיים פולינום )·(𝑝 כך שמתקיים‪.|𝑦| ≤ 𝑝(|𝑥|) :‬‬
‫‪ .4‬היחס 𝐿𝑅 ניתן לזיהוי דטרמיניסטי פולינומי‪ .‬כלומר ‪ -‬קיימת מ"ט דטרמיניסטית פולינומית 𝑉 המכריעה‬
‫את היחס (לכל זוג )𝑦 ‪ (𝑥,‬תענה האם 𝐿𝑅 ∈ )𝑦 ‪ (𝑥,‬או 𝐿𝑅 ∉ )𝑦 ‪ .)(𝑥,‬המכונה 𝑉 נקרא מאמת‪.‬‬
‫⋆‬
‫‪ .5‬השפה 𝐿 מקיימת‪.𝐿 = {𝑥 ∈ Σ | ∃𝑦 𝑠. 𝑡. (𝑥, 𝑦) ∈ 𝑅𝐿} :‬‬
‫כלומר לכל מילה בשפה קיים עד פולינומי‪ ,‬ולכל מילה שלא בשפה לא קיים עד פולינומי‪.‬‬
‫)|𝑥|(𝑝‬
‫‪ 𝑦 ∈ Σ‬כך ש‪.(𝑥, 𝑦) ∈ 𝑅𝐿 :‬‬ ‫● 𝐿 ∈ 𝑥 ← קיים פולינום )·(𝑝 וקיים‬
‫)|𝑥|(𝑝‬
‫‪ 𝑦 ∈ Σ‬כך ש‪.(𝑥, 𝑦) ∉ 𝑅𝐿 :‬‬ ‫● 𝐿 ∉ 𝑥 ← לכל פולינום )·(𝑝 ולכל‬
‫במילים‪ :‬נשאל האם הבעיה 𝑥 נפתרת בעזרת העד 𝑦‪ ,‬במידה וכן אז 𝐿𝑅 ∈ )𝑦 ‪ (𝑥,‬ואחרת לא ביחס‪.‬‬
‫הגדרה שקולה‪ 𝐿 ∈ 𝑁𝑃 :‬אם קיימת 𝑉 מכונה מוודאות דטרמיניסטית מכריעה ופולינומית עבור 𝐿‪.‬‬
‫⋆‬
‫קיים פולינום )·(𝑝 וגם עד 𝑦 עבור 𝑉 ו‪ 𝑥-‬כל שלכל ‪ 𝑥 ∈ Σ‬מתקיים‪:‬‬
‫)|𝑥|(𝑝‬
‫}‪𝑥 ∈ 𝐿 ⇔ ∃𝑦 ∈ {0, 1‬‬ ‫‪: 𝑉(𝑥, 𝑦) = 1‬‬
‫)|𝑥|(𝑝‬
‫}‪𝑥 ∉ 𝐿 ⇔ ∀𝑦 ∈ {0, 1‬‬ ‫‪: 𝑉(𝑥, 𝑦) = 0‬‬
‫⋆‬
‫הסבר‪ :‬מכונה מוודאת 𝑉 מקבלת את הקלט ‪ 𝑥 ∈ Σ‬וגם מקבלת באופן חיצוני את 𝑦 שנקרא לו העד‪.‬‬
‫העד 𝑦 עוזר לנו להגיד האם 𝐿 ∈ 𝑥 או לא‪ ,‬כלומר‪ ,‬הוא יתן לנו עדות על השייכות ליחס של השפה‪.‬‬
‫ה‪ 𝑦-‬הוא בעצם איזשהו פרמוטציה של מחרוזת בינארית שנקבל באופן חיצוני לא ידוע‪.‬‬
‫⋆‬
‫למשל עבור השפה }𝑒𝑙𝑐𝑦𝑐 𝑛𝑎𝑖𝑛𝑜𝑡𝑙𝑖𝑚𝑎𝐻 𝑎 𝑠𝑎‪ .𝐻𝐶 = {< 𝐺 > | 𝐺 ℎ‬בהינתן ‪ 𝑥 ∈ Σ‬כלשהו ובהינתן עד‬
‫𝑦 שהגיע באופן חיצוני‪ .‬המוודא ‪ 𝑉(𝑥, 𝑦) = 1‬אם העד 𝑦 מייצג מעגל המילטון (פרמוטציה‪/‬סידור של צמתי‬
‫הגרף) וגם > 𝐺 <= 𝑥‪ .‬כלומר ‪ 𝑉(< 𝐺 >, 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑐𝑦𝑐𝑙𝑒) = 1‬שאכן במקרה זה 𝐶𝐻 ∈> 𝐺 <‪.‬‬
‫חשוב להבין שלא תמיד נקבל 𝑦 שהוא בהכרח מעגל המילטון‪ ,‬יכול להיות שנקבל 𝑦 שידחה‪ .‬כלומר‪ ,‬העד לא‬
‫תמיד מבטיח לנו שהמילה תתקבל בשפה‪ ,‬והאחראי להחלטה הזאת היא המכונה המוודא 𝑉‪.‬‬
‫הוכחת 𝑃𝑁 ∈ 𝑆𝐼 על ידי ההגדרה השנייה‬

‫"עד" עבור השפה 𝑆𝐼 יהיה קבוצה ב"ת בגודל 𝑘‪.‬‬
‫היחס 𝑆𝐼𝑅 מכיל זוגות מהצורה )> 𝑆 < ‪.(< 𝐺, 𝑘 > ,‬‬
‫גודל העד הוא )𝑘(𝑂 ‪ -‬שזה פולינומי בגודל הגרף 𝐺‪.‬‬
‫לפי התנאי השלישי‪:‬‬
‫● אם 𝑆𝐼 ∈> 𝑘 ‪ ← < 𝐺,‬קיימת תת‪-‬קבוצה 𝑉 ⊆ 𝑆 בגודל 𝑘 שהיא ב"ת ← נבחר אותה להיות "העד"‪.‬‬
‫● אם 𝑆𝐼 ∉> 𝑘 ‪ ← < 𝐺,‬לכל תת‪-‬קבוצה 𝑉 ⊆ 𝑆 בגודל 𝑘‪ ,‬מתקיים ש‪ 𝑆-‬היא קבוצה תלויה‪ ← .‬לכל תת‬
‫קבוצה שנבחר להיות "העד"‪ ,‬לא יתקבל זוג אשר שייך ליחס 𝐿𝑅‪.‬‬
‫תרגיל‪ :‬כתבו פסאודו‪-‬קוד של פעולת המאמת 𝑉‪.‬‬
‫טענה‪ :‬שתי ההגדרות של ‪ NP‬הן שקולות‬

‫הוכחה‪ :‬ראשית נסמן‪:‬‬
‫● ‪ = 𝑁𝑃1‬המחלקה 𝑃𝑁 לפי ההגדרה ה‪ :1-‬כלומר כל השפות שיש להן מ"ט א"ד פולינומית מכריעה‪.‬‬
‫● ‪ = 𝑁𝑃2‬המחלקה 𝑃𝑁 לפי ההגדרה ה‪ 2-‬המשתמשת ביחס‪ :‬כלומר כל השפות כך שקיים עבורן יחס 𝐿𝑅‬
‫שהוא חסום פולינומית‪ ,‬ניתן לזיהוי יעיל‪ ,‬וכן לעל מילה בשפה קיים עד פולינומי‪ ,‬ולכל מילה שאיננה‬
‫בשפה לא קיים עד פולינומי‪.‬‬
‫כיוון א'‪ .𝑁𝑃2 ⊆ 𝑁𝑃1 :‬תהי ‪ .𝐿 ∈ 𝑁𝑃2‬תהי 𝑉 מכונה פולינומית דטרמיניסטית המוודאת את היחס 𝐿𝑅‪ ,‬יהי‬
‫)𝑛(‪ 𝑝1‬חסם פולינומי לזמן הריצה של 𝑉 ויהי )𝑛(‪ 𝑝2‬חסם פולינומי לגודל העדים ב‪.𝑅𝐿-‬‬
‫האלגוריתם‪ :‬נתאר מ"ט א"ד 𝑁 המכריעה את השפה 𝐿‪:‬‬
‫המכונה 𝑁 על קלט 𝑥 מבצעת‪:‬‬
‫‪ .1‬מנחשת עד 𝑦 באורך לכל היותר )|𝑥|(‪( .𝑝2‬כלומר‪ ,‬העד חסום פולינומית)‪.‬‬
‫‪ .2‬מסמלצת את ריצת המכונה המוודאת 𝑉 על הזוג )𝑦 ‪ (𝑥,‬ועונה כמוה‪.‬‬
‫דוגמה לכיוון א'‪ .1 :‬היא מנחשת קבוצה של קודקודים ‪ .2‬מוודאת שאכן הקבוצה הזאת היא בלתי תלויה‪.‬‬
‫נכונות האלגוריתם‪:‬‬
‫● אם 𝐿 ∈ 𝑥 ← קיים "עד" 𝑦 באורך פולינומי ומתקיים 𝐿𝑅 ∈ )𝑦 ‪ ← .(𝑥,‬קיים ניחוש נכון של 𝑦 בעץ‬
‫החישוב של 𝑁 על 𝑥 ← במסלול החישוב הנכון‪ 𝑁 ,‬מקבלת את 𝑥‪.‬‬
‫● אם 𝐿 ∉ 𝑥 ← לכל ניחוש של 𝑦 מתקיים שהזוג 𝐿𝑅 ∉ )𝑦 ‪ ← (𝑥,‬לכל ניחוש 𝑦 בעץ החישוב של 𝑁 על 𝑥‬
‫המכונה 𝑁 תדחה את 𝑥‪.‬‬
‫סיבוכיות האלגוריתם‪:‬‬
‫● שלב ‪ : 𝑂(𝑝2(|𝑥|) :1‬הניחוש של 𝑦 זה פולינומי‪.‬‬
‫● שלב ‪ :𝑂(𝑝1(|𝑥|) + 𝑝2(|𝑥|)) :2‬מוודאת שאכן 𝑦 הוא "עד"‪ ,‬אז היא מריצה את 𝑥 וגם היא צריכה‬
‫לקרוא את הניחוש הזה שזה גם יעלה 𝑥 בזמן פולינומי‪.‬‬
‫● סך הכל‪ 𝑂(𝑝1(|𝑥|) + 𝑝2(|𝑥|)) :‬פולינומי ב‪ |𝑥|-‬כנדרש‪( .‬כי סכום פולינומים הוא גם פולינום)‪.‬‬
‫לסיום‪ :‬הראנו שאם יש לנו יחס תקין אז אפשר לכתוב מכונה א"ד‪.‬‬
‫∎‬
‫כיוון ב'‪ .𝑁𝑃1 ⊆ 𝑁𝑃2 :‬תהי ‪ 𝐿 ∈ 𝑁𝑃1‬ותהי 𝑁 מ"ט א"ד המכריעה את השפה 𝐿 ויהי )𝑛(𝑝 חסם פולינומי לזמן‬
‫הריצה של המכונה 𝑁 (כלומר‪ ,‬לעומק על עצי החישוב שלה)‪.‬‬
‫יחס 𝐿𝑅 עבור השפה 𝐿 היא‪:‬‬
‫‪ .1‬לכל 𝐿 ∈ 𝑥 ניקח מסלול ריצה מקבל בעץ החישוב של 𝑁 על 𝑥 להיות עד‪ .‬נייצג כל מסלול ריצה כזה‬
‫כמחרוזת בינארית (‪=0‬שמאלה ו‪=1-‬ימינה)‪.‬‬
‫‪ .2‬האורך של כל מחרוזת כזו חסום ע"י )|𝑥|(𝑝‪.‬‬
‫‪ .3‬ניתן לבדוק "בקלות" (כלומר‪ ,‬בחישוב דטרמיניסטי בזמן פולינומי) אם המסלול שניתן לנו כ‪"-‬עד"‪,‬‬
‫מסתיים או לא מסתיים במצב מקבל‪( .‬זה בעצם המאמת 𝑉)‪.‬‬
‫נכונות‪:‬‬
‫● אם 𝐿 ∈ 𝑥 אז קיים מסלול מקבל בעץ החישוב של 𝑁 על 𝑥‪ .‬מכאן קיים עד 𝑦 שאורכו חסום ע"י פולינום‬
‫ב‪ .|𝑥|-‬לכן הזוג )𝑦 ‪ (𝑥,‬שייך ליחס 𝐿𝑅‪.‬‬
‫● אם 𝐿 ∉ 𝑥 אז כל המסלולים בעץ החישוב של 𝑁 על 𝑥 דוחים‪ .‬מכאן שלכל עד 𝑦‪ ,‬הזוג 𝐿𝑅 ∉ )𝑦 ‪.(𝑥,‬‬
‫לסיום‪ :‬הראנו שאם יש לנו מכונה א"ד אז אפשר לכתוב לה יחס‪.‬‬
‫הערה‪ :‬הראנו שהמסלול הספציפי הוא ה‪"-‬עד"‪ .‬ה‪"-‬עד" הזה יהיה הקידוד של המסלול‪.‬‬
‫∎‬
‫מסלול המילטון ‪ -‬השפה ‪HAMPATH‬‬

‫מסלול המילטוני בגרף מכוון 𝐷 הוא מסלול פשוט (ללא מעגלים) שמבקר בכל צומת‬
‫פעם אחת ויחידה‪.‬‬
‫נתונה השפה הבאה‪:‬‬
‫‪𝐻𝐴𝑀𝑃𝐴𝑇𝐻 = {< 𝐷, 𝑠, 𝑡 > | 𝐷 𝑖𝑠 𝑎 𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ‬‬
‫}𝑡 𝑜𝑡 𝑠 𝑚𝑜𝑟𝑓 ‪𝑤𝑖𝑡ℎ 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ‬‬
‫תרגיל‪ :‬תארו מאמת בעל זמן ריצה פולינומיאלי לשפה 𝐻𝑇𝐴𝑃𝑀𝐴𝐻‪.‬‬

‫פתרון‪ :‬הסבר לפתרון‪ :‬ה‪"-‬עד" יהיה סידור של ‪ 𝑛 − 1‬צמתים והניחוש יהיה "מהו המסלול?"‪.‬‬
‫העד‪ :‬בהינתן > 𝑡 ‪ < 𝐷, 𝑠,‬העד 𝑦 הינו סידור של שאר ‪ 𝑛 − 2‬הקודקודים‪.‬‬
‫בנוסף )𝐷 (𝑂 = |𝑦| כי 𝐷 זה גרף המיוצג כמטריצת שכנויות ולכן סידור הצמתים יעלה לנו )𝐷 (𝑂‪.‬‬
‫המאמת‪ :‬המאמת 𝑉 על קלט )𝑦 ‪:(𝑥,‬‬
‫‪ .1‬מוודא שכל זוג צמתים סמוכים ב‪ 𝑦-‬מחוברים בצלע‪ .‬אם לא ‪ -‬דוחה‪.‬‬
‫‪ .2‬מוודא צלע 𝑠 לתחילת 𝑦 ו‪ 𝑡-‬לסוף 𝑦‪.‬‬
‫זמן ריצה‪ :‬כדי לוודא שקיימות צלעות כאלה שבונות מסלול יעלה לנו )𝑛(𝑂‪ .‬הסידור עולה )𝐷 (𝑂‪.‬‬
‫לכן קיבלנו זמן ריצה פולינומי‪.‬‬
‫טענה‪.𝐻𝐴𝑀𝑃𝐴𝑇𝐻 ∈ 𝑁𝑃 :‬‬
‫הוכחה‪ :‬נציג אלגוריתם 𝑁 על 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 שעובד בזמן פולינומי‪.‬‬
‫המכונה 𝑁 על הקלט > 𝑡 ‪ < 𝐺, 𝑠,‬מבצעת‪:‬‬
‫‪ .1‬כתוב רשימה של 𝑚 = |)𝐺(𝑉| מספרים‪ .𝑝1, ... , 𝑝𝑚 ,‬כל מספר ברשימה נבחר באופן לא‬
‫דטרמיניסטי בטווח ]𝑚 ‪.[1,‬‬
‫‪ .2‬בדוק אם קיים חזרתיות ברשימה‪ - .‬אם נמצא כזה‪ ,‬דחה‪.‬‬
‫‪ .3‬בדוק האם ‪ 𝑠 ≠ 𝑝1‬וגם 𝑚𝑝 ≠ 𝑡‪ .‬אם מתקיים‪ ,‬דחה‪.‬‬
‫‪ .4‬לכל ‪ ,1 ≤ 𝑖 ≤ 𝑚 − 1‬בדוק האם )‪ (𝑝𝑖, 𝑝𝑖+1‬הוא צלע ב‪ .𝐺-‬אם לא‪ ,‬דחה‪.‬‬
‫‪ .5‬קבל‪.‬‬
‫כדי לנתח את האלגוריתם ולאמת שהוא רץ בזמן ריצה פולינומי א"ד‪ ,‬ננתח כל אחד מהשלבים שלו‪.‬‬
‫בשלב ‪ - 1‬קיים בחירה א"ד שמתבצעת בזמן פולינומי‪ .‬בשלב ‪ 2‬ו‪ ,3-‬כל שלב רץ בזמן פולינומי‪ .‬בשלב ‪ 4‬אנחנו‬
‫עוברים בלולאה בצורה ליניארית שזה בהחלט לכל היותר פולינומי‪ .‬לכן 𝑁 מכונה א"ד מכריעה בזמן פולינומי‪.‬‬
‫ומכאן 𝑃𝑁 ∈ 𝐻𝑇𝐴𝑃𝑀𝐴𝐻‪.‬‬
‫∎‬
‫שאלה‪ :‬האם 𝑃 ∈ 𝐻𝑇𝐴𝑃𝑀𝐴𝐻?‬

‫תשובה‪ :‬לא ידוע על אלגוריתם פולינומיאלי להכרעת השייכות לשפה‪ ,‬וגם לא הוכח שאלגוריתם כזה לא קיים‪.‬‬
‫השפה ‪COMPOSITES‬‬
‫תזכורת‪ :‬מספר טבעי נקרא פריק אם הוא מכפלה של שני מספרים טבעיים גדולים מ‪.1-‬‬
‫נתונה השפה‪.𝐶𝑂𝑀𝑃𝑂𝑆𝐼𝑇𝐸𝑆 = {< 𝑛 > | 𝑛 = 𝑝𝑞, 𝑓𝑜𝑟 𝑖𝑛𝑡𝑒𝑔𝑒𝑟𝑠 𝑝, 𝑞 > 1} :‬‬
‫שאלה‪ :‬האם 𝑃 ∈ 𝑆𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶?‬
‫תשובה‪ :‬נשים לב שישנו אלגוריתם דטרמיניסטי שנלמד בעבר שאומר שניתן לעבור על כל המספרים מ‪ 1-‬ועד‬
‫𝑛 ‪ .‬אם מצאנו מחלקה‪ ,‬אזי הוא פריק ואם לא אז הוא ראשוני‪ .‬אבל נסתכל מה סיבוכיות האלגוריתם הזה‪:‬‬
‫מאחר שהקלט > 𝑛 < מיוצג במחרוזת בינארית אז הוא בגודל )𝑛(‪ log2‬ואנחנו נרוץ 𝑛 פעמים אז נקבל שזמן‬
‫)𝑛(‪log‬‬
‫)𝑛(‪log2‬‬
‫= 𝑛 כלומר זה זמן אקספוננציאלי‪ .‬במילים אחרות‪,‬‬ ‫‪2‬‬ ‫‪=2‬‬ ‫‪2‬‬
‫הריצה של האלגוריתם הזה יהיה‬
‫‪ 𝑝(log2(𝑛)) = 2‬ולכן האלגוריתם לא‬ ‫‪2‬‬

‫קיבלנו שהיחס בין גודל הקלט לזמן הריצה הוא אקספוננציאלי‬
‫פולינומי ולא ניתן להוכיח האם 𝑃 ∈ 𝑆𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶‪ .‬נשים לב אבל שחוקרים מצאו אלגוריתם שכן מוכיח ש‬
‫𝑃 ∈ 𝑆𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶 אבל לא נלמד על זה‪.‬‬
‫טענה‪.𝐶𝑂𝑀𝑃𝑂𝑆𝐼𝑇𝐸𝑆 ∈ 𝑁𝑃 :‬‬
‫רעיון ההוכחה‪ :‬זמן הריצה צריך להיות פולינומיאלי בכמות הספרות המייצגות את המספר 𝑛‪ .‬נשים לב ש‪:‬‬
‫)𝑛(‪ |< 𝑛 >| = log‬כי זו מחרוזת בינארית ולכן נתעניין כאן במ"ט שרצות בזמן פולינומי ב‪.log(𝑛)-‬‬
‫הוכחה ‪ -‬דרך ‪ :1‬נגדיר יחס }𝑛 < 𝑑 < ‪.𝑅𝐶 = {(𝑛, 𝑑) ∈ ℕ × ℕ| 𝑑 𝑑𝑖𝑣𝑖𝑑𝑒𝑠 𝑛 𝑎𝑛𝑑 1‬‬
‫‪ .1‬היחס חסום פולינומית‪ :‬כי 𝑛 < 𝑑 ולכן קידוד 𝑑 לא גדול מקידוד 𝑛‪ .‬כלומר )𝑛(‪.log(𝑑) ≤ log‬‬
‫ֻ‬
‫פולינומית‪ :‬קיים מאמת שמחלק מספרים טבעיים ביעילות ובודק אם יש שארית‪.‬‬ ‫‪ .2‬היחס ניתן להכרעה‬
‫‪ ⇔ 𝑛 ∈ 𝐶𝑂𝑀𝑃𝑂𝑆𝐼𝑇𝐸𝑆 .3‬קיים 𝑛 < 𝑑 < ‪ 1‬המחלק את 𝑛 ללא שארית ⇔ 𝐶𝑅 ∈ )𝑑 ‪.∃𝑑: (𝑛,‬‬
‫הוכחה ‪ -‬דרך ‪ :2‬נגדיר מ"ט א"ד 𝑀 על קלט > 𝑛 <‪:‬‬
‫‪ .1‬תנחש מספר טבעי 𝑑 כך ש‪.1 < 𝑑 < 𝑛 :‬‬
‫‪ .2‬תבדוק האם 𝑑 מחלק את 𝑛‪.‬‬
‫‪ .3‬אם כן‪ ,‬תקבל‪ .‬אחרת‪ ,‬תדחה‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬המכונה פולינומית‪ ,‬כי ניתן לנחש 𝑑 ולבדוק חלוקה בזמן פולינומי‪.‬‬
‫הוכחת נכונות‪ :‬נוכיח כי )𝑀(𝐿 = 𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶‪.‬‬
‫● 𝑆𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶 ∈ 𝑛 ← קיים 𝑑 שמחלק את 𝑛 ← קיים ניחוש ל‪ 𝑑-‬שעבורו קיים מסלול חישוב ש‪𝑀-‬‬
‫מגיע למצב מקבל ← )𝑀(𝐿 ∈ 𝑛‪.‬‬
‫● 𝑆𝐸𝑇𝐼𝑆𝑂𝑃𝑀𝑂𝐶 ∉ 𝑛 ← לכל 𝑑 בתחום‪ ,‬לא קיים מסלול חישוב עבור 𝑀 שמגיע למצב מקבל ←‬
‫)𝑀(𝐿 ∉ 𝑛‪.‬‬
‫∎‬
‫השפה ‪PRIMES‬‬
‫נתונה השפה }𝑒𝑚𝑖𝑟𝑝 𝑠𝑖 𝑛 | > 𝑛 <{ = 𝑆𝐸𝑀𝐼𝑅𝑃‪.‬‬
‫שאלה‪ :‬האם 𝑃 ∈ 𝑆𝐸𝑀𝐼𝑅𝑃?‬
‫תשובה‪ :‬מכיוון ש‪ 𝐶𝑂𝑀𝑃𝑂𝑆𝐼𝑇𝐸𝑆 ∈ 𝑁𝑃 :‬אז גם 𝑃 ∈ 𝑆𝐸𝑀𝐼𝑅𝑃 (כי ‪ P‬סגורה למשלים)‪.‬‬
‫הוכיחו גם בעבר כי 𝑃𝑁 ∈ 𝑆𝐸𝑀𝐼𝑅𝑃‪.‬‬
‫הערה‪ :‬שפה שגם היא וגם המשלימה שלה שייכות ל‪ 𝑁𝑃-‬אז היא "חשודה" כשייכת גם ל‪.𝑃-‬‬
‫קליקה בגרף ‪CLIQUE -‬‬

‫הגדרה‪ :‬קליקה בגרף לא מכוון 𝐺 היא קבוצה של צמתים שיש קשת בין כל שניים מהם‪.‬‬
‫נתונה השפה‪.𝐶𝐿𝐼𝑄𝑈𝐸 = {< 𝐺, 𝑘 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ 𝑎 𝑘 − 𝑐𝑙𝑖𝑞𝑢𝑒} :‬‬
‫בציור‪ :‬גרף שמכיל ‪-5‬קליקה‪.‬‬
‫טענה‪.𝐶𝐿𝐼𝑄𝑈𝐸 ∈ 𝑁𝑃 :‬‬
‫רעיון ההוכחה‪ :‬הקליקה היא "תעודת השייכות"‪.‬‬
‫הוכחה‪ :‬נוכיח כי 𝑉 הוא המאמת של 𝐸𝑈𝑄𝐼𝐿𝐶‪.‬‬
‫𝑉 על קלט > 𝑐 ‪ << 𝐺, 𝑘 >,‬תבצע‪:‬‬
‫‪ .1‬תבדוק האם 𝑐 הוא תת‪-‬גרף עם 𝑘 קודקודים ב‪.𝐺-‬‬
‫‪ .2‬תבדוק האם 𝐺 מכילה את כל הצלעות שמחברות את הקודקודים בתת הגרף 𝑐‪.‬‬
‫‪ .3‬אם שלבים ‪ 1‬ו‪ 2-‬הצליחו‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫הוכחה אחרת‪ :‬נציג אלגוריתם 𝑁 א"ד בזמן פולינומי שמכריע את 𝐸𝑈𝑄𝐼𝐿𝐶‪.‬‬
‫המכונה 𝑁 על הקלט > 𝑘 ‪ < 𝐺,‬תבצע‪:‬‬
‫‪ .1‬תנחש תת קבוצה 𝑐 של 𝑘 קודקודים בגרף 𝐺‪.‬‬
‫‪ .2‬תבדוק האם 𝐺 מכילה את כל הצלעות שמחברות את הקודקודים בתת הגרף 𝑐‪.‬‬
‫‪ .3‬אם שלב ‪ 2‬הצליח‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫שאלה‪ :‬האם 𝑃 ∈ 𝐸𝑈𝑄𝐼𝐿𝐶?‬

‫פתרון‪ :‬לא ידוע‪.‬‬
‫שאלה‪ :‬האם 𝑆𝐼 היא המשלימה של 𝐸𝑈𝑄𝐼𝐿𝐶?‬

‫תשובה‪ :‬זה לא בדיוק המשלים שלו…‪ .‬הגרפים כן משלימים אבל השפות הנתונות לא משלימות‪.‬‬
‫למה? כי גרף קליקה בגודל ‪ k‬אז המשלים שלו הוא גרף עם קבוצה בלתי תלויה בגודל ‪.k‬‬
‫הגרפים 𝐸𝑈𝑄𝐼𝐿𝐶 ∈> 𝑘 ‪ < 𝐺,‬ו‪ < 𝐺, 𝑘 >∈ 𝐼𝑆-‬הם משלימים אחד של השני‪ .‬אבל לא השפות עצמם‪.‬‬
‫קבוצה בלתי תלויה ‪IS -‬‬

‫הגדרה‪ :‬בתורת הגרפים‪ ,‬קבוצה בלתי תלויה (‪ )IS - Independent set‬היא קבוצת קודקודים בגרף‪ ,‬אשר אין‬
‫זוג מביניהם המחוברים ישירות דרך קשת אחת‪.‬‬
‫נתונה השפה‪.𝐼𝑆 = {< 𝐺, 𝑘 > | 𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ𝑎𝑡 𝑐𝑜𝑛𝑡𝑎𝑖𝑛𝑠 𝑎𝑛 𝑖𝑛𝑑𝑒𝑝𝑒𝑛𝑑𝑒𝑛𝑡 𝑠𝑒𝑡 𝑜𝑓 𝑠𝑖𝑧𝑒 𝑘} :‬‬
‫תזכורת‪ :‬הראנו כבר שמתקיים 𝑃𝑁 ∈ 𝑆𝐼‪.‬‬

‫שאלה‪ :‬האם 𝑃 ∈ 𝑆𝐼?‬
‫תשובה‪ :‬לא ידוע‪.‬‬
‫הערה‪ :‬נשים לב היטב לקלט ב‪ 2-‬הבעיות האחרונות (גרף 𝐺 ומספר טבעי 𝑘 ולא רק גרף 𝐺)‪.‬‬
‫‪.‬‬ ‫𝑅 ∈ 𝑆𝐼‪ :‬כי אפשר לעבור על ) ( תתי קבוצות ובכל אחת לוודא שאין צלעות ) (‬
‫𝑘‬
‫‪2‬‬
‫𝑛‬
‫𝑘‬
‫𝑘‬ ‫‪2‬‬
‫זמן ריצה‪.Θ(𝑛 · 𝑘 ) :‬‬
‫𝑘‬ ‫‪2‬‬
‫הוכחנו שהיא ב‪ ,R-‬אם עברנו על כל האפשרויות ולא מצאנו קבוצה ב"ת אז ) 𝑘 · 𝑛(‪ Θ‬וזה נראה פולינום‪.‬‬
‫אז השאלה היא למה לא ידוע האם 𝑃 ∈ 𝑆𝐼? ‪ -‬הרי כתוב כאן פולינום בחזקה קבועה‪.‬‬
‫הבעיה‪ :‬כי 𝑛 ≤ 𝑘 ≤ ‪ ,1‬אמנם 𝑘 הוא מספר קבוע אבל הוא יכול להיות פונקציה של 𝑛‪.‬‬
‫‪𝑛/2‬‬ ‫‪2‬‬ ‫𝑛‬ ‫𝑘‬ ‫‪2‬‬
‫𝑛(‪ Θ‬זה אקספוננציאלי‪???WTF .‬‬ ‫= 𝑘 ולכן ) )‪· (𝑛/2‬‬ ‫‪2‬‬
‫מאינפי‪ 𝑛 · 𝑘 :‬מקבל מקסימום עבור‬
‫𝑘‬ ‫‪𝑛/2‬‬
‫𝑛= 𝑛‬ ‫במילים אחרות‪ :‬בגלל ש‪ 𝑛 → ∞ :‬ו‪ 𝑘-‬חסום עד 𝑛 כולל אז יכול להיות מקרה בו 𝑛 = 𝑘 ולכן ∞ →‬
‫כלומר זה לא יכול להיות פולינומי‪.‬‬
‫השפה ‪SUBSET-SUM‬‬
‫נתונה השפה הבאה‪:‬‬
‫}𝑡 = 𝑖𝑦‪𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 = {< 𝑆, 𝑡 > | 𝑆 = {𝑥1,.., 𝑥𝑛}, ∃{𝑦1,.., 𝑦𝑘} ⊆ {𝑥1,..., 𝑥𝑛} 𝑠. 𝑡. Σ‬‬
‫השפה במילים‪ :‬הקידוד > 𝑡 ‪ < 𝑆,‬בשפה אם לקבוצה 𝑆 קיים תת קבוצה }𝑘𝑦 ‪ {𝑦1,..,‬כך שסכומה הוא 𝑡‪.‬‬
‫דוגמה‪ < {4, 11, 16, 21, 27}, 25 >∈ 𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 :‬בגלל ש‪.4 + 21 = 25 :‬‬
‫טענה‪.𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 ∈ 𝑁𝑃 :‬‬

‫רעיון ההוכחה‪ :‬תת הקבוצה היא "תעודת השייכות"‪.‬‬
‫הוכחה‪ :‬נוכיח כי 𝑉 הוא המאמת של 𝑀𝑈𝑆 ‪.𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫המוודא 𝑉 על קלט > 𝑐 ‪ << 𝑆, 𝑡 >,‬מבצע‪:‬‬
‫‪ .1‬בדוק האם 𝑐 הוא אוסף מספרים שסוכמו שווה ל‪.𝑡-‬‬
‫‪ .2‬בדוק האם 𝑆 מכיל את כל המספרים ב‪.𝑐-‬‬
‫‪ .3‬אם שלב ‪ 1‬ו‪ 2-‬הצליחו‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫הוכחה אחרת‪ :‬נציג אלגוריתם 𝑁 א"ד בזמן פולינומי שמכריע את השפה 𝑀𝑈𝑆 ‪.𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫המכונה 𝑁 על הקלט > 𝑡 ‪ < 𝑆,‬תבצע‪:‬‬
‫‪ .1‬נחש תת קבוצה 𝑐 של מספרים מתוך 𝑆‪.‬‬
‫‪ .2‬בדוק האם 𝑐 הוא אוסף מספרים שסוכמו שווה ל‪.𝑡-‬‬
‫‪ .3‬אם שלב ‪ 1‬הצליח‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫שאלה‪ :‬האם היא שייכת ל‪?𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 ∈ 𝑃-‬‬

‫תשובה‪ :‬לא ידוע‪.‬‬
‫הבהרה של כללי המשחק‬

‫שאלה‪ :‬משהו פה לא ברור‪ .‬אם מישהו מספק לנו את ההוכחה לשייכות של המילה לשפה‪ ,‬אז האם לא כל שפה‬
‫שייכת ל‪?𝑁𝑃-‬‬
‫האם לא תמיד אפשר לספק "תעודת שייכות" קצרה לכל מילה בשפה?‬ ‫‪-‬‬
‫הכוונה ב"קצרה" היא בעלת אורך פולינומיאלי באורך המילה‪.‬‬ ‫‪-‬‬
‫תשובה‪ :‬לא כל שפה אפשר להכניס פנימה‪ .‬הסתכלו במשלימה של 𝐸𝑈𝑄𝐼𝐿𝐶 או של 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 או של 𝑆𝐼‪.‬‬
‫האם תוכלו להראות שהן שייכות ל‪ ?𝑁𝑃 -‬המשלים של 𝐸𝑈𝑄𝐼𝐿𝐶 אומר שכל הקבוצות ב‪ 𝐺-‬שאין להם קליקה‬
‫בגודל 𝑘‪ .‬כלומר צריך את כל הקבוצות בגודל 𝑘 ולוודא שכל אחת ואחת מהן היא לא קליקה‪ .‬לכן ה‪"-‬עד" הוא‬
‫קבוצה של קבוצות ולכן זה כבר אקספוננציאלי ‪ -‬לא חסום פולינומית‪.‬‬
‫שאלות פתוחות‬
‫● לא ידוע האם 𝑃𝑁 = 𝑃 או 𝑃𝑁 ⊂ 𝑃‪ .‬האם יש שוויון בין המחלקות או שיש הכלה ממש?‬
‫רוב מוחלט של החוקרים סבורים ש‪.𝑃 ≠ 𝑁𝑃 :‬‬
‫● לא ידוע האם 𝑃𝑁𝑜𝑐 = 𝑃𝑁‬
‫הסבירו היטב את משמעות השוויון הזה! (להשלים)‪.‬‬
‫● לא ידוע האם 𝑃𝑁𝑜𝑐 ∩ 𝑃𝑁 = 𝑃‪.‬‬
‫הסבירו היטב מהי המחלקה 𝑃𝑁𝑜𝑐 ∩ 𝑃𝑁‪ .‬הראו ש‪( .𝑃 ⊆ 𝑁𝑃 ∩ 𝑐𝑜𝑁𝑃 :‬להשלים)‪.‬‬
‫תמונת עולם של המחלקות‬

‫האם כל ההכלות בין המחלקות הן הכלות ממש? (להשלים)‪.‬‬
‫תכונות סגור של 𝑃𝑁‬

‫תרגיל‪ :‬הוכיחו שהמחלקה 𝑃𝑁 סגורה ל‪:‬‬
‫‪ .1‬איחוד‬
‫‪ .2‬חיתוך‬
‫‪ .3‬שרשור‬
‫‪ .4‬איטרציה‬
‫לא ידוע האם 𝑃𝑁 סגורה למשלים‪.‬‬ ‫‪-‬‬
‫לא ידוע האם 𝑃𝑁𝑜𝑐 = 𝑃𝑁‪.‬‬ ‫‪-‬‬
‫שאלה ‪ - 1‬תרגול ‪ - 5‬מעגל אוילר‬

‫נתונה השפה‪.𝐸𝐶 = {< 𝐺 > | 𝐺 ℎ𝑎𝑠 𝑎𝑛 𝐸𝑢𝑙𝑒𝑟 𝑐𝑦𝑐𝑙𝑒} :‬‬
‫הגדרה‪ :‬מסלול אוילר הוא מסלול בגרף העובר בכל קשת בו בדיוק פעם אחת‪ .‬מעגל אוילר הוא מסלול אוילר‬
‫מעגלי (מתחיל ונגמר באותו צומת)‪.‬‬
‫תזכורת (מקורס אלגוריתמים)‪ :‬בגרף קשיר קיים מעגל אוילר אם ורק אם כל הדרגות זוגיות‪.‬‬
‫טענה‪.𝐸𝐶 ∈ 𝑃 :‬‬
‫רעיון ההוכחה‪ :‬אם נרצה לחפש את המעגל עצמו‪ ,‬אז אנחנו נצטרך לבצע חיפוש שלם בכל הגרף כדי למצוא‬
‫את המעגל‪ .‬אבל אם נעבור על כל הפרמוטציות אז האלגוריתם יהיה בזמן ריצה אקספוננציאלי ואנחנו רוצים‬
‫בזמן פולינומי‪ .‬אנחנו נרצה לבנות את האלגוריתם שלנו כאשר גודל הקלט שלנו יהיה מטריצת שכנויות של 𝐺‪.‬‬
‫למה אנחנו יכולים להשתמש במטריצת שכנויות? ‪ -‬אם גודל הקלט של השפה > 𝐺 < נקבע על סמך מספר‬
‫‪2‬‬
‫הצמתים 𝑛‪ ,‬אז אפשר להשתמש בקלט אחר מסוג טבלת שכנויות 𝑛 = 𝑛𝑥𝑛 שגם בגודל פולינומי‪.‬‬
‫בהרצאה למדנו שאם קיים יחס פולינומי בין קלט ‪ a‬לקלט ‪ b‬אז אפשר להשתמש בקלט ‪ b‬במקום ‪.a‬‬
‫לכל קודקוד בטבלה (לכל שורה) נסכום את הדרגות (השכנים) וכל פעם נבדוק האם הסכום זוגי‪.‬‬
‫הוכחה‪ :‬נראה מכונת טיורינג 𝐶𝐸𝑀 דטרמיניסטית עבור 𝐶𝐸‪ ,‬שרצה בזמן חסום פולינומית ביחס לקלט שלה‪.‬‬
‫מכונת טיורינג 𝐶𝐸𝑀 על קלט > 𝐺 < תבצע‪:‬‬
‫‪ .1‬עבור על כל הקודקודים )𝐺(𝑉 ∈ 𝑖𝑣‪:‬‬
‫‪ .a‬עבור כל קודקוד 𝑖𝑣‪ ,‬בדוק מה מספר השכנים שלו וסמן זאת ב‪.𝑐-‬‬
‫‪ .b‬בדוק האם 𝑐 הוא מספר זוגי‪ .‬אם לא‪ ,‬דחה‪.‬‬
‫‪ .c‬אחרת‪ ,‬עבור לקודקוד ‪.𝑣𝑖+1‬‬
‫קבל‪( .‬נוכל לקבל פה כי עברנו על כל הצמתים ולא דחינו‪ ,‬כלומר כל הדרגות זוגיות)‪.‬‬ ‫‪.2‬‬
‫סיבוכיות זמן ריצה‪ :‬נאמר שהקלט הוא |)𝐺(𝑉| = 𝑛‪.‬‬
‫● שלב ‪ - 1‬מעבר על כל הצמתים עולה לנו )𝑛(𝑂‪.‬‬
‫● שלב ‪ - a‬לכל צומת 𝑖𝑣 נעבור על כל השכנים ‪ -‬עולה לנו )𝑛(𝑂‪.‬‬
‫‪2‬‬ ‫‪2‬‬
‫סך הכל זמן הריצה היא ) 𝑛(𝑂 שאכן בזמן פולינומי (עבור 𝑛 = )𝑛(𝑝)‪.‬‬
‫הוכחת נכונות‪ :‬צריך להוכיח כי )𝐶𝐸𝑀(𝐿 = 𝐶𝐸‪.‬‬
‫● 𝐶𝐸 ∈> 𝐺 < ← קיים מעגל אוילר בגרף 𝐺 ← כל הצמתים בגרף בעלי דרגות זוגיות ← 𝐶𝐸𝑀 תעבור‬
‫בלולאה על כל הצמתים ← לאחר שתסיים לעבור על כולם‪ ,‬תתקבל ← ‪← 𝑀𝐸𝐶(< 𝐺 >= 1‬‬
‫)𝐶𝐸𝑀(𝐿 ∈> 𝐺 <‪.‬‬
‫● 𝐶𝐸 ∉> 𝐺 < ← לא קיים מעגל אוילר בגרף 𝐺 ← קיימת לפחות צומת אחת בגרף בעלת דרגה‬
‫אי‪-‬זוגית ← המכונה 𝐶𝐸𝑀 תעבור על הצמתים עד שתפגוש בצומת עם דרגה אי זוגית ←‬
‫‪.< 𝐺 >∉ 𝐿(𝑀𝐸𝐶) ← 𝑀𝐸𝐶(< 𝐺 >= 0‬‬
‫שאלה ‪ - 2‬תרגול ‪ - 5‬מעגל המילטון‬

‫נתונה השפה‪.𝐻𝐶 = {< 𝐺 > | 𝐺 ℎ𝑎𝑠 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑐𝑦𝑐𝑙𝑒} :‬‬
‫הגדרה‪ :‬מסלול המילטוני הוא מסלול בגרף מכוון או בלתי מכוון העובר בכל צומת בדיוק פעם אחת‪.‬‬
‫מעגל המילטוני הוא מסלול בגרף העובר בכל צומת פעם אחת פרט לצומת שממנו יצא (ואז הוא עובר בו בדיוק‬
‫פעמיים ‪ -‬בהתחלה ובסוף)‪.‬‬
‫שאלה‪ :‬האם ניתן להוכיח ש‪.𝐻𝐶 ∈ 𝑃 :‬‬
‫תשובה‪ :‬נכון להיום‪ ,‬לא ידוע האם 𝑃 ∈ 𝐶𝐻‪ .‬זה לא אומר שזה לא שייך‪ ,‬ייתכן שלא מצאו אלגוריתם לבעיה‪.‬‬
‫רעיון‪ :‬אם נרצה לעבור על כל הפרמוטציות (חיפוש שלם) אז זה על‪-‬פולינומי (אקספוננציאלי)‪.‬‬
‫במעגל אוילר ניצלנו את השיטה של הדרגות הזוגיות‪ ,‬אבל נכון להיום אין לנו שיטה דומה עבור מעגל המילטון‪.‬‬
‫נשים לב ש‪ 𝐻𝐶 ∈ 𝑅 :‬משום שניתן לעבור על כל המעגלים האפשריים בגרף ולבדוק האם הם מתאימים‪.‬‬
‫פורמלית‪ ,‬נעבור על כל הסידורים של צמתי הגרף 𝑛𝑣 ‪ 𝑣1,..,‬ולכל סידור כזה נבדוק אם לכל 𝑖 מתקיים‬
‫)𝐺(𝐸 ∈ )‪ (𝑣𝑖, 𝑣𝑖+1‬וכן כי )𝐺(𝐸 ∈ )‪ .(𝑣𝑛, 𝑣1‬אם מצאנו סידור שעונה על התנאי אז מצאנו מעגל המילטון‪.‬‬
‫נניח שגודל הקלט הוא כמספר הצמתים 𝑛‪ ,‬לכן האלגוריתם שתיארנו יקח !𝑛 = ‪ 𝑛 · (𝑛 − 1) ·... · 1‬צעדים‬
‫כלומר !𝑛 = )𝑛(𝑝 וזה זמן שאינו פולינומי בגודל הקלט ולכן למרות ש‪ ,𝐻𝐶 ∈ 𝑅 :‬לא הצלחנו להוכיח כי‬
‫𝑃 ∈ 𝐶𝐻‪ .‬אך זה לא אומר ש‪ ,𝐻𝐶 ∉ 𝑃 :‬פשוט אף אחד לא מצא אלגוריתם שפותר את הבעיה ולכן לא ידוע‪.‬‬
‫שאלה ‪ - 3‬תרגול ‪ - 5‬מעגל המילטון‬

‫טענה‪.𝐻𝐶 ∈ 𝑁𝑃 :‬‬
‫רעיון ההוכחה‪ :‬מ"ט א"ד פולינומית מסוגלת להכריע שפות שאיננו יודעים אם הן ב‪ .𝑃-‬ראינו בשאלה קודמת כי‬
‫אנחנו לא יודעים האם 𝑃 ∈ 𝐶𝐻‪ .‬כלומר ראינו שנכון להיום‪ ,‬לא ידוע אם קיימת מכונה דטרמיניסטית שפותרת‬
‫את הבעיה 𝐶𝐻 בזמן פולינומי‪ .‬מצד שני‪ ,‬אם יהיה לנו אפשרות לנחש את הפרמוטציה שתייצג את הסידור הנכון‬
‫בגרף עבור מעגל המילטון אז ניתן יהיה לפתור בזמן פולינומי‪ .‬נציג מכונה א"ד פולינומית עבור 𝐶𝐻‪.‬‬
‫הוכחה‪ :‬המכונה 𝐶𝐻𝑀 על הקלט > 𝐺 < תבצע‪:‬‬
‫‪ .1‬מנחשת פרמוטציה (מסלול) על הצמתים ובודקת שאכן מהווה מעגל המילטון‪.‬‬
‫‪ .2‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬אורך המעגל שצריך לנחש הוא ליניארי (מסלול בעץ החישוב) כלומר )𝑛(𝑂‪ .‬צריך לבדוק‬
‫האם הצמתים שניחשנו שונים זה מזה‪ ,‬ושבין כל שני צמתים עוקבים בסידור קיימת קשת ‪ -‬עולה לנו )𝑛(𝑂‪.‬‬
‫לכן‪ ,‬שתי הבדיקות הללו ניתנות לביצוע בזמן פולינומי‪.‬‬
‫הוכחת נכונות‪ :‬צריך להוכיח ש‪.𝐻𝐶 = 𝐿(𝑀𝐻𝐶) :‬‬
‫● 𝐶𝐻 ∈> 𝐺 < ← קיים ב‪ 𝐺-‬מעגל המילטון ← ניתן לתאר את המעגל ההמילטוני כסידור של צמתים‬
‫← 𝐶𝐻𝑀 תנחש סידור זה והבדיקה שלה תצליח ← קיים מסלול חישוב מקבל עבור 𝐺 ←‬
‫)𝐶𝐻𝑀(𝐿 ∈> 𝐺 <‪.‬‬
‫● 𝐶𝐻 ∉> 𝐺 < ← לא קיים ב‪ 𝐺-‬מעגל המילטון ← לא קיים אף סידור של צמתים המתאר מעגל‬
‫המילטוני ← 𝐶𝐻𝑀 לא תצליח בניחוש ← לא קיים אף מסלול חישוב מקבל עבור 𝐺 ←‬
‫)𝐶𝐻𝑀(𝐿 ∉> 𝐺 <‪.‬‬
‫ומכאן 𝑃𝑁 ∈ 𝐶𝐻 כנדרש‪.‬‬
‫∎‬

‫נתונה השפה }𝑒𝑢𝑞𝑖𝑙𝑐 𝑎 𝑠𝑖 𝐶 𝑑𝑛𝑎 ‪.𝐿1 = {< 𝐺 > | ∃𝐶 ⊆ 𝑉(𝐺) 𝑠. 𝑡. |𝐶| = 11‬‬
‫טענה‪.𝐿1 ∈ 𝑁𝑃 :‬‬
‫רעיון ההוכחה‪ :‬נבנה מכונה א"ד ‪ 𝑁1‬בזמן ריצה פולינומית שמכריעה את השפה ‪.𝐿1‬‬
‫הוכחה‪ :‬בניית המכונה‪ :‬המכונה ‪ 𝑁1‬על קלט > 𝐺 < תבצע‪:‬‬
‫‪ .1‬ננחש קבוצה של קודקודים בגודל ‪.11‬‬
‫‪ .2‬לכל זוג קודקודים בקבוצה‪ ,‬נבדוק שיש ביניהם צלע‪ ,‬ואם לא ‪ -‬נדחה‪.‬‬
‫‪ .3‬אם כל הבדיקות עברו‪ ,‬נקבל‪.‬‬
‫הוכחת נכונות הבניה‪:‬‬
‫● ‪ ← < 𝐺 >∈ 𝐿1‬קיימת קליקה בגודל ‪ 11‬בגרף 𝐺 ← קיים ניחוש בו כל הצלעות קיימות ← ‪ 𝑁1‬בוחר‬
‫בניחוש הנכון ומקבל ← )‪.< 𝐺 >∈ 𝐿(𝑁1‬‬
‫● ‪ ← < 𝐺 >∉ 𝐿1‬לא קיים קליקה בגודל ‪ 11‬בגרף 𝐺 ← לכל ניחוש‪ ,‬לפחות צלע אחת תהיה חסרה ←‬
‫לכל ניחוש‪ ,‬נדחה ← )‪.< 𝐺 >∉ 𝐿(𝑁1‬‬
‫סיבוכיות זמן הריצה‪:‬‬
‫● שלב ‪ - 1‬הניחוש נקבע לפי גודל הניחוש ולכן זה עולה לנו )‪.𝑂(11) ≈ 𝑂(1‬‬
‫(𝑂‪.‬‬ ‫שלב ‪ - 2‬צריך לבדוק על כל זוג קודקודים ולכן זה עולה לנו )‪( )) ≈ 𝑂(1‬‬
‫‪11‬‬
‫‪2‬‬ ‫●‬
‫סך הכל )‪ ,𝑂(1‬פולינומי‪.‬‬

‫∎‬
‫שאלה ‪ - 5‬תרגול ‪ - 5‬צביעה של גרף‬

‫הגדרה‪ :‬בתורת הגרפים‪ ,‬גרף 𝑛‪-‬צביע הוא גרף שאפשר לצבוע את‬
‫הקודקודים שלו ב‪ n-‬צבעים‪ ,‬כך ששני קודקודים סמוכים אינם צבועים‬
‫באותו צבע‪ .‬נתונה השפה‪:‬‬
‫𝑠𝑟𝑜𝑙𝑜𝑐 𝑘 ‪𝐿2 = {(< 𝐺 >, 𝑘) | 𝑉(𝐺) 𝑐𝑎𝑛 𝑏𝑒 𝑐𝑜𝑙𝑜𝑟𝑒𝑑 𝑤𝑖𝑡ℎ‬‬
‫})𝑢(𝑟𝑜𝑙𝑜𝑐 ≠ )𝑣(𝑟𝑜𝑙𝑜𝑐)𝐺(𝐸∈)𝑣‪𝑠. 𝑡. ∀(𝑢,‬‬
‫במילים‪ :‬הצמד (קידוד של גרף‪ ,‬מספר 𝑘 טבעי) שייך לשפה ‪ 𝐿2‬אם קיים‬
‫צביעה של 𝑘 צבעים לגרף 𝐺‪ ,‬כך שלכל צלע‪ ,‬שני צמתיו בצבע שונה‪.‬‬
‫טענה‪.𝐿2 ∈ 𝑁𝑃 :‬‬
‫הוכחה‪ :‬בניית המכונה‪ :‬נבנה ‪ 𝑁2‬מ"ט א"ד פולינומית המכריעה את השפה ‪.𝐿2‬‬
‫המכונה ‪ 𝑁2‬על קלט )𝑘 ‪ (< 𝐺 >,‬תבצע‪:‬‬
‫‪ .1‬לכל צומת‪:‬‬
‫‪ .a‬נחש "צבע" בין ‪ 1‬ל‪.𝑘-‬‬
‫‪ .2‬לכל צלע‪:‬‬
‫‪ .a‬בדוק ששני הצמתים שלה צבועים בצבע שונה‪ ,‬אם לא‪ ,‬דחה‪.‬‬
‫‪ .3‬אם כל הבדיקות עברו‪ ,‬קבל‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי ‪.𝐿(𝑁2) = 𝐿2‬‬
‫● ‪ ← (< 𝐺 >, 𝑘) ∈ 𝐿2‬קיים צביעה של 𝑘 צבעים לגרף 𝐺‪ ,‬כך שלכל צלע‪ ,‬שני צמתיו בצבע שונה ←‬
‫קיים ניחוש שעבורו ‪ 𝑁2‬בוחר נכון ומקבל ← )‪.(< 𝐺 >, 𝑘) ∈ 𝐿(𝑁2‬‬
‫‪ ←(< 𝐺 >, 𝑘) ∉ 𝐿2‬לא קיים בגרף 𝐺 צביעה כזאת ← לכל ניחוש‪ ,‬קיים לפחות צלע אחת שצמתיו‬ ‫●‬
‫בצבע זהה ← )‪.(< 𝐺 >, 𝑘) ∉ 𝐿(𝑁2‬‬
‫סיבוכיות זמן הריצה‪:‬‬
‫● שלב ‪:1‬‬
‫○ מעבר על כל 𝑛 = |)𝐺(𝑉| צמתים עולה לנו )𝑛(𝑂‪.‬‬
‫○ ניחוש הצבע עולה לנו )𝑘 ‪ 𝑂(log‬כי אם יש לנו בסה"כ 𝑘 צבעים אז נצטרך 𝑘 ‪ log‬ביטים על‬
‫מנת לקודד צבע‪.‬‬
‫○ סה"כ לשלב ‪ 1‬עולה לנו )𝑘 ‪.𝑂(𝑛 log‬‬
‫● שלב ‪:2‬‬
‫‪2‬‬
‫○ לעבור על כל הצלעות עולה לנו ) 𝑛(𝑂 ‪ -‬כי זה המקרה הגרוע של מעבר על מטריצת שכנויות‪.‬‬
‫○ בדיקה לכל צלע עולה לנו )‪.𝑂(1‬‬
‫‪2‬‬
‫סה"כ עולה לנו )𝑘 ‪ ,𝑂(𝑛 + 𝑛 log‬פולינומי ולכן 𝑃𝑁 ∈ ‪ 𝐿2‬כנדרש‪.‬‬
‫∎‬

‫נתונה השפה‪.𝐿3 = {(< 𝐺 >, 𝑓, 𝑑) | ∃𝐼 ⊆ 𝑉(𝐺), |𝐼| = 𝑓, ∀𝑣 ∈ 𝑉(𝐺) : 𝑑𝑖𝑠𝑡(𝑣, 𝐼) ≤ 𝑑} :‬‬
‫במילים‪ :‬קיימת קבוצה של צמתים 𝐼‪ ,‬כך שכל הצמתים בגרף נמצאים במרחק לכל היותר 𝑑 מקודקוד בקבוצה 𝐼‪.‬‬
‫טענה‪.𝐿3 ∈ 𝑁𝑃 :‬‬
‫הוכחה‪ :‬בניית המכונה‪ :‬נבנה מ"ט א"ד ‪ 𝑁3‬בזמן פולינומי שמכריעה את השפה ‪.𝐿3‬‬
‫המכונה ‪ 𝑁3‬על קלט )𝑑 ‪ (< 𝐺 >, 𝑓,‬תבצע‪:‬‬
‫‪ .1‬נחש קבוצה של 𝑓 קודקודים‪.‬‬
‫‪ .2‬לכל צומת 𝑣 בגרף‪:‬‬
‫‪ .a‬תריץ החל ממנו 𝑆𝐹𝐵 עד שתגיע לקודקוד בקבוצה‪ .‬אם המרחק הוא יותר מ‪ - 𝑑-‬דחה‪.‬‬
‫‪ .3‬אם כל הבדיקות עברו ‪ -‬קבל‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי ‪.𝐿(𝑁3) = 𝐿3‬‬
‫● ‪ ← (< 𝐺 >, 𝑓, 𝑑) ∈ 𝐿3‬קיימת קבוצה 𝐼 של 𝑓 צמתים‪ ,‬כך שכל הצמתים בגרף נמצאים במרחק לכל‬
‫היותר 𝑑 מקודקוד בקבוצה 𝐼 ← קיים ניחוש של קבוצה כזו ← ‪ 𝑁3‬בוחר בניחוש הנכון ומקבל ←‬
‫)‪.(< 𝐺 >, 𝑓, 𝑑) ∈ 𝐿(𝑁3‬‬
‫● ‪ ← (< 𝐺 >, 𝑓, 𝑑) ∉ 𝐿3‬לא קיימת קבוצה 𝐼 של 𝑓 צמתים‪ ,‬כך שכל הצמתים בגרף נמצאים במרחק‬
‫לכל היותר 𝑑 מקודקוד בקבוצה 𝐼 ←לכל ניחוש‪ ,‬קיים צומת בגרף שרחוק יותר ב‪ 𝑑-‬מכל הצמתים‬
‫בקבוצה 𝐼 ← לכל ניחוש‪ 𝑁3 ,‬דוחה ← )‪.(< 𝐺 >, 𝑓, 𝑑) ∉ 𝐿(𝑁3‬‬
‫סיבוכיות זמן ריצה‪:‬‬
‫‪ .1‬שלב ‪ - 1‬עולה כגודל הניחוש‪ 𝑂(𝑓) = 𝑂(𝑛) :‬כאשר 𝑛 = |)𝐺(𝑉|‪.‬‬
‫‪ .2‬שלב ‪- 2‬‬
‫‪ .a‬לעבור על כל צומת בגרף עולה לנו )𝑛(𝑂‪.‬‬
‫‪2‬‬
‫‪ .b‬לבצע 𝑆𝐹𝐵 עולה לנו ) 𝑛(𝑂 כי זה הסיבוכיות של 𝑆𝐹𝐵 לגרף המיוצג במטריצת שכנויות‪.‬‬
‫‪2‬‬ ‫‪3‬‬
‫‪ .c‬סה"כ עבור שלב ‪ 2‬נקבל ) 𝑛(𝑂 = ) 𝑛 · 𝑛(𝑂‪.‬‬
‫‪ .3‬שלב ‪ - 3‬קבלה עולה לנו )‪.𝑂(1‬‬
‫‪3‬‬
‫סה"כ קיבלנו ) 𝑛(𝑂 שזה פולינומי ולכן 𝑃𝑁 ∈ ‪ 𝐿3‬כנדרש‪.‬‬
‫∎‬
‫שאלה ‪ - 7‬תרגול ‪ - 5‬מסלול קצר ביותר בגרף‬

‫}𝑘 < ‪𝐿4 = {(< 𝐺 >, 𝑘)| 𝑇ℎ𝑒 𝑠ℎ𝑜𝑟𝑡𝑒𝑠𝑡 𝑝𝑎𝑡ℎ 𝑖𝑛 𝐺 (𝑏𝑒𝑡𝑤𝑒𝑒𝑛 𝑎𝑛𝑦 𝑡𝑤𝑜 𝑛𝑜𝑑𝑒𝑠) 𝑖𝑠 𝑜𝑓 𝑙𝑒𝑛𝑔𝑡ℎ‬‬
‫במילים‪ :‬המסלול הקצר ביותר בגרף 𝐺 בין זוג קודקודים כלשהם הוא לכל היותר באורך ‪.𝑘 − 1‬‬
‫טענה‪.𝐿4 ∈ 𝑁𝑃 :‬‬
‫הוכחה‪ :‬בניית המכונה‪ :‬נבנה ‪ 𝑁4‬מ"ט א"ד פולינומית המכריעה את השפה ‪.𝐿4‬‬
‫המכונה ‪ 𝑁4‬על הקלט )𝑘 ‪ (< 𝐺 >,‬תבצע‪:‬‬
‫‪ .1‬נחש מסלול‪.‬‬
‫‪ .2‬בדוק שאורכו קטן מ‪.𝑘-‬‬
‫‪ .3‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי )‪.𝐿4 = 𝐿(𝑁4‬‬
‫● ‪ ← (< 𝐺 >, 𝑘) ∈ 𝐿4‬המסלול הקצר ביותר בגרף 𝐺 בין זוג קודקודים כלשהם הוא לכל היותר באורך‬
‫‪ ← 𝑘 − 1‬קיים ניחוש למסלול כזה ← ‪ 𝑁4‬בוחר בניחוש הנכון ומקבל ← )‪.(< 𝐺 >, 𝑘) ∈ 𝐿(𝑁4‬‬
‫● ‪ ← (< 𝐺 >, 𝑘) ∉ 𝐿4‬המסלול הקצר ביותר בגרף 𝐺 הוא לפחות באורך 𝑘 ← לכל ניחוש‪ ,‬נבחר‬
‫במסלול שלפחות באורך 𝑘 ← לכל ניחוש‪ 𝑁4 ,‬דוחה ← )‪.(< 𝐺 >, 𝑘) ∉ 𝐿(𝑁4‬‬
‫סיבוכיות זמן ריצה‪:‬‬
‫‪ .1‬שלב ‪ - 1‬אורך המסלול חסום בכמות הצמתים ולכן ניחוש המסלול עולה לנו )𝑛(𝑂‪.‬‬
‫‪ .2‬שלב ‪ - 2‬חישוב אורך המסלול‪ :‬מעבר לאורך כל הצלעות ולכן עולה לנו )𝑛(𝑂‪.‬‬
‫‪ .3‬שלב ‪ - 3‬בדיקת קבלה ‪/‬דחיה עולה לנו )‪.𝑂(1‬‬
‫סה"כ קיבלנו )𝑛(𝑂 שזה פולינומי ולכן 𝑃𝑁 ∈ ‪ 𝐿4‬כנדרש‪.‬‬
‫∎‬

‫נתונות השפות שראינו‪:‬‬
‫}𝑒𝑢𝑞𝑖𝑙𝑐 𝑎 𝑠𝑖 𝐶 𝑑𝑛𝑎 ‪𝐿1 = {< 𝐺 > | ∃𝐶 ⊆ 𝑉(𝐺) 𝑠. 𝑡. |𝐶| = 11‬‬
‫})𝑢(𝑟𝑜𝑙𝑜𝑐 ≠ )𝑣(𝑟𝑜𝑙𝑜𝑐)𝐺(𝐸∈)𝑣‪𝐿2 = {(< 𝐺 >, 𝑘) | 𝑉(𝐺) 𝑐𝑎𝑛 𝑏𝑒 𝑐𝑜𝑙𝑜𝑟𝑒𝑑 𝑤𝑖𝑡ℎ 𝑘 𝑐𝑜𝑙𝑜𝑟𝑠 𝑠. 𝑡. ∀(𝑢,‬‬
‫}𝑑 ≤ )𝐼 ‪𝐿3 = {(< 𝐺 >, 𝑓, 𝑑) | ∃𝐼 ⊆ 𝑉(𝐺), |𝐼| = 𝑓, ∀𝑣 ∈ 𝑉(𝐺) : 𝑑𝑖𝑠𝑡(𝑣,‬‬
‫}𝑘 < ‪𝐿4 = {(< 𝐺 >, 𝑘)| 𝑇ℎ𝑒 𝑠ℎ𝑜𝑟𝑡𝑒𝑠𝑡 𝑝𝑎𝑡ℎ 𝑖𝑛 𝐺 (𝑏𝑒𝑡𝑤𝑒𝑒𝑛 𝑎𝑛𝑦 𝑡𝑤𝑜 𝑛𝑜𝑑𝑒𝑠) 𝑖𝑠 𝑜𝑓 𝑙𝑒𝑛𝑔𝑡ℎ‬‬
‫שאלה‪ :‬אילו שפות אנחנו יכולים להראות שהן ב‪?𝑃-‬‬
‫תשובה‪ :‬השפות ‪ 𝐿1‬ו‪. 𝐿4 -‬‬
‫שאלה‪ :‬למה 𝑃 ∈ }𝑒𝑢𝑞𝑖𝑙𝑐 𝑎 𝑠𝑖 𝐶 𝑑𝑛𝑎 ‪?𝐿1 = {< 𝐺 > | ∃𝐶 ⊆ 𝑉(𝐺) 𝑠. 𝑡. |𝐶| = 11‬‬
‫תשובה‪ :‬אפשר לבנות מכונה דטרמיניסטית שתכריע את השפה‪ 𝐿1‬בזמן פולינומי‪ .‬מספר כל הקבוצות‬
‫ולכן אנחנו יכולים בזמן פולינומי לבדוק את כל תתי‬ ‫𝑛≤) (‬

‫𝑛‬
‫‪11‬‬
‫‪11‬‬
‫האפשריות בגודל ‪ 11‬מתוך 𝑛 קודקודים הוא‬
‫‪11‬‬
‫הקבוצות בגודל ‪( 11‬כי זה דטרמיניסטי) כי רק ) 𝑛(𝑂 כאלו‪.‬‬
‫שאלה‪ :‬למה 𝑃 ∈ }𝑘 < ‪?𝐿4 = {(< 𝐺 >, 𝑘)| 𝑇ℎ𝑒 𝑠ℎ𝑜𝑟𝑡𝑒𝑠𝑡 𝑝𝑎𝑡ℎ 𝑖𝑛 𝐺 𝑖𝑠 𝑜𝑓 𝑙𝑒𝑛𝑔𝑡ℎ‬‬
‫‪2‬‬
‫תשובה‪ :‬כמה מסלולים אפשריים יש לנו בגרף 𝐺?‪ :‬יש לנו 𝑛 מסלולים בין כל זוג קודקודים‪ ,‬ואם נעבור על כל‬
‫המסלולים האלה‪ ,‬אפשר למצוא את המסלול המינימלי ביותר בגרף 𝐺 ובסופו לוודא שהוא קטן מספיק מ‪.𝑘-‬‬
‫לכן קיימת מכונה דטרמיניסטית בזמן פולינומי שתכריע את השפה ‪.𝐿4‬‬

‫עבור מ"ט 𝑀‪ ,‬נגדיר את השפה‪.𝐿4,𝑀 = {𝑥 | 𝑀 ℎ𝑎𝑠 𝑎𝑡 𝑙𝑒𝑎𝑠𝑡 4 𝑎𝑐𝑐𝑒𝑝𝑡𝑖𝑛𝑔 𝑝𝑎𝑡ℎ𝑠 𝑟𝑢𝑛𝑛𝑖𝑛𝑔 𝑜𝑛 𝑥} :‬‬
‫נגדיר מחלקת שפות‪.𝑁𝑃4 = {𝐿 | ∃𝑀 𝑛𝑜𝑛𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑖𝑠𝑡𝑖𝑐 𝑝𝑜𝑙𝑦𝑛𝑜𝑚𝑖𝑎𝑙 𝑇𝑀 𝑠. 𝑡. 𝐿4,𝑀 = 𝐿} :‬‬
‫הוכיחו‪.𝑁𝑃 ⊆ 𝑁𝑃4 :‬‬
‫רעיון ההוכחה‪ :‬נבנה מכונה '𝐿𝑀 של שפה ב‪ 𝑁𝑃4-‬שתפעיל מכונה 𝐿𝑀 של שפה ב‪ ,𝑁𝑃-‬כך שבכל פעם שיהיה‬
‫לנו מסלול מקבל ב‪ ,𝑀𝐿-‬המכונה '𝐿𝑀 תפצל את המסלול הזה ל‪ 4-‬תתי מסלולים כך שכל אחד מהם הוא גם‬
‫מסלול מקבל‪.‬‬
‫הוכחה‪ :‬תהי 𝑃𝑁 ∈ 𝐿‪ .‬צריך להוכיח כי ‪.𝐿 ∈ 𝑁𝑃4‬‬
‫𝑃𝑁 ∈ 𝐿 ולכן קיימת 𝐿𝑀 מ"ט א"ד פולינומית המכריעה את השפה 𝐿‪.‬‬
‫בניית המכונה‪ :‬נבנה את '𝐿𝑀 מ"ט א"ד חדשה‪:‬‬
‫המכונה '𝐿𝑀 על קלט 𝑥 תבצע‪:‬‬
‫‪ .1‬מריצה את 𝐿𝑀 על 𝑥‪.‬‬
‫‪ .2‬אם דחתה ‪ -‬דוחה‪.‬‬
‫‪ .3‬אם 𝐿𝑀 קיבלה את 𝑥‪:‬‬
‫‪ .4‬מנחשת ביט‪.‬‬
‫‪ .5‬מנחשת ביט‪.‬‬
‫‪ .6‬מקבלת‪.‬‬
‫סיבוכיות זמן הריצה‪ :‬קל לראות ש‪ 𝑀𝐿' :‬פולינומית‪ .‬הרצה של 𝐿𝑀 על 𝑥 היא פולינומית כי 𝑃𝑁 ∈ 𝐿‪ ,‬ושאר‬
‫הניחושים של '𝐿𝑀 הם בזמן קבוע‪.‬‬
‫הוכחת נכונות הבניה‪ :‬עבור שפה 𝑃𝑁 ∈ 𝐿 ושפה ‪ ,𝐿4,𝑀 ' ∈ 𝑁𝑃4‬נוכיח כי 𝐿 = ' 𝑀‪.𝐿4,‬‬
‫𝐿‬ ‫𝐿‬
‫● אם 𝐿 ∉ 𝑥 ← 𝐿𝑀 תעצור ותדחה בכל מסלול חישוב (לפי הגדרה של מ"ט א"ד מכריעה) ← '𝐿𝑀‬
‫תעצור ותדחה בכל מסלול חישוב ← ' 𝑀‪.𝑥 ∉ 𝐿4,‬‬
‫𝐿‬
‫● אם 𝐿 ∈ 𝑥 ← קיים מסלול חישוב מקבל שבו 𝐿𝑀 תעצור ותקבל ← ל‪ 𝑀𝐿' -‬יש ארבעה מסלולי חישוב‬
‫מקבלים‪ ,‬עבור ניחושי הביטים ‪𝑥 ∈ 𝐿4,𝑀 ' ← 00,01,10,11‬‬
‫𝐿‬
‫הוכחנו כי 𝐿 = ' 𝑀‪ 𝐿4,‬ומאחר ו‪ 𝐿4,𝑀 ' ∈ 𝑁𝑃4-‬אז גם ‪.𝐿 ∈ 𝑁𝑃4‬‬

‫𝐿‬ ‫𝐿‬
‫ומכאן ‪ 𝑁𝑃 ⊆ 𝑁𝑃4‬כנדרש‪.‬‬
‫∎‬
‫שאלה ‪ - 10‬תרגול ‪ P - 5‬סגורה למשלים‬

‫טענה‪ :‬אם 𝑃 ∈ 𝐿 אז גם 𝑃 ∈ ‾𝐿‪.‬‬
‫הוכחה‪ :‬מכיוון ש 𝑃 ∈ 𝐿‪ ,‬אזי יש לה מ"ט 𝑀 דטרמיניסטית פולינומית שמכריעה אותה‪.‬‬
‫בניית המכונה‪ :‬נבנה מ"ט '𝑀 דטרמיניסטית פולינומית מכריעה עבור ‾𝐿‪.‬‬
‫המכונה '𝑀 על קלט 𝑥 תבצע‪:‬‬
‫‪ .1‬מריצה את 𝑀 על 𝑥‪.‬‬
‫‪ .2‬אם 𝑀 קיבלה‪ ,‬תדחה‪.‬‬
‫‪ .3‬אם 𝑀 דחתה‪ ,‬תקבל‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי )'𝑀(𝐿 = ‾𝐿‪.‬‬
‫● ‾𝐿 ∈ 𝑥 ← 𝑀 דוחה ← '𝑀 תקבל ← )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫● ‾𝐿 ∉ 𝑥 ← 𝑀 מקבלת ← '𝑀 דוחה ← '𝑀(𝐿 ∉ 𝑥‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬מאחר ו‪ 𝑀-‬מ"ט מכריעה ופולינומית אז גם '𝑀 פולינומית‪.‬‬
‫∎‬
‫שאלה ‪ - 11‬תרגול ‪5‬‬

‫טענה‪.𝑃 ⊆ 𝑐𝑜𝑁𝑃 :‬‬
‫הוכחה‪ :‬אם 𝑃 ∈ 𝐿 אז לפי סגירות למשלים גם 𝑃 ∈ ‾𝐿‪ .‬מאחר ו‪ 𝑃 ⊆ 𝑁𝑃-‬אזי 𝑃𝑁 ∈ ‾𝐿 ומכאן‬
‫‾‬
‫𝑃𝑁𝑜𝑐 ∈ 𝐿 = ‾𝐿‪.‬‬
‫∎‬
‫שאלה ‪ - 12‬תרגול ‪ P - 5‬סגורה לחיתוך‬

‫טענה‪ :‬אם 𝑃 ∈ ‪ ,𝐿1, 𝐿2‬אז גם 𝑃 ∈ ‪.𝐿1 ∩ 𝐿2‬‬
‫הוכחה‪ :‬מכיוון ש‪ 𝐿1, 𝐿2 ∈ 𝑃 :‬אז קיימות להן מ"ט דטרמיניסטיות פולינומיות מכריעות ‪.𝑀1, 𝑀2‬‬
‫בניית המכונה‪ :‬נבנה '𝑀 מ"ט דטרמיניסטית פולינומית מכריעה עבור השפה ‪.𝐿1 ∩ 𝐿2‬‬
‫המכונה '𝑀 על הקלט 𝑥 תבצע‪:‬‬
‫‪ .1‬תסמלץ את ‪ 𝑀1‬על 𝑥‪.‬‬
‫‪ .2‬תסמלץ את ‪ 𝑀2‬על 𝑥‪.‬‬
‫‪ .3‬אם שתיהן מקבלות‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי )'𝑀(𝐿 = ‪.𝐿1 ∩ 𝐿2‬‬
‫● ‪ 𝑀1 ← 𝑥 ∈ 𝐿1 ∩ 𝐿2‬מקבל על 𝑥 וגם ‪ 𝑀2‬מקבל על 𝑥 ← '𝑀 מקבל ← )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫● ‪ 𝑀1 ← 𝑥 ∉ 𝐿1 ∩ 𝐿2‬דוחה על 𝑥 או ‪ 𝑀2‬דוחה על 𝑥 ← '𝑀 דוחה ← )'𝑀(𝐿 ∉ 𝑥‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬מאחר ו‪ 𝑀1, 𝑀2-‬הן מכונות מכריעות ופולינומיות אזי גם '𝑀 פולינומית‪.‬‬
‫∎‬
‫שאלה ‪ - 13‬תרגול ‪ NP - 5‬סגורה לשרשור‬

‫טענה‪ :‬אם 𝑃𝑁 ∈ ‪ 𝐿1, 𝐿2‬אזי גם 𝑃𝑁 ∈ ‪.𝐿1 · 𝐿2‬‬
‫הוכחה‪ :‬מכיוון ש‪ 𝐿1, 𝐿2 ∈ 𝑁𝑃 :‬אזי קיימות להן מ"ט א"ד פולינומיות מכריעות ‪.𝑀1, 𝑀2‬‬
‫נבנה את '𝑀 מ"ט א"ד פולינומית שמכריעה את השפה ‪.𝐿1 · 𝐿2‬‬
‫‪ .1‬תנחש פירוק של 𝑥 מהצורה 𝑢𝑤 = 𝑥‪.‬‬
‫‪ .2‬תסמלץ את ‪ 𝑀1‬על 𝑤‪.‬‬
‫‪ .3‬תסמלץ את ‪ 𝑀2‬על 𝑢‪.‬‬
‫‪ .4‬אם שתיהן קיבלו‪ ,‬קבל‪ .‬אחרת‪ ,‬אם לפחות אחת מהן דחתה‪ ,‬דחה‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי )'𝑀(𝐿 = ‪.𝐿1 · 𝐿2‬‬
‫● ‪ ← 𝑥 ∈ 𝐿1 · 𝐿2‬קיים פירוק 𝑢𝑤 = 𝑥 כך ש‪ ← 𝑤 ∈ 𝐿1 ∧ 𝑢 ∈ 𝐿2 :‬קיים ניחוש כזה‬
‫‪ 𝑀' ← 𝑀1(𝑤) = 1 ∧ 𝑀2(𝑢) = 1‬תקבל ← )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫● ‪ ← 𝑥 ∉ 𝐿1 · 𝐿2‬לכל פירוק 𝑢𝑤 = 𝑥 כך ש‪ ← 𝑤 ∉ 𝐿1 ∨ 𝑢 ∉ 𝐿2 :‬לכל ניחוש‪,‬‬
‫‪ 𝑀' ← 𝑀1(𝑤) = 0 ∨ 𝑀2(𝑢) = 0‬תדחה ← )'𝑀(𝐿 ∉ 𝑥‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬המכונות ‪ 𝑀1, 𝑀2‬פולינומיות ולכן גם '𝑀 פולינומית‪.‬‬
‫∎‬
‫שאלה ‪ - 14‬תרגול ‪ P - 5‬סגורה לשרשור‬

‫טענה‪ :‬אם 𝑃 ∈ ‪ 𝐿1, 𝐿2‬אזי גם 𝑃 ∈ ‪.𝐿1 · 𝐿2‬‬
‫הוכחה‪ :‬מכיוון ש‪ 𝐿1, 𝐿2 ∈ 𝑃 :‬אזי קיימות להן מ"ט דטרמיניסטיות פולינומיות מכריעות ‪.𝑀1, 𝑀2‬‬
‫נבנה את '𝑀 מ"ט דטרמיניסטית פולינומית שמכריעה את השפה ‪.𝐿1 · 𝐿2‬‬
‫‪ .1‬לכל פירוק של 𝑥 מהצורה 𝑢𝑤 = 𝑥‪:‬‬
‫‪ .a‬תסמלץ את ‪ 𝑀1‬על 𝑤‪.‬‬
‫‪ .b‬תסמלץ את ‪ 𝑀2‬על 𝑢‪.‬‬
‫‪ .c‬אם שתיהן קיבלו‪ ,‬קבל‪.‬‬
‫‪ .2‬אם כל הפירוקים לא הצליחו ‪ -‬דחה‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי )'𝑀(𝐿 = ‪.𝐿1 · 𝐿2‬‬
‫● ‪ ← 𝑥 ∈ 𝐿1 · 𝐿2‬קיים פירוק 𝑢𝑤 = 𝑥 כך ש‪ ← 𝑤 ∈ 𝐿1 ∧ 𝑢 ∈ 𝐿2 :‬קיים פירוק כזה כך ש‪:‬‬
‫‪ 𝑀' ← 𝑀1(𝑤) = 1 ∧ 𝑀2(𝑢) = 1‬תקבל ← )'𝑀(𝐿 ∈ 𝑥‪.‬‬
‫● ‪ ← 𝑥 ∉ 𝐿1 · 𝐿2‬לכל פירוק 𝑢𝑤 = 𝑥 כך ש‪ ← 𝑤 ∉ 𝐿1 ∨ 𝑢 ∉ 𝐿2 :‬לכל פירוק‪,‬‬
‫‪ 𝑀' ← 𝑀1(𝑤) = 0 ∨ 𝑀2(𝑢) = 0‬תדחה ← )'𝑀(𝐿 ∉ 𝑥‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬המכונות ‪ 𝑀1, 𝑀2‬פולינומיות ולכן גם '𝑀 פולינומית‪.‬‬
‫כמה אפשרויות פירוק יש למילה 𝑛 = |𝑥|? ‪ -‬יש לנו ‪ 𝑛 + 1‬אפשרויות כאלה ולכן )𝑛(𝑂 ‪ -‬פולינומי‪.‬‬
‫לכל אחת מה‪ 𝑛-‬אפשרויות שלנו‪ ,‬נבדוק עבורה את המכונות ‪ 𝑀1, 𝑀2‬שהם בזמן פולינומי‪.‬‬
‫∎‬
‫שאלה ‪ - 15‬תרגול ‪ P - 5‬סגורה לאיטרציה‬

‫⋆‬
‫טענה‪ :‬אם 𝑃 ∈ 𝐿 אז גם 𝑃 ∈ 𝐿‪.‬‬
‫תזכורת‪ :‬כאשר הוכחנו ש‪ 𝑅 :‬סגורה לאיטרציה‪ ,‬מה שעשינו זה פשוט לעבור על כל החלוקות האפשריות של‬
‫המילה לתתי מילים‪.‬‬
‫בעיה‪ :‬יש כמות אקספוננציאלית של חלוקות כאלה!‬
‫⋆‬
‫שיטה‪ :‬מתי 𝐿 ∈ 𝑥?‬
‫‪ .1‬אם ‪.𝑥 = ε‬‬
‫‪ .2‬אם 𝐿 ∈ 𝑥‪.‬‬
‫⋆‬
‫‪ .3‬אם קיימים מילים 𝐿 ∈ 𝑢 ‪ 𝑤,‬כך ש‪.𝑥 = 𝑤𝑢 :‬‬
‫נשתמש בתכנון דינאמי על מנת לפתור את הבעיה ☹‪.‬‬
‫תכנון דינמי‪:‬‬
‫עבור מילה 𝑤‪ ,‬נגדיר את 𝑗‪ 𝑤𝑖,‬להיות תת המילה מאינדקס 𝑖 ועד אינדקס 𝑗‪.‬‬
‫⋆‬
‫נבנה טבלה 𝑏𝑎𝑇 המאותחלת ב‪ ,𝐹-‬בה כל תא 𝑗 ‪ 𝑖,‬יחזיק ערך בוליאני שיסמן האם תת‪-‬המילה 𝑗‪ 𝑤𝑖,‬שייכת ל‪.𝐿 -‬‬
‫לכל תא ]𝑗[]𝑖[ בטבלה‪ ,‬נצטרך לבדוק‪:‬‬
‫‪ .1‬האם 𝐿 ∈ 𝑗‪.𝑤𝑖,‬‬
‫⋆‬
‫‪ .2‬לבדוק את כל החלוקות לשתי מילים בין הטווח )𝑗 ‪ ,[𝑖,‬ואם באחת מהן שתי המילים ב‪.𝐿 -‬‬
‫מה תהיה התשובה הסופית שנקבל בעזרת הטבלה?‪ :‬התשובה נמצאת בתא ]𝑛[]‪.𝑇𝑎𝑏[1‬‬
‫⋆‬
‫למה? ‪ -‬כי זה תת המילה 𝑛‪ 𝑤1,‬כלומר זו המילה 𝑤 כולה שבדיוק עליה נרצה לשאול האם 𝐿 ∈ 𝑤‪.‬‬
‫המכונה המלאה‪:‬‬
‫𝑀 על קלט 𝑤 תבצע‪:‬‬
‫)‪ 𝑂(1‬אם ‪ - 𝑤 = ε‬אז נקבל‪.‬‬
‫‪2‬‬
‫) 𝑛(𝑂 נאתחל טבלה 𝑏𝑎𝑇 בגודל 𝑛𝑥𝑛 עם הערכים 𝑒𝑠𝑙𝑎𝐹‪.‬‬
‫)𝑛(𝑂 עבור 𝑛 ≤ 𝑖 ≤ ‪:1‬‬
‫עבור 𝑛 ≤ 𝑗 ≤ 𝑖‪( :‬אנחנו עוברים החל מ‪ ,𝑖-‬כי אנחנו צריכים חלוקה ל‪ 2-‬כך שהאינדקס הימני גדול מהשמאלי)‪.‬‬ ‫)𝑛(𝑂‬
‫נריץ את 𝐿𝑀 על 𝑗‪.𝑤𝑖,‬‬ ‫)𝑛(𝑝‬
‫]𝑗[]𝑖[𝑏𝑎𝑇‪( .‬התנאי הראשון עבד‪ ,‬המילה אכן בשפה ונסמן אותה)‪.‬‬ ‫אם קיבלה‪= 𝑇𝑟𝑢𝑒 :‬‬ ‫)‪𝑂(1‬‬
‫אחרת‪( :‬נבדוק את התנאי השני‪ ,‬כלומר נבדוק את כל החלוקות לשתי מילים)‪.‬‬
‫עבור ‪( :𝑖 ≤ 𝑘 ≤ 𝑗 − 1‬כלומר נבדוק שאם 𝐿 ∈ 𝑤 וגם 𝐿 ∈ 𝑢 אז גם 𝐿 ∈ 𝑢𝑤‬
‫⋆‬ ‫⋆‬ ‫⋆‬
‫= 𝑥)‪.‬‬ ‫)𝑛(𝑂‬
‫אם 𝑒𝑢𝑟𝑇 = ]𝑗[]‪ 𝑇𝑎𝑏[𝑘 + 1‬וגם 𝑒𝑢𝑟𝑇 = ]𝑘[]𝑖[𝑏𝑎𝑇‪:‬‬ ‫)‪𝑂(1‬‬
‫אז 𝑒𝑢𝑟𝑇 = ]𝑗[]𝑖[𝑏𝑎𝑇‪.‬‬
‫אם 𝑒𝑢𝑟𝑇 = ]𝑛[]‪ ,𝑇𝑎𝑏[1‬אז נקבל‪.‬‬ ‫)‪𝑂(1‬‬
‫אחרת‪ ,‬נדחה‪.‬‬
‫‪2‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪3‬‬

‫זמן הריצה של המכונה שבנינו‪.𝑂(𝑛 · 𝑝(𝑛)) + 𝑂(𝑛 · 𝑛) = 𝑂(𝑛 · 𝑝(𝑛) + 𝑛 ):‬‬
‫⋆‬
‫שכמובן שזה בזמן פולינומי ולכן אם 𝑃 ∈ 𝐿 אז גם 𝑃 ∈ 𝐿‪.‬‬
‫רדוקציה פולינומית‬
‫תזכורות מתורת החישוביות‬
‫‪ .1‬השפות הקלות במחלקה 𝐸𝑅 הן השפות הכריעות (𝑅)‪.‬‬
‫יש רדוקציה מכל שפה 𝑅 ∈ 𝐿 לכל שפה לא טריוויאלית ב‪.𝑅𝐸-‬‬
‫‪ .2‬השפות הקשות במחלקה 𝐸𝑅 הן השפות השלמות ב‪.𝑅𝐸-‬‬
‫יש רדוקציה מכל שפה 𝐸𝑅 ∈ 𝐿 לכל שפה שלמה ב‪.𝑅𝐸-‬‬
‫רעיון הרדוקציה‪:‬‬
‫בפרק זה‪ ,‬באופן כמעט דומה לרדוקציות שראינו עד היום‪ 𝑁𝑃 ,‬יהיו הקשים ו‪ 𝑃-‬יהיו הקלים (כי 𝑃𝑁 ⊆ 𝑃)‪.‬‬
‫תזכורת‪ :‬איור של המחלקה 𝐸𝑅 (חוץ מהשפות‬

‫הטריוויאליות) משמאל‪:‬‬
‫הרדוקציות הכלליות לא מתאימות‬

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

‫הגדרה‪ :‬תהיינה 𝐵 ‪ 𝐴,‬שפות מעל האלפבתים 𝐴‪ Σ‬ו‪ .Σ𝐵-‬רדוקציה בזמן פולינומיאלי של 𝐴 ל‪ 𝐵-‬היא פונקציה‬
‫⋆‬ ‫⋆‬
‫מלאה (מוגדרת לכל קלט) הניתנת לחישוב בזמן פולינומיאלי (בגודל הקלט) 𝐵‪ 𝑓: Σ𝐴 → Σ‬שמקיימת‪:‬‬
‫‪ .1‬אם 𝐴 ∈ 𝑤 אז 𝐵 ∈ )𝑤(𝑓‪.‬‬
‫‪ .2‬אם 𝐴 ∉ 𝑤 אז 𝐵 ∉ )𝑤(𝑓‪.‬‬
‫בדרך כלל ברדוקציות כאלה נוכיח ש‪ 𝑤 ∈ 𝐴 → 𝑓(𝑤) ∈ 𝐵 :‬וגם 𝐴 ∈ 𝑤 → 𝐵 ∈ )𝑤(𝑓‪.‬‬
‫סימון‪ :‬אם יש רדוקציה בזמן פולינומיאלי של 𝐴 ל‪ 𝐵-‬מסמנים 𝐵𝑃≤𝐴‪.‬‬
‫ציור רדוקציוניסטי‪ :‬כל שפה ב‪ 𝑅-‬אפשר לעשות רדוקציה לשפה ב‪-‬‬

‫𝐸𝑅‪ .‬כל שפה ב‪ 𝑃-‬אפשר לעשות רדוקציה לשפה ב‪ .𝑁𝑃-‬חוץ מ‪2-‬‬
‫⋆‬ ‫⋆‬
‫הטריוויאליות ∅ ‪ .Σ ,‬למה? ‪ -‬אם מדובר למשל בשפה ‪ 𝐴 = Σ‬אז‬
‫בפונקצית הרדוקציה אנחנו צריכים לקחת את מה שיש ב‪ 𝐴-‬ל‪ 𝐵-‬וגם‬
‫לקחת את כל מה שב‪ 𝐴‾-‬ל‪ ,𝐵‾-‬אבל ב‪ 𝐴‾-‬אין כלום! (זה נכון גם להפך‬
‫⋆‬
‫אם ∅ = 𝐴)‪ .‬בין ∅ ל‪ Σ -‬אפשר לעשות רדוקציה (או להפך)‪ ,‬אבל‬
‫⋆‬
‫מהשפות ∅ ‪ Σ ,‬לכל השפות האחרות אי אפשר לעשות רדוקציה‪.‬‬
‫הגדרה עבור שפות מאותו א"ב‪ :‬אם שתי השפות מעל אותו א"ב‪ ,‬נוכל להגדיר בצורה פשוטה יותר‪:‬‬
‫⋆‬ ‫⋆‬ ‫⋆‬
‫תהיינה ‪ ,𝐿1, 𝐿2 ⊆ Σ‬נאמר כי ‪( 𝐿1≤𝑃𝐿2‬כלומר‪ 𝐿1‬ניתנת לרדוקציה פולינומית ל‪ )𝐿2-‬אם קיימת פונקציה ‪ 𝑓: Σ → Σ‬המקיימת‪:‬‬
‫‪ 𝑓 .1‬מלאה‪.‬‬
‫‪ 𝑓 .2‬ניתנת לחישוב זמן פולינומי‪.‬‬
‫⋆‬
‫‪ 𝑓 .3‬תקפה‪ ,‬כלומר ‪.∀𝑥 ∈ Σ : 𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2‬‬
‫דוגמאות לרדוקציות פולינומיאליות‬

‫נתונות השפות הבאות‪:‬‬
‫}𝑘 𝑒𝑧𝑖𝑠 𝑓𝑜 𝑒𝑢𝑞𝑖𝑙𝑐 𝑎 𝑠𝑛𝑖𝑎𝑡𝑛𝑜𝑐 𝑡𝑎‪𝐶𝑙𝑖𝑞𝑢𝑒 = {< 𝐺, 𝑘 > |𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ‬‬
‫תזכורת‪ :‬קליקה‪ :𝐶𝑙𝑖𝑞𝑢𝑒 ,‬בהינתן גרף )𝐸 ‪ , 𝐺 = (𝑉,‬קליקה ב‪ 𝐺-‬היא תת קבוצה של קודקודים 𝑉 ⊆ 𝑆‬
‫המקיימת שכל זוג קודקודים ב‪ 𝑆-‬הם שכנים בגרף‪.‬‬
‫}𝑘 𝑒𝑧𝑖𝑠 𝑓𝑜 𝑡𝑒𝑠 𝑡𝑛𝑒𝑑𝑛𝑒𝑝𝑒𝑑𝑛𝑖 𝑛𝑎 𝑠𝑛𝑖𝑎𝑡𝑛𝑜𝑐 𝑡𝑎‪𝐼𝑆 = {< 𝐺, 𝑘 > |𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ‬‬
‫תזכורת‪ :‬קבוצה בלתי תלויה‪ :𝐼𝑛𝑑𝑒𝑝𝑒𝑛𝑑𝑒𝑛𝑡 𝑆𝑒𝑡,‬בהינתן גרף )𝐸 ‪ ,𝐺 = (𝑉,‬קבוצה בלתי תלויה ב‪ 𝐺-‬היא‬
‫תת קבוצה של קודקודים 𝑉 ⊆ 𝑆 המקיימת שלא קיימות צלעות בגרף ששני הקודקודים החלים בהן שייכים ל‪.𝑆-‬‬
‫(במילים אחרות‪ ,‬לכל אחת מהצלעות ב‪ 𝐺-‬יש לכל היותר קודקוד אחד ב‪.)𝑆-‬‬
‫}𝑘 𝑒𝑧𝑖𝑠 𝑓𝑜 𝑟𝑒𝑣𝑜𝑐 𝑥𝑒𝑡𝑟𝑒𝑣 𝑎 𝑠𝑛𝑖𝑎𝑡𝑛𝑜𝑐 𝑡𝑎‪𝑉𝐶 = {< 𝐺, 𝑘 > |𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ‬‬
‫הגדרה‪ :‬כיסוי קודקודים‪ :𝑉𝑒𝑟𝑡𝑒𝑥 𝐶𝑜𝑣𝑒𝑟 ,‬בהינתן גרף )𝐸 ‪ ,𝐺 = (𝑉,‬קבוצה‬
‫‪.‬‬ ‫𝑉 ⊆ 𝑆 היא קבוצת כיסוי קודקודים אם ורק אם כל צלע ב‪ 𝐺-‬חלה בקודקוד מ‪𝑆-‬‬
‫(כלומר‪ ,‬אין צלע בגרף שאין לה קצה בקבוצה 𝑆)‪.‬‬
‫הערה‪ :‬חיפוש של 𝑒𝑢𝑞𝑖𝑙𝐶 או של 𝐶𝑉 לא מתבצע בזמן פולינומי‪ ,‬אבל המעבר בין שניהם (רדוקציה) הוא‬
‫פולינומי ולכן נאמר שהם "קשים באותה המידה"‪ ,‬כלומר שניהם יהיו באותה המחלקה‪.‬‬
‫דוגמה ‪ :1‬איך עושים רדוקציה פולינומית 𝑆𝐼𝑃≤𝑒𝑢𝑞𝑖𝑙𝐶?‬

‫קלט‪𝐺, 𝑘 >∈ 𝐶𝑙𝑖𝑞𝑢𝑒 :‬‬
‫< (כל זוג קודקודים ב‪ 𝑆-‬הם שכנים בגרף 𝐺)‪.‬‬
‫פלט‪( < 𝐺‾, 𝑘' >∈ 𝐼𝑆 :‬לכל אחת מהצלעות ב‪ 𝐺‾-‬יש לכל היותר קודקוד אחד ב‪.)𝑆-‬‬
‫פונקצית הרדוקציה‪.𝑓(< 𝐺, 𝑘 >) =< 𝐺‾, 𝑘 > :‬‬
‫הסבר לפונקציה‪ :‬איך נתעסק בקליקה בשפה של 𝑆𝐼? אם יש לנו בגרף 𝐺 קליקה‪ ,‬אז כשנהפוך את כל הצלעות‪,‬‬
‫אותה הקליקה בדיוק תהיה ב‪ 𝐺‾-‬וה‪ 𝑘-‬נשאר אותו הדבר כי זו אותה הקליקה בדיוק‪.‬‬
‫הסבר כללי‪ :‬אנחנו לא חיפשו קליקה ב‪ ,𝐼𝑆-‬אנחנו נעזרנו ברדוקציה פולינומית שאומרת שאם יש קליקה ב‪ 𝐺-‬אז‬
‫בעזרת פונקצית הרדוקציה‪ ,‬יש לנו גם קליקה ב‪ .𝐺‾-‬מאחר ולא חיפשנו (חיפוש שלם) אז זה פולינומי כי אנחנו‬
‫בסה"כ עוברים על כל הצלעות בגרף והופכים אותם‪.‬‬
‫פתרון דוגמה ‪:1‬‬
‫פונקצית הרדוקציה‪.𝑓(< 𝐺, 𝑘 >) =< 𝐺‾, 𝑘 > :‬‬
‫הרדוקציה פולינומית‪ :‬כדי לחשב את 𝑓 יש לעבור על כל זוג קודקודים ב‪ ,𝐺-‬אם הקודקודים שכנים ב‪ ,𝐺-‬לא‬
‫תהיה ביניהם צלע ב‪ 𝐺‾-‬ואם הקודקודים לא שכנים ב‪ 𝐺-‬תהיה ביניהם צלע ב‪.𝐺‾-‬‬
‫לכן הסיבוכיות היא ) 𝑛(𝑂 = ) (‬

‫𝑛‬
‫‪( , 2‬כאשר 𝑛 הוא מספר הקודקודים ב‪ )𝐺-‬פולינומי‪( .‬בהנחה שניתן לבדוק האם זוג קודקודים‬
‫‪2‬‬
‫הם שכנים בזמן קבוע‪ ,‬הכי קל‪ :‬לעבור על מטריצת השכנויות ולהפוך כל ביט)‪.‬‬
‫תקפות הרדוקציה‪ :‬התקפות נובעת מהלמה הבאה‪:‬‬
‫למה‪ :‬עבור גרף )𝐸 ‪ ,𝐺 = (𝑉,‬קבוצת הקודקודים )𝐺(𝑉 ∈ 𝑆 היא קליקה ב‪ 𝐺-‬אם"ם 𝑆 היא קבוצה ב"ת ב‪.𝐺‾-‬‬
‫הוכחת הלמה‪:‬‬
‫● כיוון א'‪ :‬נניח ש‪ 𝑆-‬היא קליקה ב‪ ,𝐺-‬אזי כל הצלעות האפשרויות של זוגות קודקודים מ‪ 𝑆-‬קיימות ב‪,𝐺-‬‬
‫לכן ב‪ 𝐺‾-‬כל הצלעות הללו לא קיימות‪ ,‬מכאן ש‪ 𝑆-‬היא קבוצה בלתי תלויה ב‪.𝐺‾-‬‬
‫● כיוון ב'‪ :‬נניח ש‪ 𝑆-‬היא קבוצה בלתי תלויה ב‪ ,𝐺‾-‬אזי כל הצלעות האפשרויות של זוגות קודקודים מ‪ 𝑆-‬לא‬
‫קיימות ב‪ ,𝐺‾-‬לכן ב‪ 𝐺-‬כל הצלעות הללו קיימות‪ ,‬מכאן ש‪ 𝑆-‬היא קליקה ב‪.𝐺-‬‬
‫∎‬
‫דוגמה ‪ :2‬איך עושים רדוקציה פולינומית 𝐶𝑉𝑃≤𝑆𝐼?‬

‫קלט‪( < 𝐺, 𝑘 >∈ 𝐼𝑆 :‬לכל צלע בגרף 𝐺‪ ,‬יש לכל היותר קודקוד אחד ב‪.)𝑆-‬‬
‫< (לכל צלע בגרף 𝐺‪ ,‬לפחות אחד מקודקודיו שייך ל‪.)𝑆-‬‬ ‫פלט‪𝐺, 𝑛 − 𝑘 >∈ 𝑉𝐶 :‬‬
‫פונקצית הרדוקציה‪.𝑓(< 𝐺, 𝑘 >) =< 𝐺, 𝑛 − 𝑘 > :‬‬
‫הסבר‪ :‬אם קיימת ב‪ 𝐺-‬קבוצה בלתי תלויה בגודל 𝑘‪ ,‬אז קבוצת‬
‫כיסוי הקודקודים ב‪ 𝐺-‬היא בגודל 𝑘 ‪ .𝑛 −‬ראו ציור‪:‬‬
‫פתרון דוגמה ‪:2‬‬

‫הרדוקציה פולינומית‪ :‬כדי לחשב את 𝑓‪ ,‬הרדוקציה רק מחשבת את מספר קודקודי הגרף )= 𝑛( ומפחיתה מ‪𝑛-‬‬
‫ל‪ .𝑘-‬פעולות בזמן פולינומי‪.‬‬
‫תקפות הרדוקציה‪ :‬תקפות הרדוקציה נובעת מהלמה הבאה‪:‬‬
‫למה‪ :‬עבור גרף )𝐸 ‪ 𝐺 = (𝑉,‬קבוצת קודקודים )𝐺(𝑉 ⊆ 𝑆 היא בלתי תלויה ב‪ 𝐺-‬אם"ם 𝑆\𝑉 היא כיסוי‬
‫קודקודים של 𝐺‪.‬‬
‫הוכחת הלמה‪:‬‬
‫● כיוון א'‪ :‬נניח ש‪ 𝑆-‬היא קבוצה בלתי תלויה ב‪ ,𝐺-‬אזי אין צלעות המחברות שני קודקודים ב‪ ,𝑆-‬כלומר‪ ,‬כל‬
‫צלעות הגרף נוגעות בלכל היותר קודקוד אחד מ‪ .𝑆-‬אזי הקבוצה 𝑆\𝑉 נוגעת בלפחות קודקוד אחד‬
‫מכל צלע בגרף‪ ,‬כלומר 𝑆\𝑉 היא כיסוי קודקודים‪.‬‬
‫● כיוון ב'‪ :‬נניח ש‪ 𝑉\𝑆-‬היא כיסוי קודקודים ב‪ ,𝐺-‬אזי כל צלע ב‪ 𝐺-‬היא בעלת לפחות קודקוד אחד‬
‫בקבוצה 𝑆\𝑉‪ .‬מכאן שאין צלעות שחלות על שני קודקודים מ‪ ,𝑆-‬כלומר 𝑆 היא קבוצה בלתי תלויה‪.‬‬
‫∎‬
‫תרגיל בית‪ :‬הוכיחו שאם ‪ 𝐿1≤𝑃𝐿2‬אז ‪.𝐿1≤𝑃𝐿2‬‬
‫שייכות ל‪ P-‬בעזרת רדוקציה פולינומית‬

‫משפט הרדוקציה‪ :‬אם ‪ 𝐿1≤𝑃𝐿2‬ו‪ 𝐿2 ∈ 𝑃-‬אזי גם 𝑃 ∈ ‪.𝐿1‬‬
‫הערה‪ :‬לא נשתמש במסקנה הבאה (מקביל למסקנה שהשתמשנו בחישוביות)‪ :‬אם‪ 𝐿1≤𝑃𝐿2‬וגם 𝑃 ∉ ‪ ,𝐿1‬אז 𝑃 ∉ ‪.𝐿2‬‬
‫כלומר‪ ,‬לא נעסוק בשפות שהוכח עליהן שהן לא שייכות ל‪.𝑃-‬‬
‫הוכחת המשפט‪ :‬נניח כי ‪ 𝐿1≤𝑃𝐿2‬ו‪ .𝐿2 ∈ 𝑃-‬תהי 𝑓𝑀 מ"ט דטרמיניסטית פולינומית המחשבת את פונקציית‬
‫הרדוקציה‪ ,‬ויהי ‪ 𝑝1‬הפולינום החוסם את זמן הריצה שלה‪ .‬ותהי ‪ 𝑀2‬מ"ט דטרמיניסטית פולינומית המכריעה את‬
‫‪ ,𝐿2‬ויהי ‪ 𝑝2‬חסם זמן הריצה שלה‪.‬‬
‫נתאר מכונה ‪ 𝑀1‬דטרמיניסטית פולינומית המכריעה את ‪:𝐿1‬‬
‫‪ 𝑀1‬על הקלט 𝑥 תפעל‪:‬‬
‫מחשבת את )𝑥(𝑓‪( .‬סיבוכיות‪.)𝑂(𝑝1(|𝑥|)) :‬‬ ‫‪.1‬‬
‫‪2‬‬
‫(סיבוכיות‪.)( 𝑝2( 𝑝1(|𝑥|) ) ) :‬‬ ‫‪ .2‬מריצה את ‪ 𝑀2‬על )𝑥(𝑓 ועונה כמוה‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נכונות המכונה נובעת ישירות מהתקפות של פונקצית הרדוקציה‪.‬‬
‫(‬
‫) ) )|𝑥|(‪ 𝑂 𝑝1(|𝑥|) + ( 𝑝2( 𝑝1‬הוא פולינומי‪.‬‬
‫‪2‬‬
‫סיבוכיות זמן ריצה‪ :‬זמן הריצה של המכונה 𝑀 הוא )‬
‫‪1‬‬
‫∎‬
‫הערה לסיבוכיות של ההוכחה‪ :‬מכונה המריצה מכונה אחרת עולה לנו יותר זמן‪ ,‬כי יש לנו סרט נוסף שכותבים בו‬
‫את הקונפיגורציה של המכונה כדי שנדע לסמלץ אותה ולמדנו שהסרט הנוסף הזה הוא עד גודל ריבועי‪.‬‬
‫לכן תמיד שיש מכונה שמריצה מכונה נוספת אנחנו נוסיף לסיבוכיות שלה "בריבוע"‪.‬‬
‫משפטים נוספים‬
‫משפט ‪ :1‬אם ‪ 𝐿1≤𝑃𝐿2‬ו‪ 𝐿2 ∈ 𝑁𝑃-‬אז גם 𝑃𝑁 ∈ ‪.𝐿1‬‬
‫תרגיל ‪ :1‬הוכיחו את משפט ‪.1‬‬
‫פתרון תרגיל ‪ :1‬להשלים‪.‬‬
‫הערה‪ :‬גם כאן לא נשתמש במסקנה מן המשפט כדי להוכיח ששפות אינן שייכות ל‪.𝑁𝑃-‬‬
‫לא נעסוק בשפות שהוכח עליהן שהן לא שייכות ל‪.𝑁𝑃-‬‬
‫⋆‬
‫משפט ‪ :2‬אם 𝑃 ∈ ‪ 𝐿1‬ו‪ 𝐿2-‬היא שפה כלשהי ששונה מ‪ ∅-‬וגם מ‪ ,Σ -‬אז ‪.𝐿1≤𝑃𝐿2‬‬
‫תרגיל ‪ :2‬הוכיחו את משפט ‪.2‬‬
‫משפט ‪ :3‬היחס 𝑃≤ טרנזיטיבי‪.‬‬

‫תרגיל ‪ :3‬הוכיחו שהיחס 𝑃≤ הוא טרנזיטיבי‪ - .‬אם ‪ 𝐿1≤𝑃𝐿2‬וגם ‪ 𝐿2≤𝑃𝐿3‬אז ‪.𝐿1≤𝑃𝐿3‬‬
‫תרגיל ‪ :4‬האם היחס 𝑃≤ הוא רפלקסיבי? ‪ -‬הוכיחו‪.‬‬

‫פתרון תרגיל ‪ :4‬הוראות לפתרון ‪ -‬האם 𝐵𝑃≤𝐴 אז גם 𝐴𝑃≤𝐵? ‪ -‬לא ידוע אם זה רפלקסיבי‪ .‬כי אם 𝑃 ∈ 𝐴 וגם‬
‫𝑃𝑁 ∈ 𝐵 ‪ ,‬מאחר ולא ידוע האם 𝑃 ⊆ 𝑃𝑁 אז לא ידוע האם רפלקסיבי‪ .‬להשלים‪.‬‬
‫תרגיל ‪ :5‬האם היחס 𝑃≤ הוא סימטרי? ‪ -‬הוכיחו‪.‬‬

‫פתרון תרגיל ‪ :5‬הוראות לפתרון ‪ -‬מהי פונקצית רדוקציה פולינומית משפה לעצמה? ‪ -‬כלום‪ ,‬זה פונק' הזהות‬
‫ולכן זה סימטרי‪ .‬להשלים‪.‬‬
‫הערה‪ :‬אינטואיטיבית‪ ,‬אם ‪ , 𝐿1≤𝑃𝐿2‬אז ‪ 𝐿2‬קשה לפחות כמו ‪( 𝐿1‬במובן של קיום אלגוריתם מהיר לשפה)‪.‬‬
‫אם יש אלגוריתם מהיר לבדיקת השייכות ל‪ ,𝐿2-‬אז אפשר לבנות בעזרתו (ובעזרת הרדוקציה הפולינומית)‬
‫אלגוריתם מהיר לבדיקת השייכות ל‪.𝐿1-‬‬
‫השפות הקלות ב‪NP-‬‬

‫שאלה‪ :‬מי הן השפות הקלות ביותר במחלקה 𝑃𝑁 (ללא השפות הטריוויאליות)?‬
‫לפי הסיווג של קל‪/‬קשה בעזרת היחס 𝑃≤‪.‬‬ ‫‪-‬‬
‫תשובה‪ :‬אלה השפות (הלא טריוויאליות) ב‪.𝑃-‬‬
‫הסבר‪ :‬אם 𝑃 ∈ ‪ 𝐿1‬אז ‪ 𝐿1≤𝑃𝐿2‬לכל ‪ 𝐿2‬במחלקה‪ .‬כל ‪ 𝐿2‬במחלקה קשה לפחות כמו ‪ 𝐿1( 𝐿1‬הקלה ביותר)‪.‬‬
‫שפות ‪ NP‬שלמות‬
‫מחלקה 𝑃𝑁‪-‬שלמו ּת‬

‫הצבענו על הדמיון שקיים בין המחלקה 𝐸𝑅 והמחלקה 𝑃𝑁‪ ,‬ובין המחלקה 𝑅 והמחלקה 𝑃‪.‬‬
‫בהרצאה הזו נרחיב את הדמיון הזה גם למחלקה 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪ ,𝑅𝐸 −‬ונלמד על המקבילה שלה ‪-‬‬
‫שפות 𝑃𝑁‪-‬שלמות או 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪( .𝑁𝑃 −‬אולי אחת ההגדרות הכי חשובות במדעי המחשב)‪.‬‬
‫הסבר תכל'ס‪-𝑁𝑃 :‬שלם (לעיתים נסמן ב‪ )𝑁𝑃𝐶-‬אומר שלא ידוע על אלגוריתם (מכונה) יעיל (פולינומי) לשפה‪,‬‬
‫כלומר אם נצליח להראות רדוקציה משפה כלשהי לשפה 𝑒𝑡𝑒𝑙𝑝𝑚𝑜𝐶 ‪( 𝑁𝑃 −‬או להפך) אז אנחנו הוכחנו שלא‬
‫קיים אלגוריתם יעיל (פולינומי)‪ .‬אמרנו שלשפה ב‪ 𝑁𝑃-‬קיימת מ"ט א"ד פולינומית שמנחשת "עד" ואז בודקת‬
‫(‪ )validation‬עליו‪ .‬המחשב לא יודע לנחש (הוא דטרמיניסטי) אז כל עוד נקבל ששפה היא 𝑃𝑁‪-‬שלמה‪ ,‬נדע‬
‫שלא צריך לבזבז זמן יקר בלחפש עבורה אלגוריתם פולינומי (כי אין כזה)‪.‬‬
‫תזכורת‪RE-Complete :‬‬
‫שפה ‪ 𝐿2‬היא שלמה ב‪ 𝑅𝐸-‬אם‪:‬‬
‫𝐸𝑅 ∈ ‪( 𝐿2‬שייכת למחלקה)‪.‬‬ ‫‪.1‬‬
‫‪ .2‬לכל שפה 𝐸𝑅 ∈ ‪ 𝐿1‬מתקיים ש‪( 𝐿1 ≤ 𝐿2 :‬קשה ביותר במחלקה)‪.‬‬
‫חשוב‪ :‬השפות השלמות ב‪ 𝑅𝐸-‬הן הקשות ביותר במחלקה 𝐸𝑅‪.‬‬
‫שפות ‪ NP‬קשות (‪ :)NPH‬שפה 𝐻𝑃𝑁 ∈ ‪ 𝐿2‬קשה אם לכל 𝑃𝑁 ∈ ‪ 𝐿1‬קיימת רדוקציה פולינומית ‪.𝐿1≤𝑃𝐿2‬‬
‫הגדרה‪ :‬שפות ‪-NP‬שלמות‬

‫שפה ‪ 𝐿2‬היא שלמה ב‪ 𝑁𝑃-‬אם‪:‬‬
‫𝑃𝑁 ∈ ‪( 𝐿2‬שייכת למחלקה)‪.‬‬ ‫‪.1‬‬
‫‪ .2‬לכל שפה 𝑃𝑁 ∈ ‪ 𝐿1‬מתקיים ש‪( 𝐿1≤𝑃𝐿2 :‬קשה ביותר במחלקה)‪.‬‬
‫מדובר על שפות השייכות למחלקה‪ ,‬ולכל שפה במחלקה יש רדוקציה בזמן פולינומיאלי אליהן‪.‬‬
‫חשוב‪ :‬השפות השלמות ב‪ 𝑁𝑃-‬הן הקשות לפחות כמו כל שפה אחרת במחלקה 𝑃𝑁‪.‬‬
‫איך נכריע האם ‪P=NP‬‬

‫משפט‪ :‬אם יש שפה 𝐶𝑃𝑁 (שלמה) ששייכת ל‪ ,𝑃-‬אז 𝑃𝑁 = 𝑃‪.‬‬
‫תרגיל‪ :‬הוכיחו את המשפט‪.‬‬
‫מסקנה‪:‬‬
‫● אם רוצים להוכיח ש‪ ,𝑃 = 𝑁𝑃 :‬די להראות מ"ט דטרמיניסטית בזמן ריצה פולינומי לאחת השפות‬
‫השלמות ב‪.𝑁𝑃-‬‬
‫● אם רוצים להוכיח ש‪ ,𝑃 ≠ 𝑁𝑃 :‬אפשר להוכיח על שפה 𝑃𝑁 ∈ 𝐿 שאין לה מ"ט דטרמיניסטית בזמן‬
‫ריצה פולינומי‪ .‬סביר ש‪ 𝐿-‬תהיה 𝐶𝑃𝑁‪( ,‬למה?)‪.‬‬
‫האם יש שפות שלמות במחלקה ‪?NPC‬‬

‫שאלה‪ :‬נותרה השאלה האם יש בכלל שפות 𝑃𝑁‪-‬שלמות?‪ .‬כלומר‪ ,‬האם יש שפות ב‪ 𝑁𝑃-‬כך שלכל שפה ב‪𝑁𝑃-‬‬
‫יש רדוקציה בזמן פולינומי אליהן?‪.‬‬
‫תשובה‪ :‬יש שפות כאלה‪ .‬יש במחלקה 𝑃𝑁 שפות שלמות‪( .‬שפות קשות ביותר מחלקה)‪.‬‬
‫השפה הראשונה שהוכח עליה שהיא 𝐶𝑃𝑁 היא שפת הפסוקים הספיקים בתחשיב הפסוקים‪.‬‬
‫ומ ַּק ׁ ָּש ִרים‪.‬‬

‫תזכורת מהקורס בלוגיקה‪ :‬פסוק בתחשיב הפסוקים בנוי ממשתנים פסוקיים (אטומים) ִ‬
‫● המשתנים הפסוקיים (אטומים) ‪ -‬יכולים לקבל ערך 𝑒𝑢𝑟𝑇 (או ‪ ,)1‬או 𝑒𝑠𝑙𝑎𝐹 (או ‪.)0‬‬
‫● ערך האמת ‪ -‬של הפסוק 𝑒𝑠𝑙𝑎𝐹 𝑟𝑜 𝑒𝑢𝑟𝑇 נקבע לפי טבלאות האמת של הקשרים‪.‬‬
‫● סוגי קשרים ‪ -‬אנחנו נסתפק בשלושת הקשרים הבאים‪.∨, ∧, ¬ :‬‬
‫● שם הנוסחה ‪ -‬נכתוב )𝑛𝑥 ‪.ϕ(𝑥1, 𝑥2,...,‬‬
‫פסוקים ספיקים‬
‫הגדרה‪ :‬פסוק נקרא ספיק אם יש לפחות השמה אחת של ערכי אמת למשתנים של הפסוק שבה ערך האמת של‬
‫הפסוק הוא 𝑒𝑢𝑟𝑡‪.‬‬
‫תרגיל‪ :‬הפסוק )𝑦 ∨ 𝑥¬( ∧ )𝑦¬ ∨ 𝑥( = )𝑦 ‪ ϕ(𝑥,‬הוא פסוק מעל המשתנים 𝑥 ו‪ .𝑦-‬האם הוא ספיק?‬
‫תשובה‪ :‬בהחלט‪ .‬הנוסחה מקבילה לשער 𝑅𝑂𝑁𝑋‪.‬‬
‫בעיית הספיקות ‪ -‬השפה ‪SAT‬‬

‫מבוא‬
‫בעיית הספיקות בתחשיב הפסוקים (בקיצור‪ - 𝑆𝐴𝑇 :‬קיצור של המילה‬
‫האנגלית 𝑦𝑡𝑖𝑙𝑖𝑏𝑎𝑖𝑓𝑠𝑖𝑡𝑎𝑆‪ ,‬ספיקות) היא בעיית הכרעה הנחקרת‬
‫במסגרת תורת הסיבוכיות‪ .‬בעיה זו הייתה הבעיה הראשונה עליה הוכח כי‬
‫היא ‪-NP‬שלמה (הוכחה זו היא משפט קוק‪-‬לוין)‪ ,‬משמע אם קיים לה פתרון‬
‫אלגוריתמי הרץ בזמן פולינומי אזי קיים פתרון כזה לכל בעיה ב‪( NP-‬מחלקת‬
‫כל הבעיות שעבורן קיים מוודא בזמן פולינומי)‪ .‬בעיה זו משמשת בהוכחות רבות עבור‬
‫בעיות ‪-NP‬שלמות אחרות‪.‬‬
‫הגדרה ‪ -‬השפה ‪SAT‬‬

‫השפה 𝑇𝐴𝑆 היא שפת הפסוקים הספיקים בתחשיב הפסוקים‪:‬‬
‫}𝑎𝑙𝑢𝑚𝑟𝑜𝑓 𝑛𝑎𝑒𝑙𝑜𝑜𝐵 𝑒𝑙𝑏𝑎𝑖𝑓𝑠𝑖𝑡𝑎𝑠 𝑎 𝑠𝑖 ‪𝑆𝐴𝑇 = {< ϕ > | ϕ‬‬
‫משפט ‪Cook-Levin‬‬
‫משפט‪ .𝑆𝐴𝑇 ∈ 𝑁𝑃𝐶 :‬כלומר‪ ,‬השפה 𝑇𝐴𝑆 היא 𝑃𝑁‪-‬שלמה‪.‬‬
‫רעיון ההוכחה‪ :‬צריך להוכיח שני דברים‪:‬‬
‫‪.𝑆𝐴𝑇 ∈ 𝑁𝑃 .1‬‬
‫‪ .2‬לכל שפה 𝑃𝑁 ∈ 𝐿 מתקיים ש‪.𝐿≤𝑃𝑆𝐴𝑇 :‬‬
‫משפט ‪ ,Cook-Levin‬חלק א'‪ :‬הוכחה 𝑃𝑁 ∈ 𝑇𝐴𝑆‪.‬‬

‫להלן 𝐿𝑁 מ"ט א"ד פולינומית‪:‬‬
‫‪ .1‬נחש השמה למשתנים 𝑛𝑥 ‪.𝑥1,...,‬‬
‫‪ .2‬הצב את ערך הניחוש‪ ,‬וודא שהפסוק מקבל 𝑒𝑢𝑟𝑇‪.‬‬
‫● 𝑇𝐴𝑆 ∈> ‪ ← < ϕ‬קיימת השמה מספקת לביטוי ‪ ← ϕ‬המכונה 𝐿𝑁 תנחש את ההשמה הנכונה ←‬
‫המכונה תענה 𝑒𝑢𝑟𝑇 ← )𝐿𝑁(𝐿 ∈> ‪.< ϕ‬‬
‫● 𝑇𝐴𝑆 ∉> ‪ ← < ϕ‬לא קיימת השמה מספקת לביטוי ‪ ← ϕ‬לכל ניחוש של 𝐿𝑁 התשובה תהיה 𝑒𝑠𝑙𝑎𝐹‬
‫← )𝐿𝑁(𝐿 ∉> ‪.< ϕ‬‬
‫משפט ‪ ,Cook-Levin‬חלק ב'‪ :‬הוכחת הרדוקציה הפולינומית‬

‫צריך להראות שלכל שפה 𝑃𝑁 ∈ 𝐿 מתקיים 𝑇𝐴𝑆𝑃≤𝐿‪.‬‬
‫מה אנחנו יודעים על 𝐿?‪ :‬לא הרבה‪ .‬אנחנו יודעים שהיא ב‪ .𝑁𝑃-‬כלומר‪ ,‬יש לה מכונה לא דטרמיניסטית מכריעה‬
‫𝑘‬
‫𝑁 שרצה בזמן ) 𝑛(𝑂 פולינומי ל‪ 𝑘-‬טבעי כלשהו‪.‬‬
‫איך תיראה הרדוקציה?‪ :‬הרדוקציה תקבל כקלט מילה 𝑤 מעל האלפבית של 𝐿‪.‬‬
‫הרדוקציה תבנה (בזמן פולינומיאלי ב‪ )|𝑤|-‬פסוק בתחשיב הפסוקים שיהיה ספיק אם"ם 𝐿 ∈ 𝑤‪.‬‬
‫כלומר‪ ,‬הפסוק ייבנה כך שהוא יהיה ספיק אם"ם יש ל‪ 𝑁-‬חישוב מקבל על 𝑤‪.‬‬
‫תמונה של מסלול חישוב‪ :‬נניח אם כן שיש ל‪ 𝐿 ∈ 𝑁𝑃-‬מכונה א"ד מכריעה 𝑁 שזמן הריצה שלה על מילה 𝑤‬
‫𝑘‬
‫חסום על‪-‬ידי 𝑛 כאשר )|𝑤| = 𝑛( ל‪ 𝑘-‬טבעי כלשהו (קבוע)‪.‬‬
‫‪𝑘+1‬‬ ‫𝑘‬
‫𝑛 על הסרט שלה (מניחים של‪ 𝑁-‬יש סרט יחיד)‪.‬‬ ‫בתוך 𝑛 צעדים 𝑁 יכולה להגיע לכל היותר לריבוע ה‪-‬‬
‫מטריצת ‪ :tableau‬נשתמש בטבלה הזאת (קונספטואלית) כדי לייצר פסוק (לא כחלק מהבניה)‪.‬‬
‫𝑘‬ ‫𝑘‬
‫(‬ ‫( )‬ ‫)‬
‫תמונה של ריצת 𝑁 על 𝑤 באחד ממסלולי החישוב היא מטריצה (𝑢𝑎𝑒𝑙𝑏𝑎𝑡) מסדר ‪- 𝑛 + 1 × 𝑛 + 2‬‬
‫● השורה הראשונה מתאימה לקונפיגורציה ההתחלתית‪.‬‬
‫● השורה ה‪ 𝑖-‬מתאימה לקונפיגורציה ה‪ 𝑖 − 1-‬בחישוב‪.‬‬
‫𝑘‬ ‫𝑘‬
‫● השורה האחרונה (ה‪ )𝑛 + 1-‬מתאימה לקונפיגורציה ה‪.𝑛 -‬‬
‫הנחות‪ :‬לשם הנוחות‪ ,‬נניח שכל קונפיגורציה מתחילה ומסתיימת ב‪.#-‬‬
‫‪ .1‬בכל העמודה הראשונה ובכל העמודה האחרונה במטריצה‬
‫מופיע הסמל ‪.#‬‬
‫𝑘‬ ‫𝑘‬
‫(‬ ‫( )‬ ‫)‬
‫‪ .2‬נרחיב את המטריצה לסדר ‪. 𝑛 + 1 × 𝑛 + 4‬‬
‫‪ .3‬לשם הנוחות של האינדקסים בהמשך נניח שהיא מסדר‬
‫𝑘‬ ‫𝑘‬
‫‪ 𝑛 + 1 × 𝑛 + 1‬גם נניח שאם מגיעים לקונפיגורציה עוצרת (קבלה או דחייה)‪ ,‬מעתיקים אותה‬ ‫(‬ ‫( )‬ ‫)‬
‫לשורות שתחתיה במטריצה‪.‬‬
‫𝑘‬ ‫𝑘‬
‫(‬ ‫( )‬ ‫)‬
‫כך נבטיח שתמיד המטריצה היא מסדר ‪. 𝑛 + 1 × 𝑛 + 1‬‬
‫ֻ‬
‫מקבלת‪ :‬המטריצה תקרא מקבלת‪ ,‬אם אחת השורות שלה היא קונפיגורציה מקבלת‪.‬‬ ‫מטריצה‬
‫כלומר‪ ,‬המצב בקונפיגורציה הוא 𝑡𝑝𝑒𝑐𝑐𝑎𝑞‪ .‬כל מטריצה מקבלת של 𝑁 על 𝑤 מתאימה לחישוב מקבל של 𝑁 על 𝑤‬
‫‪ .‬לכן‪ ,‬השאלה האם 𝑁 מקבלת את 𝑤 שקולה לשאלה "האם יש מטריצה מקבלת של 𝑁 על 𝑤"‪.‬‬
‫אנו מעוניינים ברדוקציה פולינומית עבור 𝑇𝐴𝑆𝑃≤𝐿 ‪ .∀𝐿 ∈ 𝑁𝑃,‬ולכן‪ ,‬לכל מילת קלט נרצה לבנות פסוק‪.‬‬
‫תחילה בהינתן מילה 𝑥 נבנה פסוק שיסתפק אמ"מ יש מסלול מקבל בעץ החישוב )𝑥(𝑁 (כלומר מטריצה‬ ‫‪.1‬‬
‫מקבלת) ונסביר נכונות (כלומר את תקפות הרדוקציה)‪.‬‬
‫‪ .2‬לאחר מכן נוכיח סיבוכיות אורך הפסוק‪.‬‬
‫מה תעשה הרדוקציה?‪ :‬הרדוקציה תבנה מ‪ 𝑤-‬פסוק שערכו יהיה 𝑒𝑢𝑟𝑡 אם"ם יש מטריצה מקבלת של 𝑁 על 𝑤‬
‫איך יראה הפסוק הזה?‪ :‬הסמלים שיכולים להופיע במטריצה הם סמלים מן הקבוצה }‪ 𝐶 = 𝑄 ∪ Γ ∪ {#‬או‬
‫מיקום של הראש‪ .‬שימו לב שגודל הקבוצה 𝐶 לא תלוי ב‪( 𝑤-‬אלא רק ב‪ ,)𝑁-‬ולכן נחשב קבוע בחישוב זמן הריצה‪.‬‬
‫𝑘‬
‫הפסוק שבונה הרדוקציה‪ :‬לכל ‪ 1 ≤ 𝑖, 𝑗 ≤ 𝑛 + 1‬ולכל סימן 𝐶 ∈ 𝑠 נגדיר משתנה 𝑠‪.𝑥𝑖,𝑗,‬‬
‫הכוונה היא ש‪ 𝑥𝑖,𝑗,𝑠 = 𝑡𝑟𝑢𝑒 :‬אם"ם 𝑠 == ]𝑗[]𝑖[𝑢𝑎𝑒𝑙𝑏𝑎𝑡‪.‬‬
‫𝑘‬ ‫𝑘‬ ‫𝑘‪2‬‬
‫מספר המשתנים הוא ) 𝑛(𝑂 = )‪.𝑂(|𝑖| · |𝑗| · |𝑐|) = 𝑂(𝑛 · 𝑛 · 1‬‬
‫הרדוקציה תבנה מ‪ 𝑤-‬את הפסוק ‪ ϕ‬שהוא קוניונקציה (‪ )AND‬של ארבעה פסוקים‪:‬‬

‫𝑡𝑝𝑒𝑐𝑐𝑎‪ϕ = ϕ𝑐𝑒𝑙𝑙 ⋀ ϕ𝑠𝑡𝑎𝑟𝑡 ⋀ ϕ𝑚𝑜𝑣𝑒 ⋀ ϕ‬‬
‫נפרט על כל אחד מן הרכיבים של הפסוק‪:‬‬
‫וידוא שבכל תא במטריצה יכול להיות בדיוק תו אחד‪.‬‬ ‫𝑙𝑙𝑒𝑐‪ϕ‬‬
‫וידוא שהשורה הראשונה מכילה את הקונפיגורציה ההתחלתית המתאימה שכן אם יש לנו‬

‫𝑡𝑟𝑎𝑡𝑠‪ϕ‬‬
‫מטריצה מקבלת אבל היא לא התחילה בקונפיגורציה ההתחלתית היא לא יכולה לאשר את‬
‫קבלת המילה‪.‬‬
‫תוודא שהמעברים בין הקונפיגורציות חוקיים לפי פונקציית המעברים ‪.δ‬‬ ‫𝑒𝑣𝑜𝑚‪ϕ‬‬
‫𝑘‬
‫שהקונפיגורציה הסופית תכיל מצב מקבל‪ ,‬אמרנו הרי שאם יש פחות מ‪ 𝑛 -‬קונפיגורציות פשוט‬
‫נשכפל את הקונפיגורציה האחרונה מספר פעמים‪ ,‬ולכן יספיק לוודא מצב מקבל רק בשורה‬ ‫𝑡𝑝𝑒𝑐𝑐𝑎‪ϕ‬‬
‫האחרונה‪.‬‬
‫המשמעות של 𝑙𝑙𝑒𝑐‪ ϕ‬היא שבכל תא במטריצה יש סמל אחד ויחיד מתוך 𝐶‪.‬‬ ‫הפסוק 𝑙𝑙𝑒𝑐‪- ϕ‬‬
‫לכל 𝑗 ‪ 𝑖,‬יש 𝑠 אחד ויחיד כך ש‪ 𝑥𝑖,𝑗,𝑠 :‬הוא 𝑒𝑢𝑟𝑡‪ .‬בניסוח של פסוק נכתוב‪:‬‬
‫⋀ = 𝑙𝑙𝑒𝑐‪ϕ‬‬ ‫𝑘‬
‫‪1≤𝑖,𝑗≤𝑛 +1‬‬
‫)𝑠‪[ (⋁𝑠∈𝐶 𝑥𝑖,𝑗,‬‬ ‫⋀‬ ‫] ) )𝑡‪(⋀𝑠,𝑡,∈𝐶, 𝑠≠𝑡 (¬𝑥𝑖,𝑗,𝑠 ⋁ ¬𝑥𝑖,𝑗,‬‬
‫הביטוי השמאלי‪ :‬לוודא שאחד מהם הוא 𝑇‪.‬‬
‫הביטוי הימני‪ :‬לוודא שכל האחרים הם 𝐹‪.‬‬
‫סיבוכיות הפסוק‪:‬‬
‫(𝑂 ‪.𝑂(|Γ ∪ 𝑄|) +‬‬ ‫)) (‬
‫|𝑄∪‪|Γ‬‬
‫‪2‬‬
‫‪2‬‬
‫● עבור תא יחיד‪= 𝑂(|Γ ∪ 𝑄| ) :‬‬
‫𝑘‪2‬‬ ‫‪2‬‬
‫𝑛(𝑂‪.‬‬ ‫● עבור כל התאים במטריצה‪· |Γ ∪ 𝑄| ) :‬‬
‫‪- ϕ‬המשמעות של 𝑡𝑟𝑎𝑡𝑠‪ ϕ‬היא שהשורה הראשונה של המטריצה היא הקונפיגורציה ההתחלתית‬ ‫הפסוק‬
‫𝑡𝑟𝑎𝑡𝑠‬
‫של 𝑁 על 𝑤‪ .‬בכל תא בשורה הראשונה במטריצה מופיע הסמל הנכון של הקונפיגורציה ההתחלתית‪.‬‬
‫בניסוח של פסוק‪:‬‬
‫𝑥 ⋀ 𝑤‪ϕ𝑠𝑡𝑎𝑟𝑡 = 𝑥1,1,# ⋀ 𝑥1,2,𝑞 ⋀ 𝑥1,3,𝑤 ⋀ ... ⋀ 𝑥1,𝑛+2,‬‬ ‫𝑥 ⋀ ‪⋀ ...‬‬ ‫𝑘‬ ‫𝑥 ⋀‬ ‫𝑘‬

‫‪0‬‬ ‫‪1‬‬ ‫𝑛‬
‫‾𝑏‪1,𝑛+3,‬‬ ‫‾𝑏‪1,𝑛 ,‬‬ ‫‪1,𝑛 +1,#‬‬
‫סיבוכיות הפסוק‪ :‬להשלים‬
‫המשמעות של 𝑡𝑝𝑒𝑐𝑐𝑎‪ ϕ‬היא שיש במטריצה קונפיגורציה מקבלת‪.‬‬ ‫הפסוק 𝑡𝑝𝑒𝑐𝑐𝑎‪- ϕ‬‬
‫הדרישה היא שהסמל 𝑡𝑝𝑒𝑐𝑐𝑎𝑞 מופיע בשורה האחרונה‪:‬‬
‫⋁ = 𝑡𝑝𝑒𝑐𝑐𝑎‪ϕ‬‬ ‫𝑘‬ ‫𝑥‬ ‫𝑘‬

‫‪1≤𝑗≤𝑛 +1‬‬ ‫𝑡𝑝𝑒𝑐𝑐𝑎𝑞 ‪𝑛 +1, 𝑗 ,‬‬
‫𝑘‬
‫סיבוכיות הפסוק‪.𝑂(𝑛 ) :‬‬
‫המשמעות של 𝑒𝑣𝑜𝑚‪ ϕ‬היא לוודא שכל שורה (קונפיגורציה) מאפשרת לעבור לשורה הבאה‬ ‫הפסוק 𝑒𝑣𝑜𝑚‪- ϕ‬‬
‫(קונפיגורציה עוקבת) דרך פונקציית המעברים של 𝑁‪.‬‬
‫הנקודה החשובה היא‪ :‬ההבדל בין שתי קונפיגורציות עוקבות מתבטאת בלכל היותר בשלושה תאים רצופים‬
‫(מיקום הראש‪ ,‬והתאים שלימינו ולשמאלו) וכל השאר זהה‪ .‬לכן די לוודא שכל "חלון" מסדר ‪ 2 × 3‬הוא חוקי לפי 𝑁‪.‬‬
‫חלונות חוקיים ולא חוקיים‪ :‬לדוגמה נניח שב‪ 𝑁-‬מתקיים‪:‬‬
‫})𝑅 ‪δ(𝑞1, 𝑎) = {(𝑞1, 𝑏,‬‬ ‫‪,‬‬ ‫})𝑅 ‪δ(𝑞1, 𝑏) = {(𝑞2, 𝑐, 𝐿), (𝑞2, 𝑎,‬‬
‫חלונות חוקיים‬ ‫חלונות לא חוקיים‬
‫לכל חלון מסדר ‪ 2 × 3‬יהיה ב‪ ϕ𝑚𝑜𝑣𝑒-‬תת‪-‬פסוק שיאמר שששת הסמלים בחלון מהווים חלון חוקי‪:‬‬
‫כאשר הקביעה שהחלון הוא חוקי היא הפסוק הבא בזמן קבוע )‪ 𝑂(1‬לכל בדיקת חלון ‪:2 × 3‬‬
‫(פסוקים כאלה מופיעים לכל ‪ i‬ולכל ‪ j‬ולכל חלון חוקי) שימו לב שמספר החלונות החוקיים איננו תלוי כלל ב‪𝑤-‬‬
‫(אלא רק במכונה 𝑁)‪ ,‬ולכן הוא ייחשב לקבוע בחישוב זמן הריצה של הרדוקציה‪.‬‬
‫𝑘‬ ‫𝑘‬ ‫𝑘‪2‬‬

‫סיבוכיות הפסוק‪.𝑂(6 · (𝑛 + 1)(𝑛 + 1)) = 𝑂(𝑛 ) :‬‬
‫טענה‪ :‬אם השורה הראשונה במטריצה היא הקונפיגורציה ההתחלתית של 𝑁 על 𝑤‪ ,‬וכל חלון מסדר ‪2 × 3‬‬
‫במטריצה הוא חלון חוקי לפי 𝑁‪ ,‬אז כל שורה בטבלה היא קונפיגורציה עוקבת לקונפיגורציה של השורה שלפניה‪,‬‬
‫בְּ חישוב של 𝑁 על 𝑤‪ .‬להשלים?‬
‫הדרכה‪ :‬לכל סמל בקונפיגורציה שאיננו ‪ ,#‬התבוננו בחלון שבו הסמל הזה הוא הסמל האמצעי בשורה העליונה‬
‫בחלון‪.‬‬
‫הרדוקציה תקפה‪ :‬להשלים?‬
‫תרגיל‪ :‬הוכיחו‪ ϕ = ϕ𝑐𝑒𝑙𝑙 ⋀ ϕ𝑠𝑡𝑎𝑟𝑡 ⋀ ϕ𝑚𝑜𝑣𝑒 ⋀ ϕ𝑎𝑐𝑐𝑒𝑝𝑡 :‬ספיק אם"ם 𝐿 ∈ 𝑤‪.‬‬
‫תיארנו את הרדוקציה‪ ,‬והוכחנו שהיא תקפה (הוכחנו בבית)‪ .‬כעת נעבור לחישוב זמן הריצה של הרדוקציה‪,‬‬
‫ונוכיח שהוא פולינומי בגודל הקלט‪ .‬זה יסיים את הוכחת משפט 𝑛𝑖𝑣𝑒𝐿 ‪.𝐶𝑜𝑜𝑘 −‬‬
‫הגודל של הפסוק ‪ :ϕ‬נחשב את הגודל של ‪:ϕ‬‬

‫𝑘‪2‬‬
‫● מספר המשתנים הוא ) 𝑛(𝑂‪.‬‬
‫𝑘‪2‬‬
‫● הגודל של 𝑙𝑙𝑒𝑐‪ ϕ‬הוא ) 𝑛(𝑂‪.‬‬
‫𝑘‬
‫● הגודל של 𝑡𝑟𝑎𝑡𝑠‪ ϕ‬הוא ) 𝑛(𝑂‪.‬‬
‫𝑘‪2‬‬
‫● הגודל של 𝑒𝑣𝑜𝑚‪ ϕ‬הוא ) 𝑛(𝑂‪.‬‬
‫𝑘‬
‫● הגודל של 𝑡𝑝𝑒𝑐𝑐𝑎‪ ϕ‬הוא ) 𝑛(𝑂‪.‬‬
‫𝑘‪2‬‬
‫מסקנה‪ :‬הגודל של ‪ ϕ‬הוא ) 𝑛(𝑂‪.‬‬
‫זמן הריצה של הרדוקציה‪:‬‬

‫אפשר לחשב את ‪ ϕ‬בזמן פולינומיאלי ב‪:|𝑤|-‬‬
‫‪ ϕ‬לא תלויים ב‪ 𝑤-‬עצמה‪ ,‬אלא רק ב‪( |𝑤|-‬כדי לקבוע את התחום של האינדקסים ‪ i‬ו‪.)j-‬‬ ‫● 𝑒𝑣𝑜𝑚‪, ϕ𝑐𝑒𝑙𝑙, ϕ‬‬
‫𝑡𝑝𝑒𝑐𝑐𝑎‬
‫● הרכיבים של הפסוקים הללו חוזרים על עצמם‪ ,‬ולכן אפשר לחשב אותם בזמן פולינומיאלי‪.‬‬
‫● את 𝑡𝑟𝑎𝑡𝑠‪ ϕ‬אפשר לחשב מתוך 𝑤 בזמן פולינומיאלי‪.‬‬
‫סיום ההוכחה המגעילה הזאת‪ :‬בזה תמה הוכחת משפט 𝑛𝑖𝑣𝑒𝐿 ‪ 𝐶𝑜𝑜𝑘 −‬ומכאן 𝑇𝐴𝑆 היא 𝑃𝑁‪-‬שלמה!‬
‫צורה קוניונקטיבית נורמלית‬

‫תזכורת‪ :‬פסוק בתחשיב הפסוקים הוא בצורה קוניונקטיבית נורמלית (𝐹𝑁𝐶)‪ ,‬אם‪:‬‬
‫‪ .1‬הפסוק בנוי מקבוצה של פסוקיות שביניהן יש הקשר ∧‬
‫‪ .2‬כל פסוקית היא קבוצה של ליטרלים שביניהם יש הקשר ∨‬
‫‪ .3‬כל ליטרל הוא משתנה או שלילה של משתנה‬
‫דוגמה‪.(𝑥 ∨ 𝑦 ∨ ¬𝑧) ∧ (𝑥 ∨ 𝑧) ∧ (¬𝑦 ∨ ¬𝑧) :‬‬
‫תזכורת‪ :‬לכל פסוק יש פסוק שקול ב‪.𝐶𝑁𝐹-‬‬
‫השפה ‪CNF-SAT‬‬
‫תרגיל‪ :‬הראו שכל חלקי הפסוק ‪ ϕ‬בהוכחת משפט 𝑛𝑖𝑣𝑒𝐿 ‪ ,𝐶𝑜𝑜𝑘 −‬פרט ל‪ ,ϕ𝑚𝑜𝑣𝑒-‬הם בצורת 𝐹𝑁𝐶‪.‬‬
‫אפשר להעביר גם את 𝑒𝑣𝑜𝑚‪ ϕ‬לצורת 𝐹𝑁𝐶‪ .‬זה יגדיל את הפסוק‪ ,‬אך מכיוון שהגודל של כל תת‪-‬פסוק של חלון‬
‫ב‪ ϕ𝑚𝑜𝑣𝑒-‬תלוי רק במכונה 𝑁 (ולא ב‪ ,)𝑤-‬אפשר להתייחס להגדלה הזו כאל כפל בקבוע‪.‬‬
‫מסקנה‪ :‬גם השפה 𝑇𝐴𝑆 ‪ 𝐶𝑁𝐹 −‬היא 𝐶𝑃𝑁‪:‬‬
‫}𝑎𝑙𝑢𝑚𝑟𝑜𝑓 𝑛𝑎𝑒𝑙𝑜𝑜𝐵 𝐹𝑁𝐶 𝑒𝑙𝑏𝑎𝑖𝑓𝑠𝑖𝑡𝑎𝑠 𝑎 𝑠𝑖 ‪𝐶𝑁𝐹 − 𝑆𝐴𝑇 = {< ϕ > | ϕ‬‬
‫השפה ‪DNF-SAT‬‬
‫תזכורת‪ :‬פסוק בתחשיב הפסוקים הוא בצורה דיסיונקטיבית נורמלית (𝐹𝑁𝐷)‪ ,‬אם‪:‬‬
‫‪ .1‬הפסוק בנוי מקבוצה של פסוקיות שביניהן יש הקשר ∧‬
‫‪ .2‬כל פסוקית היא קבוצה של ליטרלים שביניהם יש הקשר ∨‬
‫‪ .3‬כל ליטרל הוא משתנה או שלילה של משתנה‬
‫}𝑎𝑙𝑢𝑚𝑟𝑜𝑓 𝑛𝑎𝑒𝑙𝑜𝑜𝐵 𝐹𝑁𝐷 𝑒𝑙𝑏𝑎𝑖𝑓𝑠𝑖𝑡𝑎𝑠 𝑎 𝑠𝑖 ‪𝐷𝑁𝐹 − 𝑆𝐴𝑇 = {< ϕ > | ϕ‬‬
‫תרגיל‪ :‬הוכיחו‪ .𝐷𝑁𝐹 − 𝑆𝐴𝑇 ∈ 𝑃 :‬שימו לב שבין הפסוקיות יש הקשר ∨‪.‬‬
‫שאלה‪ :‬האם גם 𝑃 ∈ 𝑇𝐴𝑆 ‪ ?𝐶𝑁𝐹 −‬למה האלגוריתם הבא ל‪ 𝐶𝑁𝐹 − 𝑆𝐴𝑇-‬לא מוכיח שגם 𝑇𝐴𝑆 ‪𝐶𝑁𝐹 −‬‬
‫שייכת ל‪?𝑃-‬‬
‫"על קלט > ‪ < ϕ‬כאשר ‪ ϕ‬פסוק בצורת 𝐹𝑁𝐶‪:‬‬ ‫‪-‬‬
‫‪ .1‬העבר את ‪ ϕ‬לפסוק שקול '‪ ϕ‬בצורת 𝐹𝑁𝐷‪.‬‬
‫‪ .2‬בדוק האם '‪ ϕ‬ספיק‪ .‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪".‬‬
‫תשובה‪ :‬המעבר מ‪ 𝐶𝑁𝐹-‬ל‪ 𝐷𝑁𝐹-‬עלול ליצור פסוק '‪ ϕ‬שגודלו אקספוננציאלי בגודל הפסוק ‪.ϕ‬‬
‫שקילות ‪ CNF‬ו‪DNF-‬‬
‫לדוגמה‪.ϕ = (𝑥1 ∨ 𝑥2) ∧ (¬𝑥1 ∨ ¬𝑥2) ∧ (𝑥3 ∨ 𝑥4) ∧ ... ∧ (¬𝑥𝑛−1 ∨ ¬𝑥𝑛) :‬‬
‫כיצד ממירים את זה לצורת 𝐹𝑁𝐷?‬
‫לעיון בדוגמה "קצרה" בקישור‪.‬‬
‫סיכום הפרק‬
‫רדוקציה פולינומית‪ :‬בהינתן שתי שפות ‪ ,𝐿1, 𝐿2‬נאמר ש‪ 𝐿1 :‬ניתנת לרדוקציה פולינומית ל‪ 𝐿2-‬ונסמן ‪𝐿1≤𝑃𝐿2‬‬
‫אם קיימת פונקציה 𝑓 כך ש‪:‬‬
‫‪ 𝑓 .1‬ניתנת לחישוב בזמן פולינומי‪.‬‬
‫‪ 𝑓 .2‬תקפה‪ ,‬כלומר ‪.𝑥 ∈ 𝐿1 ⇔ 𝑓(𝑥) ∈ 𝐿2‬‬
‫שפות ‪-NP‬שלמות‪ :‬שפה 𝐿 היא 𝑃𝑁‪-‬שלמה (או נסמן 𝐶𝑃𝑁) אם‪:‬‬

‫‪.𝐿 ∈ 𝑁𝑃 .1‬‬
‫‪ 𝐿 ∈ 𝑁𝑃𝐻 .2‬כלומר‪ ,‬לכל 𝑃𝑁 ∈ '𝐿‪ ,‬קיימת רדוקציה פולינומית 𝐿𝑃≤'𝐿‪.‬‬
‫השפה ‪ :SAT‬היא שפת הפסוקים הספיקים בתחשיב הפסוקים‪:‬‬

‫הוכחנו בהרצאה בעזרת משפט קוק‪-‬לוין ש‪.𝑆𝐴𝑇 ∈ 𝑁𝑃𝐶 :‬‬
‫תרגיל ‪ - 1‬תרגול ‪6‬‬

‫נתונה השפה הבאה‪.𝑆𝐴𝑇2 = {< ϕ > |∃ 𝑡𝑤𝑜 𝑠𝑎𝑡𝑖𝑠𝑓𝑦𝑖𝑛𝑔 𝑎𝑠𝑠𝑖𝑔𝑛𝑚𝑒𝑛𝑡𝑠 𝑡𝑜 ϕ} :‬‬
‫במילים‪ :‬שפת כל הפסוקיות ‪ ϕ‬שיש להן ‪ 2‬השמות מספקות (שונות)‪.‬‬
‫הוכיחו‪.𝑆𝐴𝑇2 ∈ 𝑁𝑃𝐶 :‬‬
‫פתרון‪ :‬כדי להוכיח ש‪ ,𝑆𝐴𝑇2 ∈ 𝑁𝑃𝐶 :‬צריך להוכיח כי 𝑃𝑁 ∈ ‪ 𝑆𝐴𝑇2‬וגם 𝐻𝑃𝑁 ∈ ‪.𝑆𝐴𝑇2‬‬
‫פתרון ‪ -‬חלק א'‪ :‬נוכיח 𝑃𝑁 ∈ ‪ .𝑆𝐴𝑇2‬צריך לבנות מכונה א"ד ‪ 𝑁2‬בזמן פולינומי שמכריעה את השפה ‪𝑆𝐴𝑇2‬‬
‫ולהוכיח נכונות וסיבוכיות‪ .‬אנחנו ננחש שתי השמות ונבדוק שהן מספקות‪.‬‬
‫המכונה ‪ 𝑁2‬על קלט > ‪ < ϕ‬תפעל‪:‬‬
‫‪ .1‬נחש השמה ‪ π1‬ונחש השמה נוספת ‪ π2‬כאשר ‪.π1 ≠ π2‬‬
‫‪ .2‬בדוק ש‪ π1-‬השמה מספקת‪ ,‬כלומר בדוק ש‪.ϕ(π1) = 𝑡𝑟𝑢𝑒 :‬‬
‫‪ .3‬בדוק ש‪ π2-‬השמה מספקת‪ ,‬כלומר בדוק ש‪.ϕ(π2) = 𝑡𝑟𝑢𝑒 :‬‬
‫‪ .4‬אם ‪ π1‬וגם ‪ π2‬השמות מספקות עבור ‪ - ϕ‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫סיבוכיות זמן הריצה‪ :‬נסמן ב‪ 𝑛-‬את מספר המשתנים ב‪.ϕ-‬‬
‫| |‬ ‫| |‬
‫‪ .1‬שלב ‪ :1‬כגודל הניחוש )𝑛(𝑂 = ) ‪ 𝑂( π1‬וגם )𝑛(𝑂 = ) ‪ ,𝑂( π2‬סה"כ )𝑛(𝑂 = )𝑛‪.𝑂(2‬‬
‫‪ .2‬שלב ‪ :2-3‬בבדיקת ההשמה נבצע הצבה בפסוק‪ ,‬זה יקח לנו כגודל ‪ ,ϕ‬כלומר )|‪.𝑂(|ϕ‬‬
‫‪ .3‬שלב ‪ :4‬ביצוע בדיקה בזמן קבוע )‪.𝑂(1‬‬
‫סך הכל )𝑛 ‪ - 𝑂(|ϕ| +‬פולינומי‪.‬‬
‫הוכחת נכונות בניית המכונה‪ :‬נוכיח כי )‪.𝑆𝐴𝑇2 = 𝐿(𝑁2‬‬

‫● ‪ ← < ϕ >∈ 𝑆𝐴𝑇2‬קיימות שני השמות מספקות שונות ‪ π1, π2‬עבור ‪ ← ϕ‬קיים ניחוש של ‪ π1‬ושל ‪π2‬‬
‫המובילים למצב מקבל ← )‪.< ϕ >∈ 𝐿(𝑁2‬‬
‫● ‪ ← < ϕ >∉ 𝑆𝐴𝑇2‬לכל השמות ‪ π1, π2‬הם לא מספקות את ‪ ← ϕ‬לכל ניחוש ‪ 𝑁2‬דוחה ←‬
‫)‪.< ϕ >∉ 𝐿(𝑁2‬‬
‫פתרון ‪ -‬חלק ב'‪ :‬נוכיח כי 𝐻𝑃𝑁 ∈ ‪ .𝑆𝐴𝑇2‬כלומר שלכל 𝑃𝑁 ∈ '𝐿 מתקיים ‪.𝐿'≤𝑃𝑆𝐴𝑇2‬‬
‫מבוא‪ :‬בהרצאה למדנו כי 𝐶𝑃𝑁 ∈ 𝑇𝐴𝑆‪ ,‬כלומר ש‪ 𝑆𝐴𝑇 :‬שפה 𝑃𝑁‪-‬שלמה‪ .‬בנוסף‪ ,‬למדנו שבשפות שלמות ניתן‬
‫בעזרת רדוקציה להוכיח על שפות שלמות אחרות‪ .‬כלומר‪ ,‬אם כל שפה 𝑃𝑁 ∈ '𝐿 ניתנת לרדוקציה עם 𝑇𝐴𝑆‪,‬‬
‫אז כאשר נוכיח ש‪ 𝑆𝐴𝑇≤𝑃𝑆𝐴𝑇2 :‬גם 𝐻𝑃𝑁 ∈ ‪.𝑆𝐴𝑇2‬‬
‫● תיאור הרדוקציה‪ :‬הוכחנו כי 𝐶𝑃𝑁 ∈ 𝑇𝐴𝑆‪ ,‬לכן נוכיח ברדוקציה פולינומית ‪.𝑆𝐴𝑇≤𝑃𝑆𝐴𝑇2‬‬
‫○ פונקצית הרדוקציה‪ 𝑓(ϕ) = ϕ' :‬כאשר )‾𝑦 ∨ 𝑦( ∧ ‪.ϕ' = ϕ‬‬

‫○ אין צורך לתאר את האלגוריתם מכיוון שהפונקציה מתארת היטב את הפעולה הנדרשת‪.‬‬
‫● הוכחת נכונות פונקצית הרדוקציה הפולינומית‪:‬‬
‫○ הפונקציה 𝑓 ניתנת לחישוב בזמן פולינומי‪ ,‬כי צריך בסה"כ להוסיף מחרוזת קבועה‪.‬‬
‫○ תקפות הפונקציה‪ :‬צריך להוכיח ‪.< ϕ >∈ 𝑆𝐴𝑇 ⇔ < ϕ' >∈ 𝑆𝐴𝑇2‬‬
‫■ 𝑇𝐴𝑆 ∈> ‪ ← < ϕ‬קיימת השמה מספקת ‪ π‬לפסוק ‪ ← ϕ‬ההשמות ‪π1 = π · 0‬‬
‫וגם ‪ π2 = π · 1‬מספקות את '‪ ϕ‬כיוון שקיימת בו פסוקית טאוטולוגית (תמיד נכונה)‬
‫← יש ל‪ ϕ'-‬לפחות שתי השמות מספקות ← ‪.< ϕ' >∈ 𝑆𝐴𝑇2‬‬
‫■ ‪ ← < ϕ' >∈ 𝑆𝐴𝑇2‬קיימות שני השמות מספקות שונות ‪ π1, π2‬לפסוק '‪ ← ϕ‬נבחר‬
‫בה"כ את ההשמה המספקת ‪ ← π1‬ההשמה ‪ π1‬בפרט מספקת את הפסוק ‪← ϕ‬‬
‫𝑇𝐴𝑆 ∈> ‪.< ϕ‬‬
‫סיכום פתרון‪ :‬הוכחנו 𝑃𝑁 ∈ ‪ 𝑆𝐴𝑇2‬וגם הראנו ש‪ 𝑆𝐴𝑇2 ∈ 𝑁𝑃𝐻 :‬בעזרת רדוקציה פולינומית ‪𝑆𝐴𝑇≤𝑃𝑆𝐴𝑇2‬‬
‫מ‪.‬ש‪.‬ל‪.‬‬ ‫‪-‬‬ ‫ולכן 𝐶𝑃𝑁 ∈ ‪ .𝑆𝐴𝑇2‬כלומר‪ 𝑆𝐴𝑇2 ,‬היא שפה 𝑃𝑁‪-‬שלמה‬
‫∎‬
‫תרגיל ‪ - 2‬שרשרת רדוקציות (תרגיל גדול) ‪ -‬תרגול ‪6‬‬

‫תזכורת‪:‬‬
‫● פסוק 𝐹𝑁𝐶 הוא ספיק אם קיימת השמה שנותנת לו ערך 𝑇‪.‬‬
‫● שפת 𝑇𝐴𝑆 ‪ 𝐶𝑁𝐹 −‬היא שפת כל פסוקי ה‪ 𝐶𝑁𝐹-‬הספיקים‪.‬‬
‫● אם יש לנו פסוק 𝐹𝑁𝐶 שבו כל פסוקית מכילה בדיוק 𝑘 ליטרלים‪ ,‬אומרים שזהו פסוק 𝐹𝑁𝐶 ‪.𝑘 −‬‬
‫● השפה 𝑇𝐴𝑆 ‪ 𝑘 − 𝐶𝑁𝐹 −‬היא אוסף פסוקי ה‪ 𝑘 − 𝐶𝑁𝐹-‬הספיקים‪.‬‬
‫שרשרת הרדוקציות‪ :‬בתרגיל זה אנחנו נוכיח שייכות של שפות למחלקה 𝐶𝑃𝑁 בעזרת שרשרת רדוקציות‪.‬‬
‫היות ו‪ 𝑆𝐴𝑇-‬היא שפה 𝑃𝑁‪-‬שלמה (לפי משפט קוק לוין) אז גם שאר השפות הבאות יהיו 𝑃𝑁‪-‬שלמות‪.‬‬
‫מדובר בתרגיל גדול‪ ,‬השפות שנוכיח כאן יהיו כלים לפתירת בעיות במבחנים ומטלות‪.‬‬
‫כל רדוקציה (𝑃≤) הוא תרגיל בפני עצמו (יש ‪ 6‬כאלה)‪ .‬עבור כל שפה בשרשרת הנתונה צריך להוכיח שהיא‬
‫שייכת למחלקה 𝑃𝑁 ונעשה זאת ע"י בניית מ"ט א"ד פולינומית ‪ +‬הוכחת בנייה וסיבוכיות זמן ריצה‪.‬‬
‫לאחר שנוכיח שכל השפות 𝑃𝑁 ∈ 𝐿 אז נפתור כל רדוקציה פולינומית נתונה בנפרד (משמאל לימין)‪.‬‬
‫נוכיח בשלבים את שרשרת הרדוקציות הבאה‪:‬‬
‫𝐿𝐻𝐷 𝑃≤ 𝐿𝐻 𝑃≤ 𝐶𝐻 𝑃≤ 𝐶𝐻𝐷 𝑃≤ 𝐶𝑉 𝑃≤ 𝑇𝐴𝑆 ‪𝐶𝑁𝐹 − 𝑆𝐴𝑇 ≤𝑃 3 − 𝐶𝑁𝐹 −‬‬
‫הגדרת שפות‪:‬‬
‫}‪𝐷𝐻𝐿 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ‬‬
‫}‪𝐻𝐿 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ‬‬
‫}𝑒𝑙𝑐𝑦𝑐 𝑛𝑎𝑖𝑛𝑜𝑡𝑙𝑖𝑚𝑎𝐻 𝑎 ‪𝐻𝐶 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ‬‬
‫}𝑒𝑙𝑐𝑦𝑐 𝑛𝑎𝑖𝑛𝑜𝑡𝑙𝑖𝑚𝑎𝐻 𝑎 ‪𝐷𝐻𝐶 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ‬‬
‫}𝑘 𝑒𝑧𝑖𝑠 𝑓𝑜 𝑟𝑒𝑣𝑜𝑐 𝑥𝑒𝑡𝑟𝑒𝑣 𝑎 𝑠𝑛𝑖𝑎𝑡𝑛𝑜𝑐 𝑡𝑎‪𝑉𝐶 = {< 𝐺, 𝑘 > |𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ‬‬
‫} 𝑎𝑙𝑢𝑚𝑟𝑜𝑓 𝑛𝑎𝑒𝑙𝑜𝑜𝐵 𝐹𝑁𝐶 ‪3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 = {< ϕ > | ϕ 𝑖𝑠 𝑎 𝑠𝑎𝑡𝑖𝑠𝑓𝑖𝑎𝑏𝑙𝑒 3 −‬‬
‫ציור להמחשה‪ :‬מגרף 𝐺 לא מכוון‪ ,‬לכל צלע ניצור ‪ 2‬צלעות‬ ‫רדוקציה ‪ .𝐻𝐿≤𝑃𝐷𝐻𝐿 :1‬תחילה צריך להוכיח כי 𝑃𝑁 ∈ 𝐿𝐻𝐷‬
‫בגרף המכוון '𝐺 כך שכל אחת מ‪ 2-‬הצלעות יוצאת לצומת‬ ‫וגם 𝑃𝑁 ∈ 𝐿𝐻‪ .‬עבור 𝑃𝑁 ∈ 𝐿𝐻 הוכחנו כבר בהרצאה‬
‫אחרת‪:‬‬ ‫קודמת‪ ,‬קראנו לשפה 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 = 𝐿𝐻‪ .‬צריך להוכיח‬
‫𝑃𝑁 ∈ 𝐿𝐻𝐷‪.‬‬
‫בניית מכונה ל‪ :DHL-‬צריך להוכיח 𝑃𝑁 ∈ 𝐿𝐻𝐷‪ .‬לכן‪ ,‬נבנה 𝑁‬
‫מ"ט א"ד פולינומית שתכריע את השפה 𝐿𝐻𝐷‪.‬‬
‫המכונה 𝑁 על קלט > 𝐺 < תבצע‪:‬‬
‫‪ .1‬נחש מסלול מצומת 𝑠 לצומת 𝑡‪.‬‬
‫‪ .2‬בדוק שכל צלע 𝑒 במסלול שייכת ל‪.𝑒 ∈ 𝐸(𝐺)-‬‬
‫‪ .a‬אם )𝐺(𝐸 ∉ 𝑒 ‪ -‬דחה‪.‬‬
‫‪ .3‬לכל צומת )𝐺(𝑉 ∈ 𝑖𝑣‪:‬‬
‫אם ביקרנו ב‪ 𝑣𝑖 -‬יותר מפעם אחת ‪ -‬דחה‪.‬‬ ‫‪.a‬‬
‫אם לא ביקרנו ב‪ 𝑣𝑖-‬בכלל ‪ -‬דחה‪.‬‬ ‫‪.b‬‬
‫‪ .4‬קבל‪.‬‬
‫חשוב לשים לב שאם לא קיים ב‪ 𝐺-‬מסלול המילטוני‪ ,‬אז גם אם‬ ‫סיבוכיות זמן הריצה‪ :‬נסמן ב‪ 𝑑-‬את אורך המסלול‪.‬‬
‫נצרף ‪ 2‬צלעות‪ ,‬עדיין גם בגרף '𝐺 לא יהיה מסלול המילטוני וזה‬ ‫● שלב ‪ - 1‬כגודל הניחוש‪.𝑂(𝑑) :‬‬
‫טוב לנו ויהיה שימושי לנכונות של תקפות הפונקציה‪.‬‬ ‫● שלב ‪ - 2‬בדיקת כל צלע על המסלול‬
‫‪2‬‬
‫) |𝐸|(𝑂 = )|𝐸| · 𝑑(𝑂‪.‬‬
‫שלב ‪ - 2a‬בדיקה ספציפית ‪.𝑂(1) -‬‬ ‫●‬
‫הוכחה‪ :‬נראה רדוקציה 𝐿𝐻𝐷𝑃≤𝐿𝐻‪.‬‬ ‫שלב ‪ - 3‬מעבר על כל צומת )|𝑉|(𝑂‪.‬‬ ‫●‬
‫פונקצית הרדוקציה‪ .𝑓(< 𝐺 >) =< 𝐺' > :‬כאשר 𝐺 גרף לא‬ ‫שלב ‪ - 3a,b‬בדיקה ספציפית ‪.𝑂(1) -‬‬ ‫●‬
‫‪2‬‬
‫מכוון ו‪ 𝐺'-‬גרף מכוון‪.‬‬ ‫סה"כ זמן הריצה הוא ) |𝐸| ‪ - 𝑂(|𝑉| +‬פולינומי‪.‬‬
‫הפעלת הרדוקציה‪ :‬הגרף '𝐺 המכוון יהיה כמו 𝐺 (לא מכוון) רק‬ ‫הוכחת נכונות הבניה‪ :‬נוכיח כי )𝑁(𝐿 = 𝐿𝐻𝐷‪.‬‬
‫שעבור כל ‪ 2‬קודקודים )𝐺(𝑉 ∈ 𝑣 ‪ 𝑢,‬בצלע )𝐺(𝐸 ∈ )𝑣 ‪,(𝑢,‬‬ ‫● 𝐿𝐻𝐷 ∈> 𝐺 < ← קיים מסלול המילטוני מכוון‬
‫נעשה ‪ 2‬צלעות )'𝐺(𝐸 ∈ )𝑢 ‪.(𝑢, 𝑣), (𝑣,‬‬ ‫בגרף 𝐺 ← קיים ניחוש למסלול המילטוני מכוון‬
‫הפונקציה ניתנת לחישוב בזמן פולינומי‪ :‬מעבר על כל‬ ‫מצומת 𝑠 לצומת 𝑡 המובילים למצב מקבל ←‬
‫הקודקודים )𝑛(𝑂 ויצירת ‪ 2‬צלעות )𝑛‪ 𝑂(2‬ולכן סך הכל נקבל‬ ‫)𝑁(𝐿 ∈> 𝐺 <‪.‬‬
‫)𝑛(𝑂 ‪ -‬פולינומי‪.‬‬ ‫● 𝐿𝐻𝐷 ∉> 𝐺 < ← לא קיים אף מסלול המילטוני‬
‫תקפות הפונקציה‪.< 𝐺 >∈ 𝐻𝐿 ⇔ < 𝐺' >∈ 𝐷𝐻𝐿 :‬‬ ‫מכוון בגרף 𝐺 ← לכל ניחוש של מסלול 𝑡 → 𝑠‬
‫● 𝐿𝐻 ∈> 𝐺 < ← קיים מסלול המילטוני בגרף לא‬ ‫המכונה 𝑁 דוחה ← )𝑁(𝐿 ∉> 𝐺 <‪.‬‬
‫מכוון 𝐺 ← לכן‪ ,‬כאשר נשאיר את הצלע וניצור ממנו‬ ‫מ‪.‬ש‪.‬ל‪.‬‬
‫שני כיוונים‪ ,‬עדיין יהיה קיים מסלול המילטוני בגרף‬ ‫הוכחת הרדוקציה‪.𝐻𝐿≤𝑃𝐷𝐻𝐿 :‬‬
‫המכוון '𝐺 (זה אותו המסלול שהיה ב‪← )𝐺-‬‬
‫רעיון ההוכחה‪ :‬במסלול המילטוני נרצה לעבור על כל‬
‫𝐿𝐻𝐷 ∈> '𝐺 <‪.‬‬
‫הקודקודים פעם אחת בלבד‪.𝑓(< 𝐺 >) =< 𝐺' > .‬‬
‫● 𝐿𝐻 ∉> 𝐺 < ← לא קיים מסלול המילטוני בגרף‬
‫בגרף 𝐺 הלא מכוון קיים מסלול המילטוני‪ ,‬נרצה בעזרת‬
‫לא מכוון 𝐺 ← לכן‪ ,‬גם אם ניצור עבור כל צלע שני‬
‫רדוקציה להשליך גם על הגרף המכוון '𝐺 שיהיה בעל מסלול‬
‫כיוונים עדיין לא יהיה מסלול המילטוני בגרף מכוון '𝐺‬
‫המילטוני‪ .‬ניקח כל צלע בגרף הלא מכוון 𝐺‪ ,‬ונשים במקומה שתי‬
‫← 𝐿𝐻𝐷 ∉> '𝐺 <‪.‬‬
‫צלעות מכוונות‪ .‬כלומר‪ ,‬לכל )𝐺(𝐸 ∈ )𝑣 ‪ (𝑢,‬ניצור ‪ 2‬צלעות‬
‫מ‪.‬ש‪.‬ל‪.‬‬
‫)'𝐺(𝐸 ∈ )𝑢 ‪. (𝑢, 𝑣), (𝑣,‬‬
‫נרצה שאם ב‪ 𝐺-‬יש מסלול המילטוני אז גם ב‪ 𝐺'-‬יש‪,‬‬
‫ואם ב‪ 𝐺-‬אין מסלול המילטוני אז גם ב‪ 𝐺'-‬אין מסלול המילטוני‪.‬‬
‫𝐿𝐻𝐷 𝑃≤ 𝐿𝐻𝑃≤ 𝐶𝐻 𝑃≤ 𝐶𝐻𝐷 𝑃≤ 𝐶𝑉 𝑃≤ 𝑇𝐴𝑆 ‪𝐶𝑁𝐹 − 𝑆𝐴𝑇 ≤𝑃 3 − 𝐶𝑁𝐹 −‬‬
‫ציור להמחשה‪ :‬בציור מתואר ‪ 2‬התרחישים (שייכות ואי שייכות)‪.‬‬ ‫רדוקציה ‪ .𝐻𝐶≤𝑃𝐻𝐿 :2‬תחילה צריך להוכיח כי 𝑃𝑁 ∈ 𝐿𝐻 וגם‬
‫נשים לב שאי אפשר לבנות עבור מקרה של שייך ובניה אחרת‬ ‫𝑃𝑁 ∈ 𝐶𝐻‪ .‬עבור 𝑃𝑁 ∈ 𝐿𝐻 הוכחנו כבר בהרצאה קודמת‪,‬‬
‫עבור מקרה שלא שייך‪ ,‬הבנייה שלנו צריכה לעבוד לכל מקרה‪.‬‬ ‫קראנו לשפה 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 = 𝐿𝐻‪.‬‬
‫● תרחיש ‪( 1‬שייכות ‪ -‬ציור עליון)‪ :‬אם קיים מעגל המילטון אז‬ ‫בניית מכונה ל‪ :HC-‬נוכיח כי 𝑃𝑁 ∈ 𝐶𝐻‪.‬‬
‫קיים מסלול המילטון‪.‬‬ ‫רעיון ההוכחה‪ :‬אם יהיה לנו אפשרות לנחש את הפרמוטציה‬
‫● תרחיש ‪( 2‬אי שייכות ‪ -‬ציור תחתון)‪ :‬אם לא קיים מעגל‬ ‫שתייצג את הסידור הנכון בגרף עבור מעגל המילטון אז ניתן‬
‫המילטון אז לא קיים מסלול המילטון‪.‬‬ ‫יהיה לפתור בזמן פולינומי‪.‬‬
‫אפשר לראות בציור שבאמת עבור ‪ 2‬התרחישים אנחנו עומדים‬ ‫נציג מכונה 𝐶𝐻𝑀 א"ד פולינומית המכריעה את השפה 𝐶𝐻‬
‫בדרישות ולכן תקיפות הפונקציה שנבנה תהיה נכונה וללא‬
‫הוכחה‪ :‬המכונה 𝐶𝐻𝑀 על הקלט > 𝐺 < תבצע‪:‬‬
‫באגים‪.‬‬
‫‪ .1‬מנחשת פרמוטציה (מסלול) על הצמתים ובודקת‬
‫שאכן מהווה מעגל המילטון‪.‬‬
‫‪ .2‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬אורך המעגל שצריך לנחש הוא ליניארי‬
‫(מסלול בעץ החישוב) כלומר )𝑛(𝑂‪ .‬צריך לבדוק האם הצמתים‬
‫שניחשנו שונים זה מזה‪ ,‬ושבין כל שני צמתים עוקבים בסידור‬
‫קיימת קשת ‪ -‬עולה לנו )𝑛(𝑂‪ .‬לכן‪ ,‬שתי הבדיקות הללו ניתנות‬
‫לביצוע בזמן פולינומי‪.‬‬
‫הוכחת נכונות‪ :‬צריך להוכיח ש‪.𝐻𝐶 = 𝐿(𝑀𝐻𝐶) :‬‬
‫𝐶𝐻 ∈> 𝐺 < ← קיים ב‪ 𝐺-‬מעגל המילטון ← ניתן‬ ‫●‬
‫לתאר את המעגל ההמילטוני כסידור של צמתים ←‬
‫הוכחה‪ :‬נראה רדוקציה 𝐿𝐻𝑃≤𝐶𝐻‪.‬‬
‫𝐶𝐻𝑀 תנחש סידור זה והבדיקה שלה תצליח ← קיים‬
‫פונקצית הרדוקציה‪.𝑓(< 𝐺 >) =< 𝐺' > :‬‬
‫מסלול חישוב מקבל עבור 𝐺 ← )𝐶𝐻𝑀(𝐿 ∈> 𝐺 <‪.‬‬
‫הפעלת הרדוקציה‪ :‬נבנה '𝐺 כך‪ :‬נבחר צומת 𝑣 בצורה‬
‫רנדומלית ונפרק אותה ל‪ 2-‬צמתים 𝑢 ‪ ,𝑤,‬כך ש‪ 𝑢, 𝑣 :‬יהיו‬ ‫𝐶𝐻 ∉> 𝐺 < ← לא קיים ב‪ 𝐺-‬מעגל המילטון ← לא‬ ‫●‬
‫מחוברים לאותם קודקודים ש‪ 𝑣-‬היה מחובר‪ .‬אם לא יהיו‬ ‫קיים אף סידור של צמתים המתאר מעגל המילטוני ←‬
‫מחוברים אז בונים לבין עצמם‪ .‬כעת נוסיף שני צמתים נוספים‬ ‫𝐶𝐻𝑀 לא תצליח בניחוש ← לא קיים אף מסלול חישוב‬
‫לגרף 𝑒 ‪ 𝑠,‬וניצור את הקשתות )𝑢 ‪.(𝑠, 𝑤), (𝑒,‬‬ ‫מקבל עבור 𝐺 ← )𝐶𝐻𝑀(𝐿 ∉> 𝐺 <‪.‬‬
‫הפונקציה ניתנת לחישוב בזמן פולינומי‪ :‬יצירת ‪ 4‬קודקודים ו‪2-‬‬ ‫מ‪.‬ש‪.‬ל‪.‬‬ ‫ומכאן 𝑃𝑁 ∈ 𝐶𝐻 כנדרש‪.‬‬
‫צלעות ‪ -‬פולינומי‪.‬‬
‫תקפות הפונקציה‪.< 𝐺 >∈ 𝐻𝐶 ⇔ < 𝐺' >∈ 𝐻𝐿 :‬‬ ‫הוכחת הרדוקציה‪.𝐻𝐶≤𝑃𝐻𝐿 :‬‬
‫● 𝐶𝐻 ∈> 𝐺 < ← קיים מעגל המילטוני בגרף 𝐺 כלומר‬
‫)𝑣 → 𝑦 ‪ ←(𝑣 → 𝑥....‬בגרף '𝐺 יהיה קיים מסלול המילטוני‬ ‫רעיון ההוכחה‪ :‬במסלול המילטוני נרצה לעבור על כל‬
‫← )𝑒 → 𝑢 ‪.< 𝐺' >∈ 𝐻𝐿 ←(𝑠 → 𝑤....‬‬ ‫הקודקודים פעם אחת בלבד‪ .‬אנו יודעים כי כל מעגל המילטוני‬
‫● 𝐶𝐻 ∉> 𝐺 < ← לא קיים מעגל המילטוני בגרף 𝐺 נחלק‬ ‫הוא מסלול המילטוני‪ ,‬אבל חשוב לשים לב שלא כל מסלול‬
‫ל‪ 2-‬מקרים (היה מסלול ולא היה מסלול) ←‬ ‫המילטוני הוא גם מעגל המילטוני!‪ .‬אם ב‪ 𝐺-‬יש מעגל אז הבנייה‬
‫‪ )1‬היה ב‪ G-‬מסלול המילטוני‪ :‬אזי ב‪ 𝐺'-‬נבחר איזשהו 𝑣‬ ‫של '𝐺 קלה כי כל מעגל המילטון הוא מסלול המילטון‪ .‬אבל‪,‬‬
‫ונפרק ל‪ 𝑢, 𝑤-‬ונוסף ‪ 2‬קודקודים 𝑒 ‪ 𝑠,‬שמחוברים רק ל‪𝑢, 𝑤-‬‬ ‫בחלק של האי‪-‬שייכות‪ ,‬אם לא קיים מעגל המילטון ב‪ 𝐺-‬אז זה‬
‫‪ .‬כדי להגיע ל‪ 𝑠, 𝑒-‬נהיה חייבים להתחיל באחד מהם ולסיים‬ ‫לא מחייב שלא קיים מסלול המילטון ב‪ 𝐺'-‬ואנחנו נרצה לבנות‬
‫בשני ולכן נשבור את הרצף של המסלול‬ ‫את '𝐺 במקרה של אי שייכות כך שלא קיים בו מסלול המילטון‪.‬‬
‫‪ )2‬לא היה ב‪ G-‬מסלול המילטוני‪ :‬אז גם עבור '𝐺 לא יהיה‬ ‫> '𝐺 <= )> 𝐺 <(𝑓‪ .‬הגרף 𝐺 הוא גרף לא מכוון בעל מעגל‬
‫מסלול המילטוני‪.‬‬ ‫המילטוני‪ ,‬אנחנו נרצה לבנות '𝐺 שישמור על התכונות‪.‬‬
‫← 𝐿𝐻 ∉> '𝐺 <‪.‬‬ ‫כלומר‪ ,‬אנחנו נרצה להפוך מעגל למסלול‪ :‬ניקח קודקוד 𝑣‬
‫מ‪.‬ש‪.‬ל‪.‬‬ ‫ו"נפצל" אותו לשני קודקודים 𝑤 ‪ 𝑢,‬שיהיו מחוברים לכל השכנים‬
‫של 𝑣‪ .‬נוסיף גם צלעות שיוצאות מ‪ 𝑤-‬ו‪ 𝑢-‬לקודקודים חדשים‪.‬‬
‫𝐿𝐻𝐷 𝑃≤𝐿𝐻𝑃≤ 𝐶𝐻𝑃≤ 𝐶𝐻𝐷 𝑃≤ 𝐶𝑉 𝑃≤ 𝑇𝐴𝑆 ‪𝐶𝑁𝐹 − 𝑆𝐴𝑇 ≤𝑃 3 − 𝐶𝑁𝐹 −‬‬
‫ציור להמחשה‪:‬‬ ‫רדוקציה ‪ .𝐷𝐻𝐶≤𝑃𝐻𝐶 :3‬תחילה צריך להוכיח כי 𝑃𝑁 ∈ 𝐿𝐻‬

‫וגם 𝑃𝑁 ∈ 𝐶𝐻𝐷‪ .‬עבור 𝑃𝑁 ∈ 𝐶𝐻 הוכחנו ברדוקציה‬
‫הקודמת‪ ,‬נוכיח כי 𝑃𝑁 ∈ 𝐶𝐻𝐷‪.‬‬
‫בניית מכונה ל‪ :DHC-‬נוכיח כי 𝑃𝑁 ∈ 𝐶𝐻𝐷‪.‬‬
‫רעיון ההוכחה‪ :‬אם יהיה לנו אפשרות לנחש את הפרמוטציה‬
‫שתייצג את הסידור הנכון בגרף עבור מעגל המילטון אז ניתן‬
‫יהיה לפתור בזמן פולינומי‪.‬‬
‫נציג מכונה 𝐶𝐻𝐷𝑀 א"ד פולינומית המכריעה את השפה 𝐶𝐻‬
‫הוכחה‪ :‬המכונה 𝐶𝐻𝐷𝑀 על הקלט > 𝐺 < תבצע‪:‬‬
‫‪ .1‬מנחשת פרמוטציה (מסלול) על הצמתים ובודקת‬
‫שאכן מהווה מעגל המילטון‪.‬‬
‫‪ .2‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬אורך המעגל שצריך לנחש הוא ליניארי‬
‫(מסלול בעץ החישוב) כלומר )𝑛(𝑂‪ .‬צריך לבדוק האם הצמתים‬
‫שניחשנו שונים זה מזה‪ ,‬ושבין כל שני צמתים עוקבים בסידור‬
‫הוכחה‪ :‬נראה רדוקציה 𝐶𝐻𝑃≤𝐶𝐻𝐷‪.‬‬ ‫קיימת קשת ‪ -‬עולה לנו )𝑛(𝑂‪ .‬לכן‪ ,‬שתי הבדיקות הללו ניתנות‬
‫פונקצית הרדוקציה‪.𝑓(< 𝐺 >) =< 𝐺' > :‬‬ ‫לביצוע בזמן פולינומי‪.‬‬
‫הפעלת הרדוקציה‪ :‬נבנה '𝐺 כך‪ :‬עבור כל קודקוד בגרף 𝐺‬ ‫הוכחת נכונות‪ :‬צריך להוכיח ש‪.𝐷𝐻𝐶 = 𝐿(𝑀𝐷𝐻𝐶) :‬‬
‫נעשה ‪ 3‬קודקודים 𝑡𝑢𝑜𝑣 ‪ .𝑣𝑖𝑛, 𝑣𝑚𝑖𝑑𝑑𝑙𝑒,‬אם ב‪ 𝐺-‬הייתה קיימת‬ ‫𝐶𝐻𝐷 ∈> 𝐺 < ← קיים בגרף מכוון 𝐺 מעגל המילטון‬ ‫●‬
‫צלע )𝑣 ‪ (𝑢,‬אזי ב‪ 𝐺'-‬תיהיה צלע )𝑛𝑖𝑣 ‪ .(𝑢𝑜𝑢𝑡,‬ואם ב‪ 𝐺-‬הייתה‬ ‫← ניתן לתאר את המעגל ההמילטוני כסידור של‬
‫צמתים ← 𝐶𝐻𝐷𝑀 תנחש סידור זה והבדיקה שלה‬
‫קיימת צלע )𝑢 ‪ (𝑣,‬אזי ב‪ 𝐺'-‬תיהיה צלע )𝑛𝑖𝑢 ‪ .(𝑣𝑜𝑢𝑡,‬בנוסף‬
‫תצליח ← קיים מסלול חישוב מקבל עבור 𝐺 ←‬
‫נוסיף את הצלעות )𝑡𝑢𝑜𝑢 ‪ (𝑢𝑖𝑛, 𝑢𝑚𝑖𝑑𝑑𝑙𝑒), (𝑢𝑚𝑖𝑑𝑑𝑙𝑒,‬כדי לכפות‬
‫)𝐶𝐻𝐷𝑀(𝐿 ∈> 𝐺 <‪.‬‬
‫את המעגל לעבור ב‪ ,𝑢-‬כלומר ב‪.𝑢𝑚𝑖𝑑𝑑𝑙𝑒-‬‬
‫𝐶𝐻𝐷 ∉> 𝐺 < ← לא בגרף מכוון 𝐺 מעגל המילטון‬ ‫●‬
‫סיבוכיות זמן ריצה‪ :‬שילוש כמות הקודקודים וחיבור הצלעות זה‬ ‫← לא קיים אף סידור של צמתים המתאר מעגל‬
‫בזמן )𝑛(𝑂 ‪ -‬פולינומי‪.‬‬ ‫המילטוני ← 𝐶𝐻𝐷𝑀 לא תצליח בניחוש ← לא קיים אף‬
‫תקפות הפונקציה‪.< 𝐺 >∈ 𝐷𝐻𝐶 ⇔ < 𝐺' >∈ 𝐻𝐶 :‬‬
‫מסלול חישוב מקבל עבור 𝐺 ← )𝐶𝐻𝐷𝑀(𝐿 ∉> 𝐺 <‪.‬‬
‫● 𝐶𝐻𝐷 ∈> 𝐺 < ← יש ב‪ 𝐺-‬מעגל המילטוני מכוון במסלול‬
‫מ‪.‬ש‪.‬ל‪.‬‬ ‫ומכאן 𝑃𝑁 ∈ 𝐶𝐻𝐷 כנדרש‪.‬‬
‫(‬
‫‪ ← 𝑣1 →... → 𝑣𝑛 → 𝑣1‬בגרף החדש '𝐺 יש את המעגל‪:‬‬ ‫)‬
‫)𝑛𝑖‪← (𝑣1𝑖𝑛 → 𝑣1𝑚𝑖𝑑 → 𝑣1𝑜𝑢𝑡... → 𝑣𝑛𝑖𝑛.. → 𝑣𝑛𝑜𝑢𝑡 → 𝑣1‬‬
‫הוכחת הרדוקציה‪.𝐷𝐻𝐶≤𝑃𝐻𝐶 :‬‬
‫𝐶𝐻 ∈> '𝐺 <‪.‬‬
‫רעיון ההוכחה‪ :‬אם ניקח את כל הצלעות המכוונות ונהפוך אותן‬
‫● 𝐶𝐻 ∈> '𝐺 < ← יש ב‪ 𝐺'-‬מעגל המילטוני לא מכוון ← לכל‬
‫לצלעות לא מכוונות אז ייתכן וניצור מעגלי המילטון שלא היו‬
‫קודקוד 𝑑𝑖𝑚𝑣 מחובר רק ל‪ 𝑣𝑖𝑛, 𝑣𝑜𝑢𝑡-‬וכי המעגל המילטוני אז‬
‫קיימות וזה בעייה במקרה ונרצה להוכיח אי‪-‬שייכות!‪.‬‬
‫(‬ ‫)‬
‫הוא חייב לעבור 𝑡𝑢𝑜𝑣 → 𝑑𝑖𝑚𝑣 → 𝑛𝑖𝑣 או הפוך (בה"כ)‪← .‬‬ ‫> '𝐺 <= )> 𝐺 <(𝑓‪ .‬המטרה שלנו זה לעבור מגרף 𝐺 מכוון‬
‫(‬ ‫)‬
‫בפרט‪ ,‬לא יכול להיות מצב 𝑤 → 𝑡𝑢𝑜\𝑛𝑖𝑣 → 𝑢 כאשר‬ ‫לגרף '𝐺 לא מכוון ועדיין לשמר את הנכונות של הפונקציה‪,‬‬
‫כלומר שאם לא קיים מעגל המילטון ב‪ 𝐺-‬אז לא קיים גם ב‪𝐺'-‬‬
‫𝑑𝑖𝑚𝑣 ≠ 𝑤 ‪ ← 𝑢,‬לפי התיאור והבניה של הגרף‪ ,‬המעגל‬
‫ואם כן קיים מעגל המילטון ב‪ 𝐺-‬אז קיים מעגל המילטון ב‪.𝐺'-‬‬
‫נראה כך‪:‬‬ ‫הרעיון‪ :‬לכל קודקוד 𝑣 בגרף המכוון 𝐺‪ ,‬נפצל אותו לשלושה‬
‫(‬
‫𝑛𝑖‪← 𝑣1𝑖𝑛 → 𝑣1𝑚𝑖𝑑 → 𝑣1𝑜𝑢𝑡... → 𝑣𝑛𝑖𝑛.. → 𝑣𝑛𝑜𝑢𝑡 → 𝑣1‬‬ ‫)‬ ‫קודקודים חדשים‪.𝑣𝑖𝑛, 𝑣𝑚𝑖𝑑𝑑𝑙𝑒, 𝑣𝑜𝑢𝑡 :‬‬
‫(‬ ‫)‬
‫בגרף המקורי 𝐺 יש מעגל ‪← 𝑣1 →... → 𝑣𝑛 → 𝑣1‬‬ ‫ונוסיף לו צלעות‪.(𝑣𝑖𝑛, 𝑣𝑚𝑖𝑑𝑑𝑙𝑒), (𝑣𝑚𝑖𝑑𝑑𝑙𝑒, 𝑣𝑜𝑢𝑡) ∈ 𝐸(𝐺') :‬‬
‫מ‪.‬ש‪.‬ל‪.‬‬ ‫𝐶𝐻𝐷 ∈> 𝐺 <‪.‬‬ ‫ולכל צלע )𝐺(𝐸 ∈ )𝑦 ‪ (𝑥,‬נוסיף את )'𝐺(𝐸 ∈ )𝑛𝑖𝑦 ‪.(𝑥𝑜𝑢𝑡,‬‬
‫𝐿𝐻𝐷𝑃≤𝐿𝐻𝑃≤𝐶𝐻𝑃≤𝐶𝐻𝐷 𝑃≤ 𝐶𝑉 𝑃≤ 𝑇𝐴𝑆 ‪𝐶𝑁𝐹 − 𝑆𝐴𝑇 ≤𝑃 3 − 𝐶𝑁𝐹 −‬‬
‫ציור להמחשה‪ :‬נסתכל לדוגמה על הפסוק הבא‪:‬‬ ‫רדוקציה ‪ .3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑃𝑉𝐶 :5‬תחילה צריך להוכיח‬
‫)‪ϕ = (𝑥1 ∨ 𝑥1 ∨ 𝑥2) ∧ (𝑥1 ∨ 𝑥2 ∨ 𝑥2) ∧ (𝑥1 ∨ 𝑥2 ∨ 𝑥2‬‬ ‫כי 𝑃𝑁 ∈ 𝐶𝑉 וגם 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪ .3 − 𝐶𝑁𝐹 −‬עבור‬
‫הרדוקציה תייצר > 𝑘 ‪ < 𝐺,‬מ‪ ,ϕ-‬כאשר ‪𝑘 = 𝑚 + 2𝑙 = 8‬‬ ‫𝑃𝑁 ∈ 𝐶𝑉 הוכחנו בהרצאה‪ ,‬נוכיח כי 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪.3 −‬‬
‫בניית מכונה ל‪ :3SAT-‬נוכיח כי 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪.3 −‬‬
‫רעיון ההוכחה‪ :‬נבנה ‪ 𝑁3‬מ"ט א"ד פולינומית שמכריעה את‬
‫השפה 𝑇𝐴𝑆 ‪ .3 − 𝐶𝑁𝐹 −‬אין לנו צורך לבצע בדיקה שאכן‬
‫הפסוק ‪ ϕ‬מכיל ‪ 3‬ליטרלים בכל פסוקית‪ ,‬אנחנו מניחים שזה‬
‫תקין‪ .‬הבדיקה היחידה שיש לנו לעשות הוא עבור ההשמה‬
‫שננחש‪ ,‬נרצה לבדוק שההשמה הזאת אכן מספקת את ‪.ϕ‬‬
‫הוכחה‪ :‬המכונה ‪ 𝑁3‬על הקלט > ‪ < ϕ‬תבצע‪:‬‬
‫הוכחה‪ :‬נראה רדוקציה 𝐶𝑉𝑃≤𝑇𝐴𝑆 ‪.3 − 𝐶𝑁𝐹 −‬‬
‫‪ .1‬נחש השמה ‪.π‬‬
‫פונקצית הרדוקציה‪.𝑓(< ϕ >) =< 𝐺, 𝑘 > :‬‬ ‫‪ .2‬נבדוק שאכן 𝑒𝑢𝑟𝑡 = )‪.ϕ(π‬‬
‫הפעלת הרדוקציה‪ :‬לכל משתנה 𝑥 ב‪ ,ϕ-‬ניצור צלע המחבר שני‬ ‫‪ .3‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫קודקודים‪ .‬אנחנו נסמן את שני הקודקודים האלה ב‪ 𝑥-‬ו‪ .𝑥‾-‬כאשר‬ ‫סיבוכיות זמן ריצה‪ :‬נסמן ב‪ 𝑛-‬את מספר המשתנים ב‪.ϕ-‬‬
‫𝐸𝑈𝑅𝑇 = 𝑥‪ ,‬וגם 𝐸𝑆𝐿𝐴𝐹 = ‾𝑥‪ .‬כל פסוקית היא שלשה של קודקודים‬ ‫‪ .1‬שורה ‪ :1‬כגודל הניחוש )𝑛(𝑂 = )|‪.𝑂(|π‬‬
‫המסומנים בהתאם לשלושת הליטרלים בפסוקית הזאת‪ .‬שלושת‬ ‫‪ .2‬שורה ‪ :2‬הצבה לבדיקת הסיפוק )|‪.𝑂(|ϕ‬‬
‫הקודקודים האלה מחוברים ביניהם וגם מחוברים לקודקודי המשתנים‬ ‫סה"כ )|‪ - 𝑂(|ϕ‬פולינומי‪.‬‬
‫שלהם בהתאם לסימון‪ .‬נסמן ב‪ 𝑚-‬את המשתנים ו‪ 𝑙-‬את הפסוקיות‪.‬‬
‫הוכחת נכונות‪ :‬צריך להוכיח ש‪.3𝑆𝐴𝑇 = 𝐿(𝑁3) :‬‬
‫מספר הקודקודים בגרף 𝐺 הוא 𝑙‪ 2𝑚 + 3‬וגם 𝑙‪.𝑘 = 𝑚 + 2‬‬
‫סיבוכיות זמן ריצה‪ :‬לכל משתנה ניצור ‪ 2‬קודקודים עם צלע‬ ‫● 𝑇𝐴𝑆‪ ← < ϕ >∈ 3‬קיימת השמה ‪ π‬שמספקת את‬
‫מחבר ביניהם‪ ,‬לכל פסוקית ניצור ‪ 3‬קודקודים עם ‪ 3‬צלעות‬ ‫מקבל←‬ ‫הפסוק ‪ ←ϕ‬קיים ניחוש של ‪ π‬שיוביל למצב‬
‫ביניהם‪ .‬בנוסף‪ ,‬לכל ליטרל זהה ב‪ 2-‬הקבוצות נחבר בצלע‪.‬‬ ‫)‪.< ϕ >∈ 𝐿(𝑁3‬‬
‫● 𝑇𝐴𝑆‪← < ϕ >∉ 3‬לכל השמה ‪ ,π‬היא לא תספק את סה"כ ‪ -‬זמן פולינומי‪.‬‬
‫תקפות הפונקציה‪.< ϕ >∈ 3𝑆𝐴𝑇 ⇔ < 𝐺, 𝑘 >∈ 𝑉𝐶 :‬‬ ‫‪ ← ϕ‬לכל ניחוש נדחה ← )‪.< ϕ >∉ 𝐿(𝑁3‬‬
‫● 𝑇𝐴𝑆‪ ← < ϕ >∈ 3‬יש השמה מספקת ל‪ ← ϕ-‬נבנה‬ ‫ומכאן 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪ 3 − 𝐶𝑁𝐹 −‬כנדרש‪.‬‬
‫כיסוי בגודל 𝑙‪:𝑘 = 𝑚 + 2‬‬ ‫מ‪.‬ש‪.‬ל‪.‬‬
‫○ מקודקודי המשתנים‪ ,‬ניקח מכל זוג את הליטרל עם ה‪.𝑇-‬‬
‫○ מקודקודי הפסוקיות‪ ,‬נבחר מכל משולש שני קודקודים‪ ,‬כך‬ ‫הוכחת הרדוקציה‪.3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑃𝑉𝐶 :‬‬
‫שהשלישי קיבל ערך 𝑇 (חייב להיות כזה כי ההשמה עבור ‪ϕ‬‬
‫רעיון ההוכחה‪ :‬הרדוקציה ממירה פסוק 𝑓𝑛𝑐‪ 3‬שנסמנה ב‪ϕ-‬‬
‫היא מספקת‪ ,‬לכן חייב להיות לפחות 𝑇 אחד)‪.‬‬
‫לגרף 𝐺 ומספר 𝑘‪ ,‬כך ש ‪ ϕ‬ספיק כאשר 𝐺 מכיל כיסוי קודקודים‬
‫← קיבלנו כיסוי‪ ,‬כי הצלעות מקבוצת המשתנים מכוסות‪,‬‬
‫של 𝑘 קודקודים‪ .‬ההמרה נעשית ללא הידיעה אם ‪ ϕ‬ספיק או‬
‫הצלעות בתוך המשולשים מכוסות והצלעות בין הקבוצות‬
‫לא‪ .‬בפועל‪ 𝐺 ,‬מסמלץ את ‪ .ϕ‬הגרף מכיל כלים שמחקים (חיקוי)‬
‫מכוסות‪ :‬עבור משתנים שקיבלו 𝑇 צד המשתנים וגם עבור‬
‫את המשתנים והפסוקיות של ‪ .ϕ‬אנחנו ניצור ‪ 2‬קבוצות בגרף‬
‫משתנים שקיבלו 𝐹 בצד המשולשים‪.< 𝐺, 𝑘 >∈ 𝑉𝐶 ← .‬‬
‫שנבנה‪ :‬קבוצת קודקודי המשתנים וקבוצת קודקודי הפסוקיות‪.‬‬
‫● 𝐶𝑉 ∈> 𝑘 ‪ ← < 𝐺,‬קיים כיסוי קודקודים בגודל‬
‫‪ .1‬קבוצת קודקודי הפסוקיות‪ :‬עבור כל פסוקית )𝑧 ∨ 𝑦 ∨ 𝑥(‬
‫𝑙‪ 𝑘 = 𝑚 + 2‬בגרף 𝐺 ← כדי לכסות את כל הצלעות‬
‫‪ ,‬נגדיר שלושה קודקודים המחוברים ביניהם‪.‬‬
‫במשולשים (לבנות פסוקיות עם ‪ 3‬ליטרלים)‪ ,‬הכיסוי חייב לקחת לפחות‬
‫‪ .2‬קבוצת קודקודי המשתנים‪ :‬עבור כל משתנה‪ ,‬נגדיר שני‬
‫‪ 2‬קודקודים מכל משולש ← כדי לכסות את הצלעות‬
‫קודקודים מחוברים (צלע)‪ ,‬עבורו ועבור ההופכי שלו‪.‬‬
‫במשתנים‪ ,‬הכיסוי חייב לקחת לפחות קודקוד אחד עבור כל‬
‫לאחר מכן‪ ,‬נחבר בין ‪ 2‬הקבוצות שהצגנו‪ ,‬כלומר נחבר צלעות‬
‫משתנה‪ ← .‬נבנה השמה‪ :‬לכל משתנה‪ ,‬נחבר שיהיה 𝑇 אם‬
‫בין ליטרלים זהים בשתי הקבוצות ‪ -‬כל משתנה בקבוצת‬
‫הקודקוד שלו בכיסוי‪ ,‬ו‪ 𝐹-‬אם השלילה בכיסוי‪ .‬כיוון שהראנו‬
‫המשתנים נבחר בצלע עם אותו המשתנה שנמצא בקבוצת‬
‫שרק אחד נבחר מכל משתנה‪ ,‬זו השמה חוקית‪ ← .‬ההשמה‬
‫הפסוקיות‪ .‬אנחנו נבחר את 𝑘 להיות 𝑙‪ 𝑘 = 𝑚 + 2‬כאשר 𝑚‬
‫שבנינו מספקת‪ :‬בכל משולש‪ ,‬הקודקוד שלא נבחר לכיסוי‬
‫זה מספר המשתנים ו‪ 𝑙-‬זה מספר הפסוקיות‪.‬‬
‫חייב להתחבר לקודקוד משתנה שכן נבחר (אחרת הצלע לא‬
‫מכוסה)‪ ,‬ולכן קיבל ערך 𝑇 ומכאן ← 𝑇𝐴𝑆‪.< ϕ >∈ 3‬‬
‫הוכחה‪ :‬נראה רדוקציה 𝑇𝐴𝑆‪.𝑆𝐴𝑇 ≤𝑃 3‬‬ ‫רדוקציה ‪.𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑃3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 :6‬‬
‫לנוחות‪ ,‬נסמן במקום ב‪ .𝑆𝐴𝑇 ≤𝑃 3𝑆𝐴𝑇 -‬תחילה צריך להוכיח‬
‫פונקצית הרדוקציה‪.𝑓(< ϕ >) =< ϕ' > :‬‬ ‫כי 𝑃𝑁 ∈ 𝑇𝐴𝑆‪ 3‬וגם 𝑃𝑁 ∈ 𝑇𝐴𝑆‪ .‬הוכחנו בהרצאה‬
‫𝑃𝑁 ∈ 𝑇𝐴𝑆 וגם הוכחנו ברדוקציה הקודמת כי 𝑃𝑁 ∈ 𝑇𝐴𝑆‪.3‬‬
‫הפעלת הרדוקציה‪ :‬נבצע המרה בין פסוק ‪ ϕ‬רגיל לפסוק '‪ϕ‬‬
‫מצורת 𝐹𝑁𝐶 ‪ .3 −‬נסמן ב‪ 𝑛𝑖-‬את מספר הליטרלים הנמצאים‬ ‫הוכחת הרדוקציה‪.𝑆𝐴𝑇 ≤𝑃 3𝑆𝐴𝑇 :‬‬
‫בפסוקית 𝑖𝑝 ונבצע המרה בצורה הבאה‪:‬‬ ‫רעיון ההוכחה‪ :‬אנחנו צריכים להמיר כל פסוקית מהפסוק‬
‫‪ .1‬לכל פסוקית בגודל ‪ :𝑛 ≤ 2‬נבחר ליטרל מהפסוקית ונשכפל‬ ‫המקורי 𝑇𝐴𝑆 ∈ ‪ ϕ‬לפסוקיות בגודל ‪ 3‬בפסוק 𝑇𝐴𝑆‪.ϕ' ∈ 3‬‬
‫אותו עד שנגיע ל‪ 3-‬ליטרלים בפסוקית‪.‬‬ ‫אנחנו נראה רדוקציה פולינומית מ‪ 𝑆𝐴𝑇-‬ל‪ ,3𝑆𝐴𝑇-‬ואז נוכל‬
‫‪ .2‬לכל פסוקית בגודל ‪ :𝑛 = 3‬נשאיר אותו כמו שהוא‪.‬‬ ‫להוכיח ש‪ 3𝑆𝐴𝑇 :‬היא 𝑃𝑁‪-‬שלמה‪ .‬מספיק להראות איך לתרגם‬
‫‪ .3‬לכל פסוקית בגודל ‪ :𝑛 ≥ 4‬נפצל את הפסוקית ל‪𝑛 − 2-‬‬ ‫פסוקית אחת לפסוק 𝐹𝑁𝐶‪ .3‬עבור פסוק כללי‪ ,‬אפשר להפעיל‬
‫פסוקיות חדשות המכילות את הליטרלים הקיימים‪ ,‬יחד עם‬ ‫את התהליך על כל פסוקית לחוד‪ .‬ההמרה תתבצע בצורה‬
‫‪ 𝑛 − 3‬משתני עזר 𝑦 חדשים ונוספים הממלאים את‬ ‫הבאה‪:‬‬
‫הפסוקיות החדשות לצורה של ‪-3‬ליטרלים (במידה וחסר)‪.‬‬ ‫‪ .1‬לכל פסוקית שיש בה ‪ 1‬או ‪ 2‬ליטרלים‪ ,‬אנחנו נבחר אחד‬
‫מהם ונשכפל אותו בתוך הפסוקית עד שנגיע ל‪ 3-‬ליטרלים‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬בזמן הגרוע‪ ,‬עבור כל פסוקית בגודל 𝑛‪,‬‬ ‫‪ .2‬לכל פסוקית שיש בה יותר מ‪ 3-‬ליטרלים‪ ,‬אנחנו נפצל אותה‬
‫נוסיף ‪ 𝑛 − 3‬ליטרלים ו‪ 𝑛 − 2-‬פסוקיות חדשות ולכן זה‬ ‫לכמה פסוקיות בגודל ‪ ,3‬במידה ונשאר לנו שארית להשלים‬
‫מתבצע בזמן פולינומי‪.‬‬ ‫אז נבחר במשתנה במשתני עזר 𝑖𝑦 ונשכפל אותם עד שנגיע‬
‫ל‪ 3-‬ליטרלים בכל הפסוקיות‪.‬‬
‫תקפות הפונקציה‪.< ϕ' >∈ 3𝑆𝐴𝑇 ⇔ < ϕ >∈ 𝑆𝐴𝑇 :‬‬
‫דוגמה להמחשה‪ :‬נסמן ליטרל ב‪ 𝑙-‬ופסוקית ב‪.𝑝-‬‬
‫● 𝑇𝐴𝑆 ∈> ‪ ← < ϕ‬קיימת ל‪ ϕ-‬השמה מספקת ‪ ← π‬נבנה‬ ‫)‪(𝑙1) ⇒ (𝑙1 ∨ 𝑙1 ∨ 𝑙1‬‬
‫השמה מספקת לכל פסוקית חדשה ← עבור המשתנים‬
‫)‪(𝑙1 ∨ 𝑙2) ⇒ (𝑙1 ∨ 𝑙2 ∨ 𝑙2‬‬
‫המקוריים‪ ,‬ההשמה תיתן להם את אותו הערך )𝑙(‪π'(𝑙) = π‬‬
‫‪ ← .‬ההשמה מספקת ולכן יש לפחות ליטרל אחד 𝑖𝑙 שיקבל‬ ‫)‪(𝑙1 ∨ 𝑙2 ∨ 𝑙3) ⇒ (𝑙1 ∨ 𝑙2 ∨ 𝑙3‬‬
‫ערך 𝑇 ← עבור משתנים חדשים נבצע לכל ‪ 𝑗 ≤ 𝑖 − 2‬את‬
‫𝑇 = )𝑗𝑙('‪ π‬וגם נבצע לכל ‪ 𝑗 > 𝑖 − 2‬את 𝐹 = )𝑗𝑙('‪← .π‬‬ ‫עבור פסוקית 𝑝 כך ש‪ ,𝑛 ≥ 4 :‬הפתרון מורכב יותר ודורש‬
‫שימוש במשתני עזר שנסמן ב‪.𝑦1, 𝑦2,...., 𝑦𝑛−3-‬‬
‫כל הפסוקיות יסתפקו ע"י המשתנים החדשים‪ ,‬מלבד‬
‫הפסוקית של 𝑖𝑙‪ ,‬שתסתפק כי הוא ערך 𝑇 ← יש השמה‬ ‫באופן כללי‪ ,‬אם הפסוקית 𝑝 מכילה 𝑛 ליטרלים‪:‬‬
‫)𝑛𝑙 ∨ ‪𝑝 = (𝑙1 ∨ 𝑙2 ∨...‬‬
‫מספקת ל‪.< ϕ' >∈ 3𝑆𝐴𝑇 ← ϕ'-‬‬
‫אז אנחנו יכולים להחליף אותה עם ‪ 𝑛 − 2‬פסוקיות חדשות וגם‬
‫● 𝑇𝐴𝑆‪ ← < ϕ' >∈ 3‬קיימת השמה מספקת ל‪ ← ϕ'-‬נניח‬ ‫‪ 𝑛 − 3‬משתנים חדשים בנוסף לקיימים‪.‬‬
‫בשלילה ש )𝑖𝑙('‪ ϕ(𝑙𝑖) = ϕ‬לא השמה מספקת ל‪← ϕ-‬‬
‫לדוגמה‪ ,‬נתבונן בפסוקית הבאה‪:‬‬
‫אז כל הליטרלים קיבלו ערך 𝐹 ← 𝑇 = )𝑖𝑦(‪ ϕ‬כי ההשמה‬
‫)‪(𝑙1 ∨ 𝑙2 ∨ 𝑙3 ∨ 𝑙4) ⇒ (𝑙1 ∨ 𝑙2 ∨ 𝑦1) ∧ (𝑦‾1 ∨ 𝑙3 ∨ 𝑙4‬‬
‫צריכה לספק את '‪ ← ϕ‬הפסוקית האחרונה לא מסתפקת ←‬
‫סתירה‪ ← .‬לכן‪ ϕ(𝑙𝑖) = ϕ'(𝑙𝑖) ,‬זו השמה מספקת ל‪← ϕ-‬‬ ‫יש לה ‪ 𝑛 = 4‬ליטרלים‪ ,‬איתה ניצור ‪ 𝑛 − 2 = 2‬פסוקיות‬
‫חדשות ונוספו לה ‪ 𝑛 − 3 = 1‬משתנים חדשים (‪.)𝑦1‬‬
‫𝑇𝐴𝑆 ∈> ‪.< ϕ‬‬
‫ככה אנחנו נפעל לכל פסוקית שנפגוש בתהליך ההמרה כך‬
‫מ‪.‬ש‪.‬ל‪.‬‬ ‫שנבדיל בין פסוקיות עם לכל היותר ‪ 3‬ליטרלים ופסוקיות עם‬
‫לפחות ‪ 4‬ליטרלים‪.‬‬
‫תרגיל ‪ - 3‬השמה מאוזנת ‪ -‬תרגול ‪6‬‬

‫נאמר על השמה שהיא מאוזנת אם מספר המשתנים שקיבלו 𝑇 שווה למספר המשתנים שקיבלו 𝐹‪.‬‬
‫נתונה השפה‪.𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 − 𝑆𝐴𝑇 = {ϕ | ∃ 𝑏𝑎𝑙𝑎𝑛𝑐𝑒𝑑 𝑠𝑎𝑡𝑖𝑠𝑓𝑦𝑖𝑛𝑔 𝑎𝑠𝑠𝑖𝑔𝑛𝑚𝑒𝑛𝑡𝑠 𝑓𝑜𝑟 ϕ} :‬‬
‫הוכיחו‪.𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 − 𝑆𝐴𝑇 ∈ 𝑁𝑃𝐶 :‬‬
‫פתרון‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬ולאחר מכן נוכיח כי 𝐻𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪.𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫פתרון ‪ -‬שלב א'‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪.𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫נבנה 𝑁 מ"ט א"ד פולינומית המכריעה את השפה 𝑇𝐴𝑆 ‪.𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫𝑁 על קלט > ‪ < ϕ‬תבצע‪:‬‬
‫‪ .1‬אם מספר המשתנים ב‪ ϕ-‬הוא אי‪-‬זוגי ‪ -‬דחה‪.‬‬
‫‪ .2‬נחש השמה ‪.π‬‬
‫‪ .3‬בדוק שההשמה מאוזנת ‪ -‬אם לא‪ ,‬דחה‪.‬‬
‫‪ .4‬בדוק שמתקיים 𝑒𝑢𝑟𝑡 = )‪.ϕ(π‬‬
‫‪ .5‬אם כן‪ ,‬קבל‪ .‬אחרת‪ ,‬דחה‪.‬‬
‫סיבוכיות זמן הריצה‪ :‬נסמן את מספר המשתנים של הפסוק ב‪.𝑛-‬‬
‫‪ .1‬שלב ‪ - 1‬בדיקת מספר המשתנים הוא )𝑛(𝑂‪.‬‬
‫‪ .2‬שלב ‪ - 2‬כגודל הניחוש‪.𝑂(𝑛) :‬‬
‫‪ .3‬שלב ‪ - 3‬מעבר על כל המשתנים כדי לבדוק האם הם מאוזנים‪.𝑂(𝑛) :‬‬
‫‪ .4‬שלב ‪ - 4‬בדיקת הסיפוק ע"י הצבה במעבר על הפסוק‪.𝑂(|ϕ|) :‬‬
‫‪ .5‬שלב ‪ - 5‬בדיקה בזמן קבוע )‪.𝑂(1‬‬
‫סך הכל קיבלנו זמן ריצה של כ‪ 𝑂(|ϕ|) -‬ולכן פולינומי‪.‬‬
‫הוכחת נכונות הבניה‪ :‬נוכיח כי 𝑇𝐴𝑆 ‪.𝐿(𝑁) = 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫● 𝑇𝐴𝑆 ‪ ← < ϕ >∈ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬קיימת השמה מספקת ומאוזנת עבור הפסוק ‪ ← ϕ‬קיים ניחוש‬
‫‪ π‬שיוביל למצב מקבל ← )𝑁(𝐿 ∈> ‪.< ϕ‬‬
‫● 𝑇𝐴𝑆 ‪ ← < ϕ >∉ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬לכל השמה ‪ π‬קיימים ‪ 3‬מקרים אפשריים‪:‬‬
‫○ מספר המשתנים הוא אי זוגי‪.‬‬
‫○ מספר המשתנים שקיבלו 𝑇 שונה למספר המשתנים שקיבלו 𝐹‪.‬‬
‫○ ההשמה ‪ π‬לא מספקת את ‪.ϕ‬‬
‫← לכל ניחוש נקבל לפחות אחד מהמקרים שהצגנו ולכן 𝑁 תדחה ← )𝑁(𝐿 ∉> ‪.< ϕ‬‬
‫פתרון ‪ -‬שלב ב'‪ :‬נוכיח כי 𝐻𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬בעזרת רדוקציה מ‪.𝑆𝐴𝑇-‬‬
‫תיאור הרדוקציה‪ :‬אנו יודעים כי 𝐻𝑃𝑁 ∈ 𝑇𝐴𝑆‪ ,‬לכן נראה רדוקציה 𝑇𝐴𝑆 ‪.𝑆𝐴𝑇≤𝑃𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫● פונקצית הרדוקציה‪ .𝑓(< ϕ >) =< ϕ' > :‬כאשר ‪ ϕ‬פסוק רגיל ו‪ ϕ'-‬פסוק עם מספר משתנים זוגי‪.‬‬
‫● ביצוע‪ :‬נבנה את הפסוק '‪ ϕ‬כך שהוא מכיל את הפסוק ‪ ϕ‬ויחד איתו מחוברים 𝑛 פסוקיות (ב‪)AND-‬‬
‫טאוטולוגיות (תמיד נכונות)‪ .‬כלומר ) ‾𝑦 ∨ 𝑦( ∧ ‪.ϕ' = ϕ ∧ (𝑦 ∨ 𝑦‾ ) ∧ ...‬‬
‫‪1‬‬ ‫‪1‬‬ ‫𝑛‬ ‫𝑛‬
‫הפונקציה פולינומית‪ :‬אנחנו מוסיפים מספר קבוע של פסוקיות טאולוגיות ‪ -‬פולינומי‪.‬‬

‫הפונקציה תקפה‪ :‬נראה שמתקיים 𝑇𝐴𝑆 ‪.< ϕ >∈ 𝑆𝐴𝑇 ⇔ < ϕ' >∈ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫● 𝑇𝐴𝑆 ∈> ‪ ← < ϕ‬קיימת השמה מספקת ל‪ ← ϕ-‬לכל הצבה של ערכים ל‪-𝑦-‬ים‪ ,‬אנחנו נשאר עם‬
‫השמה מספקת (כי זה טאוטולוגי) ← נבחר לכל 𝑦 את הערך ‾𝑥 ← נקבל השמה מספקת ומאוזנת ←‬
‫𝑖‬ ‫𝑖‬
‫𝑇𝐴𝑆 ‪.< ϕ' >∈ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬‬
‫● 𝑇𝐴𝑆 ‪ ← < ϕ' >∈ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬קיימת השמה מספקת ← 𝑇𝐴𝑆 ∈> ‪.< ϕ‬‬
‫לכן 𝐶𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪ 𝐵𝐴𝐿𝐴𝑁𝐶𝐸𝐷 −‬כנדרש‪.‬‬
‫∎‬
‫תמונת מצב‬
‫לחלק מהשפות בציור עוד לא הוכחנו שייכות אבל נוכיח בהמשך… נשים לב ש‪.𝐿∞, 𝐿𝑒𝑞, 𝐿 ⋆ ∈ 𝑅𝐸 ∪ 𝑐𝑜𝑅𝐸 :‬‬
‫‪Σ‬‬
‫דוגמאות לשפות ‪-NP‬שלמות‬

‫מבוא‬
‫בפרק הקודם הכרנו שתי שפות 𝑃𝑁‪-‬שלמות‪:‬‬
‫כעת נלמד כמה שפות נוספות שהם גם בעיות 𝑃𝑁‪-‬שלמות בכל מיני תחומים (גרפים‪ ,‬לוגיקה‪ ,‬קבוצות וכו'‪)..‬‬
‫איך נוכיח על שפות נוספות?‪ :‬ברגע שידועה לנו שפה 𝑃𝑁‪-‬שלמה אחת‪ ,‬אפשר להוכיח על שפות נוספות שגם הן‬
‫𝑃𝑁‪-‬שלמות‪.‬‬
‫משפט‬
‫אם 𝐶𝑃𝑁 ∈ ‪ 𝐿1‬וגם ‪ 𝐿2‬מקיימת את התכונות הבאות‪:‬‬
‫‪.𝐿2 ∈ 𝑁𝑃 .1‬‬
‫‪ ,𝐿1≤𝑃𝐿2 .2‬כלומר ‪ 𝐿1‬ניתנת לרדוקציה עם ‪.𝐿2‬‬
‫אז גם 𝐶𝑃𝑁 ∈ ‪.𝐿2‬‬
‫תרגיל‪ :‬הוכיחו את המשפט המתואר מעל‪ ,‬זכרו כי היחס 𝑃≤ הוא טרנזיטיבי‪.‬‬

‫הוכחה‪ :‬נתון לנו כי 𝑃𝑁 ∈ ‪ ,𝐿2‬לכן אנחנו חייבים להראות לכל שפה 𝑃𝑁 ∈ '𝐿 ניתנת לרדוקציה פולינומית עם‬
‫‪ .𝐿2‬מאחר ש‪ ,𝐿1 ∈ 𝑁𝑃𝐶 :‬כל שפה 𝑃𝑁 ∈ '𝐿 ניתנת לרדוקציה פולינומית ‪ ,𝐿'≤𝑃𝐿1‬וגם נתון לנו כי ‪.𝐿1≤𝑃𝐿2‬‬
‫לכן‪ ,‬מאחר והיחס 𝑃≤ הוא טרנזיטיבי‪ ,‬אז כל 𝑃𝑁 ∈ '𝐿 ניתנת לרדוקציה פולינומית עם ‪ 𝐿1‬וגם ‪ 𝐿1‬ניתנת‬
‫לרדוקציה פולינומית עם ‪ .𝐿2‬לכן‪ ,‬כל שפה 𝑃𝑁 ∈ '𝐿 ניתנת לרדוקציה פולינומית עם ‪ 𝐿2‬ומכאן 𝐶𝑃𝑁 ∈ ‪.𝐿2‬‬
‫∎‬
‫השפה ‪3SAT‬‬
‫הגדרה‪ :‬פסוק בתחשיב הפסוקים הוא 𝐹𝑁𝐶‪ 3‬אם‪:‬‬
‫‪ .1‬הפסוק 𝐹𝑁𝐶‪.‬‬
‫‪ .2‬בכל פסוקית יש שלושה ליטרלים‪.‬‬
‫השפה‪.3𝑆𝐴𝑇 = {< ϕ > | ϕ 𝑖𝑠 𝑎 𝑠𝑎𝑡𝑖𝑠𝑓𝑖𝑎𝑏𝑙𝑒 3𝐶𝑁𝐹 𝐵𝑜𝑜𝑙𝑒𝑎𝑛 𝑓𝑜𝑟𝑚𝑢𝑙𝑎} :‬‬
‫כלומר‪ ,‬זוהי שפת הפסוקים הספיקים ב‪.3𝐶𝑁𝐹-‬‬
‫דוגמה‪.(𝑥 ∨ ¬𝑦 ∨ ¬𝑧) ∧ (¬𝑥 ∨ 𝑦 ∨ 𝑤) :‬‬
‫משפט‪.3𝑆𝐴𝑇 ∈ 𝑁𝑃𝐶 :‬‬

‫הוכחה‪ :‬נראה 𝑇𝐴𝑆‪.𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑃3‬‬
‫פונקצית הרדוקציה‪ .𝑓(ϕ(𝑥1,..., 𝑥𝑛)) = ϕ'(𝑥1,..., 𝑥𝑛) :‬כל פסוקית ב‪ ϕ-‬נמיר לפסוקית אחת או יותר בעלות‬
‫שלושה ליטרלים ב‪.ϕ-‬‬
‫תיאור הרדוקציה‪ :‬נחלק את הפסוקיות ב‪ ϕ-‬לשלושה סוגים ונטפל בכל סוג בנפרד‪:‬‬
‫‪ .1‬פסוקיות עם פחות מ‪ 3-‬ליטרים ‪ -‬פסוקיות כאלה פשוט נשכפל את אחד הליטרלים עד שנגיע ל‪3-‬‬
‫ליטרלים‪.‬‬
‫‪ .2‬פסוקיות עם ‪ 3‬ליטרלים בדיוק ‪ -‬לא נשנה אותם‪.‬‬
‫‪ .3‬פסוקיות עם לפחות ‪ 4‬ליטרלים ‪ -‬מצריך עבודה עדינה יותר‪ :‬עבור כל פסוקית עם איזשהו ‪𝑘 ≥ 4‬‬
‫ליטרים‪ ,‬נוסיף עוד ‪ 𝑘 − 3‬משתנים חדשים המסומנים ב‪ ,𝑦-‬ונפצל את הפסוקית ל‪ 𝑘 − 4-‬פסוקיות‬
‫בגודל ‪ 3‬באופן הבא‪:‬‬
‫‪ .a‬הפסוקית המקורית‪(𝑙1 ∨ 𝑙2 ∨ 𝑙3 ∨ 𝑙4 ∨....... ∨ 𝑙𝑘−2 ∨ 𝑙𝑘−3 ∨ 𝑙𝑘) :‬‬
‫‪ .b‬הפסוקית החדשה‪:‬‬
‫)𝑘𝑙 ∨ ‪(𝑙1 ∨ 𝑙2 ∨ 𝑦1) ∧ (𝑦‾1 ∨ 𝑙3 ∨ 𝑦2) ∧ (𝑦‾2 ∨ 𝑙4 ∨ 𝑧3) ∧ ...... ∧ (𝑦‾𝑘−3 ∨ 𝑙𝑘−1‬‬
‫סיבוכיות זמן ריצה‪ :‬בה"כ נניח של‪ ϕ-‬יש 𝑛 משתנים ו‪ 𝑚-‬פסוקיות‪.‬‬
‫‪ .1‬המרת סוג ‪ :1‬כגודל הפסוקיות‪.𝑂(𝑚) :‬‬
‫‪ .2‬המרת סוג ‪ :2‬לא נשנה דבר ‪ -‬זמן קבוע‪.𝑂(1) :‬‬
‫‪ .3‬המרת סוג ‪ :3‬יש לכל היותר 𝑚 פסוקיות המצריכות טיפול כזה ובכל פסוקית יש לכל היותר 𝑛 ליטרלים‬
‫ולכן )𝑚 · 𝑛(𝑂‪.‬‬
‫סה"כ קיבלנו זמן )𝑚 · 𝑛(𝑂 = )𝑚 · 𝑛 ‪ - 𝑂(𝑚 +‬פולינומי‪.‬‬
‫הוכחת נכונות‪:‬נוכיח שהפונקציה שיצרנו היא אכן רדוקציה‪ ,‬כלומר‪.< ϕ' >∈ 3𝑆𝐴𝑇 ⇔ < ϕ >∈ 𝑆𝐴𝑇 :‬‬
‫מכיוון שטיפלנו בכל פסוקית בנפרד‪ ,‬נרצה להוכיח שכל פסוקית ב‪ ϕ-‬אם"ם הפסוקית או הפסוקיות המקבילות‬
‫לה ב‪ ϕ'-‬ספיקות‪ .‬מקרים ‪ 1+2‬טריוויאלים ולכן נפרט רק על מקרה ‪.3‬‬
‫נראה כי ‪ ϕ‬ספיקה ⇔ '‪ ϕ‬ספיקה‪:‬‬
‫מצד אחד ‪ -‬אם הפסוק ספיק‪ :‬אז הפסוקית הגדולה ספיקה‪ ,‬אז יש בה לפחות ליטרל אחד חיובי‪.‬‬
‫נפצל שוב לשלושה מקרים משלימים‪:‬‬
‫‪ .1‬אם הליטרל החיובי נמצא בפסוקית הראשונה שנוצרה‪ ,‬אז נוכל להגדיר שלכל ]‪ 𝑗 ∈ [1, 𝑘 − 3‬יתקיים‬
‫𝐹 = 𝑗𝑦 ולכן כל הפסוקיות שנוצרו יסתפקו‪.‬‬
‫‪ .2‬אם הליטרל החיובי נמצא בפסוקית האחרונה שנוצרה‪ ,‬אז נוכל להגדיר שלכל ]‪ 𝑗 ∈ [𝑘 − 3‬יתקיים‬
‫𝑇 = 𝑗𝑦 ולכן כל הפסוקיות שנוצרו יסתפקו‪.‬‬
‫‪ .3‬אם הליטרל החיובי נמצא באמצע‪ ,‬כלומר בפסוקית ה‪ ,𝑖-‬אז נוכל להגדיר שלכל ]‪ 𝑗 ∈ [𝑘 − 2‬יתקיים‬
‫𝑇 = 𝑗𝑦 ושלכל ‪ 𝑖 − 3 ≤ 𝑗 ≤ 𝑘 − 3‬יתקיים 𝐹 = 𝑗𝑦 ולכן כל הפסוקיות שנוצרו יסתפקו‪.‬‬
‫מצד שני ‪ -‬אם הפסוק לא ספיק‪ :‬נרצה להוכיח שגם צירוף הפסוקיות הבאות לא יסתפק‪.‬‬
‫מאחר והפסוקיות המקוריות לא הסתפקה‪ ,‬כל הליטרלים בה שליליים‪.‬‬
‫נניח בשלילה שהוא כן ספיק‪ ,‬אם כך‪ ,‬בהכרח 𝑇 = ‪ 𝑦1‬ולכן בהכרח 𝑇 = ‪ 𝑦2‬ונמשיך ככה עד 𝑇 = ‪ 𝑦𝑘−3‬ונקבל‬
‫שהפסוקית אחרונה לא מסתפקת! ‪ -‬סתירה‪.‬‬
‫∎‬
‫הערה‪ :‬ניתן להגדיר את 𝐹𝑁𝐶‪ 3‬כך שאין פסוקיות בהן משתנה מופיע יותר מפעם אחת‪ .‬במצב כזה‪ ,‬עבור‬
‫פסוקית בעלת פחות מ‪ 3-‬משתנים‪ ,‬נצטרך לבצע את הרדוקציה אחרת‪ .‬עבור פסוקית עם שני משתנים‬
‫) 𝑙 ∨ 𝑙( ניצור שתי פסוקיות חדשות‪.(𝑙 ∨ 𝑙 ∨ 𝑥) ∧ (𝑙 ∨ 𝑙 ∨ 𝑥‾) :‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪2‬‬
‫תרגיל ‪ :1‬מה יקרה עבור פסוקית עם משתנה יחיד?‬

‫פתרון ‪ :1‬אם קיים פסוקית 𝑖𝐶 עם משתנה (ליטרל) אחד )𝑖𝑙( = 𝑖𝐶 אז ניצור עבורו ‪ 2‬משתנים חדשים ‪𝑦𝑖,1 , 𝑦𝑖,2‬‬
‫נחליף את 𝑖𝐶 בצירוף פסוקיות 𝑖𝑍 כאשר )‪.𝑍𝑖 = (𝑙𝑖 ∨ 𝑦𝑖,1 ∨ 𝑦𝑖,2) ∧ (𝑙𝑖 ∨ 𝑦𝑖,1 ∨ 𝑦𝑖,2) ∧ (𝑙𝑖 ∨ 𝑦𝑖,1 ∨ 𝑦𝑖,2‬‬
‫תרגיל ‪ :2‬מה הסיבוכיות של ההמרות הללו?‬

‫פתרון ‪ :2‬להשלים‪.‬‬
‫תרגיל ‪ :3‬המירו את הפסוק הבא לצורת 𝐹𝑁𝐶‪:3‬‬

‫)‪(𝑥1 ∨ 𝑥2 ∨ 𝑥‾3 ∨ 𝑥4 ∨ 𝑥‾5 ∨ 𝑥6) ∧ (𝑥3) ∧ (𝑥1 ∨ 𝑥‾4) ∧ (𝑥‾3 ∨ 𝑥4 ∨ 𝑥‾6‬‬
‫תרגיל ‪ :3‬להשלים‪.‬‬
‫השפה ‪2SAT‬‬
‫הגדרה‪ :‬פסוק בתחשיב הפסוקים הוא 𝐹𝑁𝐶‪ 2‬אם‪:‬‬
‫‪ .1‬הפסוק 𝐹𝑁𝐶‪.‬‬
‫‪ .2‬בכל פסוקית יש שני ליטרלים‪.‬‬
‫השפה‪.2𝑆𝐴𝑇 = {< ϕ > | ϕ 𝑖𝑠 𝑎 𝑠𝑎𝑡𝑖𝑠𝑓𝑖𝑎𝑏𝑙𝑒 2𝐶𝑁𝐹 𝐵𝑜𝑜𝑙𝑒𝑎𝑛 𝑓𝑜𝑟𝑚𝑢𝑙𝑎} :‬‬
‫כלומר‪ ,‬זוהי שפת הפסוקים הספיקים ב‪.2𝐶𝑁𝐹-‬‬
‫דוגמה‪.(𝑥 ∨ ¬𝑦) ∧ (¬𝑥 ∨ 𝑦) :‬‬
‫שאלה‪ :‬האם 𝐶𝑃𝑁 ∈ 𝑇𝐴𝑆‪?2‬‬

‫תשובה‪ :‬אי אפשר!‪ ,‬נוכיח כי 𝑃 ∈ 𝑇𝐴𝑆‪!2‬‬
‫משפט‪2𝑆𝐴𝑇 ∈ 𝑃 :‬‬
‫מבוא להוכחה‪ :‬במקרה של פסוקית שיש בה רק שני ליטרלים‪ ,‬אם ידוע לנו על אחד מהם שהוא 𝐹 אז השני חייב‬
‫להיות 𝑇 כדי שהפסוק יסתפק‪ .‬מה שאומר שניתן לבנות גרף מכוון שירכז את כל התנאים של כל הפסוקיות‬
‫ולהשתמש בגרף הנ"ל כדי למצוא השמה מספקת‪ .‬כך שאם השמה זו לא קיימת‪ ,‬נוכל לזהות זאת ולהחזיר‬
‫תשובה שלילית‪.‬‬
‫הוכחה‪ :‬נוכיח ע"י בניית גרף שייצג שקילות לוגית לפסוק‪ .‬הבנייה תעשה בזמן פולינומי‪ ,‬הפעולות על הגרף ייעשו‬
‫בזמן פולינומי‪ ,‬סה"כ נקבל אלגוריתם פולינומי הבודק האם פסוק 𝐹𝑁𝐶‪ 2‬ספיק‪.‬‬
‫הפסוק שנעסוק בו הוא 𝑚𝐶 ∧ ‪ ϕ(𝑥1,..., 𝑥𝑛) = 𝐶1 ∧ 𝐶2 ∧ ...‬בעל 𝑚 פסוקיות‪.‬‬
‫תזכורת ‪ :1‬פסוקית מהצורה )𝑗𝑙 ∨ 𝑖𝑙( שקולה לוגית לפסוק 𝑗𝑙 → 𝑖‾𝑙 ולפסוק 𝑖𝑙 → 𝑗‾𝑙‪.‬‬
‫תזכורת ‪.¬¬𝑥 = 𝑥 :2‬‬
‫המשך‪ :‬נייצג כל פסוקית )𝑗𝑙 ∨ 𝑖𝑙( בגרף ע"י השקילות הלוגית )𝑖𝑙 → 𝑗‾𝑙( ∧ )𝑗𝑙 → 𝑖‾𝑙(‪.‬‬
‫נרצה לבנות את הגרף )𝐸 ‪ 𝐺 = (𝑉,‬באופן הבא‪:‬‬
‫● קבוצת הקודקודים‪.𝑉 = {𝑥𝑖, 𝑥‾𝑖 : 𝑖 ∈ [𝑛]} :‬‬
‫● קבוצת הצלעות‪.𝐸 = {𝑥‾𝑖 → 𝑥𝑗 , 𝑥‾𝑗 → 𝑥𝑖 | (𝑥𝑖 ∨ 𝑥𝑗) ∈ ϕ} :‬‬

‫● בגרף יהיו 𝑛‪ 2‬קודקודים וגם 𝑚‪ 2‬צלעות ולכן קידוד הגרף יצריך זמן פולינומי בגודל הפסוק‪.‬‬
‫אבחנה ‪ :1‬נשים לב שהגרף סימטרי‪ ,‬כלומר אם יש קשת 𝑏 → 𝑎 אז יש גם קשת ‾𝑎 → ‾𝑏‪( .‬זה נובע ישירות מכך‬
‫שאם יש קשת 𝑏 → 𝑎 אז מופיעה הפסוקית )𝑏 ∨ ‾𝑎( ולכן בגרף ישנה הצלע ‾𝑎 → ‾𝑏)‪.‬‬
‫הסבר בעברית (תכל'ס) לבניית הגרף שהצגנו‪ :‬ניצור גרף )𝐸 ‪ 𝐺 = (𝑉,‬עם 𝑛‪ 2‬קודקודים‪ .‬אינטואיטיבית‪ ,‬לכל‬
‫משתנה ניצור ‪ 2‬קודקודים‪ ,‬קודקוד ראשון לעצמו וקודקוד שני לשלילה שלו‪ .‬לכל פסוקית )𝑏 ∨ 𝑎( כאשר 𝑏 ‪𝑎,‬‬
‫הם ליטרלים‪ ,‬ניצור צלע מכוונת )𝑏 ‪ (𝑎‾,‬וגם )𝑎 ‪ .(𝑏‾,‬הצלעות האלה אומרות בעצם שאם 𝑎 הוא 𝐹‪ ,‬אז 𝑏 חייב‬
‫להיות 𝑇 (להפך)‪ .‬מכאן‪ ,‬קיים צלע מכוונת )𝐺(𝐸 ∈ )𝑏 ‪ (𝑎,‬אם"ם קיים פסוקית ‪.(𝑎‾, 𝑏) ∈ ϕ‬‬
‫דוגמה‪ :‬נסתכל על הפסוק הבא‪:‬‬

‫)𝑦 ∨ 𝑧( ∧ )‾𝑧 ∨ 𝑥( ∧ )𝑧 ∨ ‾𝑦( ∧ )𝑦 ∨ ‾𝑥( = ‪.ϕ‬‬
‫אפשר לראות למשל עבור הפסוקית הראשונה )𝑦 ∨ ‾𝑥( אז אנחנו‬
‫‾‬
‫צריכים ליצור צלע )𝑦 ‪ (𝑥‾, 𝑦) = (𝑥,‬וגם צלע )‾𝑥 ‪ ,(𝑦‾,‬אפשר לראות‬
‫בציור כי באמת קיימות הצלעות המכוונות האלה‪.‬‬
‫המשך‪ :‬אם נשתמש באבחנה זו מספר פעמים‪ ,‬נשים לב שמסלול‪:‬‬

‫𝑘𝑣 → ‪ 𝑣1 → 𝑣2 →... → 𝑣𝑘−1‬גורר את הצלעות‪:‬‬
‫‪.𝑣‾𝑘 → 𝑣𝑘−1‬‬
‫‪ 𝑣‾ → 𝑣‾ , 𝑣‾ → 𝑣‾ , ....‬שיגררו את קיום המסלול‪‾ →... → 𝑣‾ → 𝑣‾ :‬‬
‫‪2‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪3‬‬ ‫‪2‬‬
‫‪, 𝑣‾𝑘 → 𝑣𝑘−1‬‬
‫‾‬
‫אבחנה ‪ :2‬לכל צלע 𝑣 → 𝑢 מתקיים‪ :‬אם הקודקוד 𝑢 קיבל 𝑇 אז גם הקודקוד 𝑣 צריך לקבל 𝑇‪.‬‬
‫למה? כי )𝑣 ∨ ‾𝑢( ≡ 𝑣 → 𝑢‪.‬‬
‫ננסח קריטריון כללי‪ :‬אין השמה מספקת לפסוק אם"ם קיים משתנה 𝑥 כך שקיים מעגל מכוון‪:‬‬
‫‪ .1‬קיים מסלול מ‪ 𝑥-‬ל‪ 𝑥‾-‬בגרף‪.‬‬
‫‪ .2‬קיים מסלול מ‪ 𝑥‾-‬ל‪ 𝑥-‬בגרף‪.‬‬
‫הוכחת הקריטריון‪:‬‬
‫● כיוון א' ‪ -‬אם לא קיים בגרף משתנה 𝑥 כך ש‪ 𝑥 :‬וגם ‾𝑥 נמצאים שניהם על מעגל מכוון אחד‪ ,‬אזי קיימת‬
‫השמה מספקת לפסוק‪ .‬נניח שלא קיים קודקוד 𝑥 כך שיש מסלול מ‪ 𝑥-‬לעבר ‾𝑥‪ ,‬וגם יש מסלול מ‪𝑥‾-‬‬
‫לעבר 𝑥‪ .‬נחפש קודקוד (ליטרל) שנסמן ב‪ 𝑢‾-‬אשר יש ממנו מסלול אל שלילתו‪ .‬כלומר 𝑢 → ‪ ,𝑢‾ →...‬אם‬
‫לא קיים מסלול כזה‪ ,‬נבחר קודקוד כלשהו‪.‬‬
‫○ ניתן לליטרל 𝑇 = 𝑢 ולליטרל 𝐹 = ‾𝑢‪.‬‬
‫○ לכל הקודקודים שיש מסלול אליהם מ‪ ,𝑢-‬ניתן ערך 𝑇 ו‪ 𝐹-‬לשלילתם‪.‬‬
‫יש שתי בעיות שעלולות לצוץ בשיטה זו‪:‬‬
‫‪ .1‬יש מסלול מ‪ 𝑢-‬לקודקוד כלשהו 𝑤 וגם מסלול מ‪ 𝑢-‬ל‪ :𝑤‾-‬בגלל הסימטריה של הגרף‪ ,‬מכיוון שיש‬
‫מסלול מ‪ 𝑢-‬אל 𝑤 אז גם יש מסלול מ‪ 𝑤‾-‬אל ‾𝑢‪ ,‬כלומר יש מעגל המכיל את 𝑢 וגם את ‾𝑢‪,‬‬
‫בסתירה להנחה‪.‬‬
‫‪ .2‬יש קודקוד שנרצה לתת לו ערך 𝑇 אבל הוא כבר קיבל ערך 𝐹‪ :‬זה יקרה אם ‾𝑤 קיבל 𝑇‪ .‬כלומר‬
‫יש מסלול מ‪ 𝑢-‬אל ‾𝑤‪ .‬שוב‪ ,‬בגלל הסימטריה שלה הגרף‪ ,‬נובע שיש מסלול מ‪ 𝑤-‬אל ‾𝑢‪ ,‬בסתירה‬
‫להנחה‪.‬‬
‫● כיוון ב' ‪ -‬אם קיים בגרף משתנה 𝑥 כך ש‪ 𝑥 :‬וגם ‾𝑥 נמצאים שניהם על מעגל מכוון אחד‪ ,‬אזי אין השמה‬
‫מספקת לפסוק‪ .‬נניח שיש קודקוד 𝑥 כך שיש מסלול מ‪ 𝑥-‬לעבר ‾𝑥‪ ,‬וגם יש מסלול מ‪ 𝑥‾-‬לעבר 𝑥‪.‬‬
‫○ אם 𝑇 = 𝑥 אז צריך שגם 𝑇 = ‾𝑥 וזו סתירה!‪.‬‬
‫○ אם 𝑇 = ‾𝑥 אז צריך שגם 𝑇 = 𝑥 וזו גם סתירה!‬
‫מ‪.‬ש‪.‬ל‪ - .‬הקריטריון הכללי‬
‫המשך ההוכחה‪ :‬לסיכום‪ ,‬בהינתן פסוק 𝐹𝑁𝐶‪ 2‬נתאר מכונה‪/‬אלגוריתם דטרמיניסטי פולינומי‪:‬‬
‫𝑇𝐴𝑆‪ 𝑀2‬על קלט > ‪ < ϕ‬תבצע‪:‬‬
‫‪ .1‬בונה את הגרף הנ"ל‪.‬‬
‫‪ .2‬לכל 𝑉 ∈ 𝑣 תבצע‪:‬‬
‫‪ .a‬מבצעת 𝑆𝐹𝐵 (או 𝑆𝐹𝐷) מ‪.𝑣-‬‬
‫‪ .b‬אם קיים מסלול מ‪ 𝑣-‬אל ‾𝑣‪ ,‬מבצעת גם 𝑆𝐹𝐵 מ‪ ,𝑣‾-‬אם נמצא שהמסלול מגיע חזרה אל 𝑣 ‪-‬‬
‫אז דחה‪.‬‬
‫‪ .3‬קבל‪.‬‬
‫נכונות הבניה‪ :‬נובעת ישירות נכונות הקריטריון שהוכחנו‪.‬‬
‫‪2‬‬
‫סיבוכיות זמן ריצה‪ :‬סיבוכיות של 𝑆𝐹𝐷 היא ) 𝑛 ‪ 𝑂(|𝑉| + |𝐸|) = 𝑂(𝑛 +‬ונבצע את ה‪ 𝐷𝐹𝑆-‬למשך |𝑉| = 𝑛‬
‫‪3‬‬
‫פעמים‪ .‬סה"כ נקבל ) 𝑛(𝑂 ‪ -‬זמן פולינומי‪.‬‬
‫∎‬
‫הסבר תכל'ס‪ :‬נסתמך בשיטת הבדיקה הבאה‪ :‬לפי בדיקת קיימות המסלול ‾𝑥 → 𝑥 או‪/‬גם 𝑥 → ‾𝑥 בגרף 𝐺‪,‬‬
‫אנחנו יכולים להכריע האם ההשמה מספקת את ‪ ϕ‬או לא‪ .‬קיום המסלול מצומת אחת לאחר יכולה להתבצע‬
‫באלגוריתמים טריוויאלים לחיפוש בגרף כמו 𝑆𝐹𝐵 או 𝑆𝐹𝐷‪ .‬שני האלגוריתמים האלה הם בזמן פולינומי‬
‫)𝐸 ‪ 𝑂(𝑉 +‬ולכן אפשר להוכיח בצורה הזאת כי 𝑃 ∈ 𝑇𝐴𝑆‪.2‬‬
‫בעיית כיסוי קודקודים היא ‪-NP‬שלמה‬

‫הגדרה‪ :‬קבוצת צמתים 𝑈 בגרף לא מכוון )𝐸 ‪ 𝐺 = (𝑉,‬נקראת כיסוי קודקודים‪ ,‬אם לכל קשת )𝐺(𝐸 ∈ )𝑣 ‪(𝑢,‬‬
‫מתקיים ש‪ :‬או 𝑈 ∈ 𝑢 או ש‪ 𝑣 ∈ 𝑈 :‬או 𝑈 ∈ 𝑢 ‪ .𝑣,‬בנוסף‪ ,‬צמתי 𝑈 "מכסים" את כל קשתות הגרף‪.‬‬
‫}𝑟𝑒𝑣𝑜𝑐 𝑥𝑒𝑡𝑟𝑒𝑣 𝑒𝑑𝑜𝑛 ‪𝑉𝐸𝑅𝑇𝐸𝑋 − 𝐶𝑂𝑉𝐸𝑅 = {< 𝐺, 𝑘 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ𝑎𝑡 ℎ𝑎𝑠 𝑎 𝑘 −‬‬
‫משפט‪.𝑉𝐶 ∈ 𝑁𝑃𝐶 :‬‬

‫הוכחה‪ :‬צריך להוכיח כי 𝑃𝑁 ∈ 𝐶𝑉 ולאחר מכן להוכיח כי 𝐻𝑃𝑁 ∈ 𝐶𝑉 בעזרת רדוקציה 𝐶𝑉𝑃≤𝑇𝐴𝑆‪.3‬‬
‫חלק א'‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝐶𝑉‪ .‬נתאר מ"ט א"ד לשפה 𝐶𝑉‪.‬‬
‫המכונה 𝑁 על קלט > 𝑘 ‪ < 𝐺,‬תבצע‪:‬‬
‫‪ .1‬מנחשת קבוצת קודקודים בגודל 𝑘‪.‬‬
‫‪ .2‬עוברת על כל הצלעות בגרף‪ ,‬אם מוצאת צלע שחלה בקודקוד שאינו בקבוצה ‪ -‬דוחה‪.‬‬
‫‪ .3‬מקבלת‪.‬‬
‫נשים לב שלא ביקשנו כיסוי מינימלי ))𝐺(‪ .(τ‬יתכן ויהיו קודקודים זהים בקבוצה שמנחשים‪.‬‬
‫● המכונה עובדת בזמן פולינומי‪:‬‬
‫○ שלב ‪ - 1‬כגודל הניחוש )𝑘(𝑂‪.‬‬
‫○ שלב ‪ - 2‬מעבר על כל הצלעות בגרף ובודקת כל קודקוד בקבוצה )|𝐸| · 𝑘(𝑂‪.‬‬
‫סה"כ זמן ריצה )|𝐸| · 𝑘(𝑂 ‪ -‬זמן פולינומי‪.‬‬
‫● נכונות הבניה‪ :‬נראה כי 𝐶𝑉 = )𝑁(𝐿‪.‬‬
‫○ 𝐶𝑉 ∈> 𝑘 ‪ ← < 𝐺,‬קיימת קבוצת 𝑘‪-‬קודקודים המכסים את כל הצלעות בגרף ← קיים ניחוש‬
‫עבור קבוצה כזו בגודל 𝑘 ← 𝑁 בוחר בניחוש הנכון‪ ,‬עובר כל על הצלעות והבדיקה עברה‬
‫בהצלחה ← 𝑁 מקבל ← )𝑁(𝐿 ∈> 𝑘 ‪.< 𝐺,‬‬
‫○ 𝐶𝑉 ∉> 𝑘 ‪ ← < 𝐺,‬לא קיימת קבוצת 𝑘‪-‬קודקודים המכסים את כל הצלעות בגרף ← לכל‬
‫ניחוש עבור קבוצה כזו בגודל 𝑘‪ 𝑁 ,‬בודק ומוצא צלע שחלה בקודקוד שאינו בקבוצה ← 𝑁‬
‫דוחה ← )𝑁(𝐿 ∉> 𝑘 ‪.< 𝐺,‬‬
‫חלק ב'‪ :‬נוכיח כי 𝐻𝑃𝑁 ∈ 𝐶𝑉 בעזרת רדוקציה 𝐶𝑉𝑃≤𝑇𝐴𝑆‪ .3‬לכל פסוק 𝐹𝑁𝐶‪ ,ϕ ∈ 3‬יש לבנות זמן פולינומי‬
‫בגודל של ‪ ,ϕ‬גרף לא מכוון 𝐺 ומספר טבעי 𝑘‪ ,‬כך שב‪ 𝐺-‬יש 𝐶𝑉 בגודל 𝑘 אם ורק אם ‪ ϕ‬ספיק‪.‬‬
‫בהינתן פסוק 𝐹𝑁𝐶‪ 3‬עם 𝑛 משתנים ו‪ 𝑚-‬פסוקיות‪ ,‬כאשר כל פסוקית 𝑖‪ φ‬היא פסוקית עם ‪ 3‬ליטרלים וגם כל‬
‫ליטרל הוא מהצורה 𝑘𝑥 = 𝑗𝑖𝑙 או 𝑘‾𝑥 = 𝑗𝑖𝑙‪ .‬נבנה את הגרף הבא )𝐸 ‪:𝐺 = (𝑉,‬‬
‫● קבוצת הקודקודים‪:‬‬
‫}‪.𝑉 = {𝑥𝑖| 1 ≤ 𝑖 ≤ 𝑛} ∪ {𝑥‾𝑖| 1 ≤ 𝑖 ≤ 𝑛} ∪ {𝑙𝑗𝑟| 1 ≤ 𝑗 ≤ 𝑚 , 1 ≤ 𝑟 ≤ 3‬‬
‫צומת לכל משתנה‬ ‫צומת שלילה לכל משתנה‬ ‫לכל פסוקית ‪ ,j‬ניצור שלושה צמתים‬
‫● קבוצת הצלעות 𝐸 נבנה כך‪:‬‬

‫○ לכל משנה 𝑖𝑥 נגדיר את הצלע }𝑖‾𝑥 ‪.{𝑥𝑖,‬‬
‫○ לכל פסוקית 𝑗‪ ,‬ניצור משולש 𝑟 (‪ 3‬צלעות מחוברות)‬
‫שקודקודיו הם הליטרלים של הפסוקית‪.‬‬
‫○ נחבר כל ליטרל במשולשים של הפסוקיות עם‬
‫המשתנה המתאים לו בקשתות של המשתנים‪.‬‬
‫)‪ϕ(𝑥1, 𝑥2) = (𝑥1 ∨ 𝑥1 ∨ 𝑥2) ∧ (𝑥1 ∨ 𝑥2 ∨ 𝑥2) ∧ (𝑥1 ∨ 𝑥2 ∨ 𝑥2‬‬
‫אפשר למשל לכתוב 𝑗𝑖𝑥𝑙 כאשר 𝑗 אינדקס המשולש‪.‬‬

‫הרדוקציה היא > 𝑘 ‪ 𝑓(< ϕ >) =< 𝐺,‬כך ש‪ 𝐺-‬הוא הגרף שתיארנו ו‪( 𝑘 = 2𝑚 + 𝑛-‬לכסות צלעות‬
‫משתנים ‪ 𝑛 -‬וגם לכסות משולשים 𝑚‪ - 2‬כי לכל משולש‪ ,‬צריך ‪ 2‬קודקודים בשביל לכסות אותו)‪.‬‬
‫● סיבוכיות זמן הריצה‪ :‬גודל הקלט הוא )𝑛 ‪ 𝑂(𝑚 +‬וזהו גם סדר הגודל של הגרף שבנינו‪ .‬כמות הצלעות‬
‫היא בדיוק 𝑚‪ .𝑛 + 3𝑚 + 3‬אם אנחנו עובדים עם מטריצת שכנויות‪ ,‬אז זה ריבועי ‪ -‬עדיין פולינומי‪.‬‬
‫● תקפות הפונקציה‪:‬‬
‫○ נניח ש‪ ϕ ∈ 3𝑆𝐴𝑇 :‬ותהי ‪ π‬השמה מספקת עבורה‪ .‬נבנה כיסוי קודקודים ל‪ 𝐺-‬שגודלו הוא‬
‫בדיוק 𝑛 ‪:2𝑚 +‬‬
‫■ מהקשתות של המשתנים‪ ,‬ניקח כל זוג }𝑖‾𝑥 ‪ {𝑥𝑖,‬את הליטרל שמקבל ערך 𝑇 בהשמה ‪π‬‬
‫■ לכל משולש של פסוקית‪ ,‬נבחר את כל קודקודי הליטרלים בפסוקית שלא הסתפקו‪.‬‬
‫יש לכל היותר ‪ 2‬כאלה לכל פסוקית‪ ,‬כי ‪ π‬היא השמה מספקת ולכן נותנת 𝑇 ללפחות‬
‫ליטרל אחד מכל פסוקית‪.‬‬
‫גודל הקבוצה שתיארנו הוא 𝑛 ‪( 2𝑚 +‬לכל היותר)‪.‬‬
‫למה קבוצה זו מהווה כיסוי קודקודים? ‪ -‬נראה ששלושת סוגי הצלעות מכוסות‪:‬‬
‫‪ .1‬בין משתנה לשלילתו ‪ -‬בהשמה חוקים בדיוק אחד מהם מסתפק ולכן צלעות אלו‬
‫מכוסות‪.‬‬
‫‪ .2‬בכל משולש יש ‪ 2‬קודקודים בקבוצה ‪ -‬כי ‪ 2‬קודקודים מכסים משולש‪.‬‬
‫‪ .3‬הסיבה שבגללה כל צלע בין החלק העליון (ממשתנה לשלילתו) לחלק התחתון‬
‫(משולשי הפסוקיות) מכוסה מצריכה הסבר‪ .‬נניח בשלילה שישנה צלע בין החלק‬
‫העליון לחלק התחתון שאינה מכוסה ‪ -‬אם כך‪ ,‬שני קודקודי הצלע לא בקבוצת‬
‫הקודקודים שנבחרו‪ .‬הקודקוד בחלק העליון לא בקבוצה‪ ,‬כלומר הליטרל שהוא מייצג‬
‫לא מסתפק‪ ,‬ולכן הפסוקית מטה לא מסתפקת ממנו‪ .‬הקודקוד התחתון לא מיוצג‬
‫בקבוצה ואם כך‪ ,‬יש כבר שני קודקודים בפסוקית שנבחרו (אחרת פשוט היינו מוסיפים‬
‫אותם)‪ .‬אבל‪ ,‬לפי בניית הקבוצה הוספנו את כל הקודקודים מהמשולש שלא‬
‫מסתפקים ‪ -‬סתירה‪ .‬יש לכל היותר שני ליטרלים שלא מסתפקים בפסוקית ספיקה‪.‬‬
‫סך‪-‬הכל‪ ,‬הקבוצה שבחרנו היא 𝐶𝑉 כי כל הצלעות מכוסות ע"י קודקודי הקבוצה‪.‬‬
‫○ נניח ש‪ ,< 𝐺, 𝑘 >∈ 𝑉𝐶 :‬בגרף יש תת‪-‬קבוצה של קודקודים 𝑆 שהיא כיסוי קודקודים בגודל‬
‫𝑛 ‪ 𝑘 = 2𝑚 +‬בדיוק‪ .‬נשתמש ב‪ 𝑆-‬הנ"ל כדי למצוא השמה המספקת את הפסוק ‪.ϕ‬‬
‫ראשית‪ ,‬כדי לכסות צלעות של משולש‪ ,‬צריך לבחור לפחות שני קודקודים‪ ,‬וכדי לכסות צלע בין‬
‫משתנה לשלילתו צריך לפחות קודקוד אחד‪ .‬מכיוון ש‪ ,|𝑆| = 2𝑚 + 𝑛 :‬נובע ש‪ 𝑆-‬אכן מכיל‬
‫לפחות קודקוד אחד מכל צלע של משתנה ושלילתו‪ ,‬ולפחות ‪ 2‬קודקודים מכל משולש של‬
‫פסוקית‪ .‬נגדיר השמה מספקת ל‪ ϕ-‬באופן הבא‪ :‬ההשמה תתן 𝑇 לליטרלים שנבחרו ל‪ 𝑆-‬מתוך‬
‫הצלעות בין משתנה ושלילתו‪ ,‬ו‪ 𝐹-‬לאחרים‪ .‬ההשמה הנ"ל חייבת להיות השמה מספקת ‪-‬‬
‫אחרת‪ ,‬נקבל שיש משולש שכל הצלעות שיוצאות ממנו לא מגיעות לקודקוד כלשהו ב‪ ,𝑆-‬וזאת‬
‫סתירה לכך ש‪ 𝑆-‬היא כיסוי קודקודים של 𝐺‪ .‬נרצה להראות שיש לפחות ליטרל אחד חיובי בכל‬
‫פסוקית‪ ,‬מה שיגרור שהפסוק ספיק‪ .‬נניח בשלילה שהיא לא מספקת את הפסוק ‪ -‬אם כך‪ ,‬יש‬
‫לפחות פסוקית אחת שלא מסתפקת‪ .‬מכאן שכל הליטרלים בה שליליים‪ .‬בדיוק שני קודקודים‬
‫מכל משולש נבחרו‪ .‬נתבונן בקודקוד שלא נבחר בפסוקית זו‪ .‬כדי שהליטרל בפסוקית‬
‫שקודקוד זה מייצג לא יסתפק ‪ -‬הקודקוד שמייצג את ליטרל זה בחלק העליון לא נבחר אל 𝑆‪.‬‬
‫מאחר וגם הקודקוד בפסוקית לא נבחר אליה‪ ,‬הצלע ביניהם לא מכוסה‪ ,‬סתירה‪.‬‬
‫∎‬
‫בעיית קבוצה בלתי תלויה היא ‪-NP‬שלמה‬

‫תזכורת‪ :‬קבוצה בלתי תלויה (ב"ת) או 𝑇𝐸𝑆 ‪ 𝐼𝑁𝐷𝐸𝑃𝐸𝑁𝐷𝐸𝑁𝑇 −‬של צמתים בגרף לא מכוון 𝐺 היא קבוצת‬
‫צמתים שאין קשת בין כל שניים מהם‪.‬‬
‫}𝑡𝑒𝑠 𝑡𝑛𝑒𝑑𝑛𝑒𝑝𝑒𝑑𝑛𝑖 𝑒𝑑𝑜𝑛 ‪𝐼𝑆 = {< 𝐺, 𝑘 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ𝑎𝑡 ℎ𝑎𝑠 𝑎 𝑘 −‬‬
‫תרגיל‪ :‬הוכיחו‪ :‬קבוצת צמתים 𝑈 בגרף לא מכוון 𝐺 היא כיסוי קודקודים ב‪ ,𝐺-‬אם"ם 𝑈\𝑉 היא קבוצה ב"ת ב‪.𝐺-‬‬
‫● כיוון א'‪ :‬נניח ש‪ 𝑆-‬היא קבוצה בלתי תלויה ב‪ ,𝐺-‬אזי אין צלעות המחברות שני קודקודים ב‪ ,𝑆-‬כלומר‪ ,‬כל‬
‫צלעות הגרף נוגעות בלכל היותר קודקוד אחד מ‪ .𝑆-‬אזי הקבוצה 𝑆\𝑉 נוגעת בלפחות קודקוד אחד‬
‫מכל צלע בגרף‪ ,‬כלומר 𝑆\𝑉 היא כיסוי קודקודים‪.‬‬
‫● כיוון ב'‪ :‬נניח ש‪ 𝑉\𝑆-‬היא כיסוי קודקודים ב‪ ,𝐺-‬אזי כל צלע ב‪ 𝐺-‬היא בעלת לפחות קודקוד אחד‬
‫בקבוצה 𝑆\𝑉‪ .‬מכאן שאין צלעות שחלות על שני קודקודים מ‪ ,𝑆-‬כלומר 𝑆 היא קבוצה בלתי תלויה‪.‬‬
‫∎‬
‫משפט‪.𝐼𝑆 ∈ 𝑁𝑃𝐶 :‬‬

‫רעיון ההוכחה‪( :‬של הרדוקציה)‪ .‬נניח שקיים אלגוריתם יעיל (בזמן פולינומי) הפותר את בעיית הקבוצה הבלתי‬
‫תלויה‪ ,‬אפשר פשוט להשתמש בה כדי להכריע האם ל‪ 𝐺-‬יש כיסוי קודקודים בגודל לכל היותר 𝑘‪ ,‬על ידי השאלה‬
‫האם 𝐺 יש קבוצה ב"ת בגודל לפחות 𝑘 ‪.𝑛 −‬‬
‫הוכחה‪ :‬צריך להוכיח כי 𝑃𝑁 ∈ 𝑆𝐼 וגם 𝐻𝑃𝑁 ∈ 𝑆𝐼 ברדוקציה פולינומית 𝑆𝐼𝑃≤𝐶𝑉‪.‬‬
‫𝑃𝑁 ∈ 𝑆𝐼 הוכחנו כבר בפרק קודם‪ .‬נוכיח כי 𝐻𝑃𝑁 ∈ 𝑆𝐼 ברדוקציה פולינומית 𝑆𝐼𝑃≤𝐶𝑉‪.‬‬
‫(לכל צלע בגרף 𝐺‪ ,‬לפחות אחד מקודקודיו שייך ל‪.)𝑆-‬‬ ‫קלט‪< 𝐺, 𝑘 >∈ 𝑉𝐶 :‬‬
‫פלט‪( < 𝐺, 𝑛 − 𝑘 >∈ 𝐼𝑆 :‬לכל צלע בגרף 𝐺‪ ,‬יש לכל היותר קודקוד אחד ב‪.)𝑆-‬‬
‫הסבר‪ :‬אם קיימת ב‪ 𝐺-‬קבוצה כיסוי קודקודים בגודל 𝑘‪ ,‬אז קבוצה ב"ת ב‪ 𝐺-‬היא בגודל לפחות 𝑘 ‪.𝑛 −‬‬
‫הרדוקציה פולינומית‪ :‬כדי לחשב את 𝑓‪ ,‬הרדוקציה רק מחשבת את מספר קודקודי הגרף )= 𝑛( ומפחיתה מ‪𝑛-‬‬
‫ל‪ .𝑘-‬פעולות בזמן פולינומי‪.‬‬
‫תקפות הרדוקציה‪ :‬תקפות הרדוקציה נובעת מהלמה הבאה‪:‬‬
‫למה‪ :‬עבור גרף )𝐸 ‪ 𝐺 = (𝑉,‬קבוצת קודקודים )𝐺(𝑉 ⊆ 𝑆 היא בלתי תלויה ב‪ 𝐺-‬אם"ם 𝑆\𝑉 היא כיסוי‬
‫קודקודים של 𝐺‪.‬‬
‫∎‬
‫בעיית הקליקה היא ‪-NP‬שלמה‬

‫תזכורת‪ :‬קליקה‪ :𝐶𝑙𝑖𝑞𝑢𝑒 ,‬בהינתן גרף )𝐸 ‪ , 𝐺 = (𝑉,‬קליקה ב‪ 𝐺-‬היא תת קבוצה של קודקודים 𝑉 ⊆ 𝑆‬
‫המקיימת שכל זוג קודקודים ב‪ 𝑆-‬הם שכנים בגרף‪( .‬שיש צלע בין כל ‪ 2‬צמתים בקבוצה)‪.‬‬
‫}𝑘 𝑒𝑧𝑖𝑠 𝑓𝑜 𝑒𝑢𝑞𝑖𝑙𝑐 𝑎 𝑠𝑛𝑖𝑎𝑡𝑛𝑜𝑐 𝑡𝑎‪𝐶𝐿𝐼𝑄𝑈𝐸 = {< 𝐺, 𝑘 > |𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ‬‬
‫משפט‪.𝐶𝐿𝐼𝑄𝑈𝐸 ∈ 𝑁𝑃𝐶 :‬‬

‫הוכחה‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝐸𝑈𝑄𝐼𝐿𝐶 וגם 𝐻𝑃𝑁 ∈ 𝐸𝑈𝑄𝐼𝐿𝐶 בעזרת רדוקציה פולינומית 𝐸𝑈𝑄𝐼𝐿𝐶𝑃≤𝑆𝐼‪.‬‬
‫חלק א'‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝐸𝑈𝑄𝐼𝐿𝐶‪ ,‬הוכחנו בפרק הקודם‪.‬‬
‫חלק ב'‪ :‬נוכיח כי 𝐻𝑃𝑁 ∈ 𝐸𝑈𝑄𝐼𝐿𝐶 בעזרת רדוקציה פולינומית 𝐸𝑈𝑄𝐼𝐿𝐶𝑃≤𝑆𝐼‪ ,‬הוכחנו גם בפרק קודם‪.‬‬
‫מסקנה‪ 𝐶𝐿𝐼𝑄𝑈𝐸 :‬היא 𝑃𝑁‪-‬שלמה‪.‬‬
‫תרגיל ממבחן‬
‫יהי }‪𝐶𝑙𝑖𝑞𝑢𝑒𝐼𝑆 = {< 𝐺, 𝑘1, 𝑘2 > | 𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ 𝑎 𝐶𝑙𝑖𝑞𝑢𝑒 𝑜𝑓 𝑠𝑖𝑧𝑒 𝑘1 𝑂𝑅 𝑎𝑛 𝐼𝑆 𝑜𝑓 𝑠𝑖𝑧𝑒 𝑘2‬‬
‫סווגו את 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ל‪.𝑁𝑃𝐶/𝑁𝑃/𝑃-‬‬
‫פתרון‪ .𝐶𝑙𝑖𝑞𝑢𝑒𝐼𝑆 ∈ 𝑁𝑃𝐶 :‬צריך להראות 𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 וגם 𝐻𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶‪.‬‬
‫נוכיח כי 𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶‪ ,‬נציג הוכחה של חלק זה ב‪ 2-‬שיטות‪.‬‬
‫נבנה 𝑁 מ"ט א"ד פולינומית המכריעה את השפה 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶‪.‬‬ ‫‪.1‬‬
‫‪ .2‬נוכיח ביחס 𝐿𝑅‪.‬‬
‫שיטה ‪ - 1‬בניית מכונה‪ :‬המכונה 𝑁 על הקלט > ‪ < 𝐺, 𝑘1, 𝑘2‬תבצע‪:‬‬
‫‪ .1‬נחש קבוצת קודקודים ‪ 𝑆1‬בגודל‪ 𝑘1‬וקבוצת קודקודים ‪ 𝑆2‬בגודל ‪.𝑘2‬‬
‫‪ .2‬בדוק האם הקבוצה ‪ 𝑆1‬היא קליקה‪ ,‬אם כן ‪ -‬קבל‪.‬‬
‫‪ .3‬בדוק האם הקבוצה ‪ 𝑆2‬היא בלתי תלויה‪ ,‬אם כן ‪ -‬קבל‪.‬‬
‫‪ .4‬אחרת‪ ,‬דוחה‪.‬‬
‫שיטה ‪ - 1‬סיבוכיות זמן ריצה‪ :‬המכונה 𝑁 היא פולינומית‪ ,‬הניחוש חסום פולינומית )‪.2|𝑉(𝐺)| ≥ (𝑘1 + 𝑘2‬‬
‫‪2‬‬ ‫‪2‬‬
‫בנוסף‪ ,‬הבדיקה של ‪ 𝑆1‬לקליקה חסום ב‪ ,𝑂(𝑘1 )-‬הבדיקה של ‪ 𝑆2‬לב"ת חסום ב‪.𝑂(𝑘2 )-‬‬
‫סך הכל‪ ,‬פולינומי (ריבועי) בקלט‪.‬‬
‫שיטה ‪ - 1‬הוכחת נכונות הבניה‪:‬‬
‫● 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ∈> ‪ ← < 𝐺, 𝑘1, 𝑘2‬קיימת קליקה בגודל ‪ 𝑘1‬או קבוצה ב"ת בגודל ‪ ← 𝑘2‬קיים ניחוש כזה‬
‫והמכונה 𝑁 תנחש נכון ותקבל ← )𝑁(𝐿 ∈> ‪.< 𝐺, 𝑘1, 𝑘2‬‬
‫● 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ∉> ‪ ← < 𝐺, 𝑘1, 𝑘2‬לא קיימת קליקה בגודל ‪ 𝑘1‬ולא קבוצה ב"ת בגודל ‪ ← 𝑘2‬לכל ניחוש‪,‬‬
‫המכונה 𝑁 תדחה ← )𝑁(𝐿 ∉> ‪.< 𝐺, 𝑘1, 𝑘2‬‬
‫שיטה ‪ - 2‬הגדרת היחס‪ :‬נגדיר את היחס 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶𝑅‪ .‬עבור 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶𝑅 ∈ )𝑦 ‪ (𝑥,‬נגדיר את > ‪𝑥 =< 𝐺, 𝑘1, 𝑘2‬‬
‫| |‬ ‫| |‬
‫ונגדיר את העד‪ 𝑦 =< 𝑆1, 𝑆2 > :‬כאשר ‪. 𝑆1 = 𝑘1 , 𝑆2 = 𝑘2‬‬
‫שיטה ‪ - 2‬היחס חסום פולינומית‪ :‬העד 𝑦 חסום פולינומית ב‪.2|𝑉(𝐺)|-‬‬
‫שיטה ‪ - 2‬היחס ניתן להכרעה פולינומית‪ :‬המכונה המוודאת 𝑉 על קלט )> ‪ (< 𝐺, 𝑘1, 𝑘2 >, < 𝑆1, 𝑆2‬תוודא‪:‬‬
‫‪ .1‬האם ‪ 𝑆1‬קליקה‪ ,‬אם כן ‪ -‬קבל‪.‬‬
‫‪ .2‬האם ‪ 𝑆2‬ב"ת‪ ,‬אם כן ‪ -‬קבל‪.‬‬
‫‪ .3‬אחרת ‪ -‬דחה‪.‬‬
‫‪2‬‬
‫שיטה ‪ - 2‬המכונה המוודאת חסום פולינומי‪ :‬הבדיקה של ‪ 𝑆1‬לקליקה חסום ב‪ ,𝑂(𝑘1 )-‬הבדיקה של ‪ 𝑆2‬לב"ת‬
‫‪2‬‬
‫חסום ב‪ .𝑂(𝑘2 )-‬סך הכל‪ ,‬פולינומי (ריבועי) בקלט‪.‬‬
‫שיטה ‪ - 2‬נכונות הבניה של המכונה המוודאת‪:‬‬

‫● 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ∈> ‪ ← < 𝐺, 𝑘1, 𝑘2‬קיימת קליקה בגודל ‪ 𝑘1‬או קבוצה ב"ת בגודל ‪ ← 𝑘2‬המכונה‬
‫המוודאת 𝑉 תקבל ← 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶𝑅 ∈ )> ‪.(< 𝐺, 𝑘1, 𝑘2 >, < 𝑆1, 𝑆2‬‬
‫● 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ∉> ‪ ← < 𝐺, 𝑘1, 𝑘2‬לא קיימת קליקה בגודל ‪ 𝑘1‬ולא קבוצה ב"ת בגודל ‪ ← 𝑘2‬לכל עד‪,‬‬
‫המכונה המוודאת 𝑉 תדחה ← 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶𝑅 ∉ )> ‪.(< 𝐺, 𝑘1, 𝑘2 >, < 𝑆1, 𝑆2‬‬
‫סיכום שלב ‪ :1‬הוכחנו 𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ב‪ 2-‬שיטות‪ )1 :‬בניית מכונה א"ד‪ )2 .‬יחס 𝐿𝑅‪.‬‬
‫שלב ‪ :2‬נוכיח כעת 𝐻𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 בעזרת רדוקציה פולינומית 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶𝑃≤𝐸𝑈𝑄𝐼𝐿𝐶‪.‬‬

‫פונקצית הרדוקציה‪.𝑓(< 𝐺, 𝑘 >) = (< 𝐺', 𝑘1, 𝑘2 >) :‬‬
‫רעיון הרדוקציה‪ :‬ניקח גרף מ‪ ,𝐶𝐿𝐼𝑄𝑈𝐸-‬ונרצה לטפל רק בקליקה של 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶‪ .‬מאחר ותנאי השפה של‬
‫𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 הוא קליקה "או" קבוצה ב"ת‪ ,‬יתכן שנגיד ש‪ < 𝐺, 𝑘 >∉ 𝐶𝐿𝐼𝑄𝑈𝐸-‬ואז צריך שלא יהיה קליקה‬
‫בגרף '𝐺‪ ,‬אבל מי אמר לנו שאין שם במקרה קבוצה ב"ת?‪ .‬לכן‪ ,‬אנחנו נאלץ ב‪ 𝐺'-‬שתמיד לא תהיה לנו קבוצה‬
‫ב"ת‪ ,‬וזה בסדר‪ .‬איך נאלץ? נגדיר את ‪ 𝑘2‬להיות יותר ממספר הקודקודים בגרף '𝐺 ‪ -‬וזה לעולם לא יתקיים‪.‬‬
‫תיאור הרדוקציה‪ :‬בגרף '𝐺 נגדיר 𝑘 = ‪ .𝑘1‬כדי לוודא שאין קבוצה ב"ת בגודל ‪ ,𝑘2‬נגדיר ‪.𝑘2 = |𝑉(𝐺')| + 1‬‬
‫הפונקציה ניתנת לחישוב ומלאה‪ :‬מתקיים בזמן פולינומי כיוון שביצענו רק הגדרות (השמות)‪.‬‬
‫הפונקציה תקפה‪:‬‬
‫● 𝐸𝑈𝑄𝐼𝐿𝐶 ∈> 𝑘 ‪ ← < 𝐺,‬קיים בגרף 𝐺 קליקה בגודל 𝑘 ← קיים בגרף '𝐺 קליקה בגודל ‪← 𝑘1‬‬
‫𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ∈> ‪.< 𝐺', 𝑘1, 𝑘2‬‬
‫● 𝐸𝑈𝑄𝐼𝐿𝐶 ∉> 𝑘 ‪ ← < 𝐺,‬לא קיים בגרף 𝐺 קליקה בגודל 𝑘 ← לא קיים בגרף '𝐺 קליקה בגודל ‪,𝑘1‬‬
‫בנוסף‪ ,‬לא קיימת קבוצה ב"ת כי לא יתכן שקיימת קבוצה ב"ת בת ‪ |𝑉(𝐺)| + 1‬קודקודים ←‬
‫𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 ∉> ‪.< 𝐺', 𝑘1, 𝑘2‬‬
‫סיכום‪ :‬הוכחנו 𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 בעזרת בנית מ"ט א"ד פולינומית וגם בדרך אחרת עם יחס 𝐿𝑅‪.‬‬
‫בשלב השני‪ ,‬הוכחנו 𝐻𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶 בעזרת הרדוקציה הפולינומית 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶𝑃≤𝐸𝑈𝑄𝐼𝐿𝐶‪.‬‬
‫ומכאן 𝐶𝑃𝑁 ∈ 𝑆𝐼𝑒𝑢𝑞𝑖𝑙𝐶‪.‬‬
‫∎‬
‫טיפ למבחן ‪ -‬שימוש בגאדג'טים (‪)Gadgets‬‬

‫בהרצאות לא נתנו שם לשיטה הזאת אבל בעצם השתמשנו בה כמה פעמים‪ ,‬זו שיטה שיכולה לעזור במבחן‬
‫במיוחד בפתרון של בעיות חדשות או דומות‪ .‬גאדג'ט היא קבוצת קודקודים‪/‬צלעות שמייצגת גוף‪/‬חלק מתוך‬
‫פסוקית‪ .‬למשל‪ ,‬ברדוקציה שעשינו 𝐶𝑉𝑃≤𝑇𝐴𝑆‪ 3‬יצרנו ‪ 2‬גאדג'טים‪:‬‬
‫‪ .1‬קבוצה ‪ - 1‬הליטרלים‪.‬‬
‫‪ .2‬קבוצה ‪ - 2‬הפסוקיות (המשולשים)‪.‬‬
‫השליטה בגאדג'טים עזרה לנו לשלוט בעניין שאם קיימת השמה מספקת ב‪ ϕ-‬אז קיימת קבוצת כיסוי קודקודים‬
‫בגרף בגודל 𝑘‪ .‬נציג כעת את בעיית מסלול המילטון ונראה שהיא 𝑃𝑁‪-‬שלמה בעזרת רדוקציה עם שימוש‬
‫בגאדג'טים‪.‬‬
‫בעיית מסלול המילטון היא ‪-NP‬שלמה‬

‫תזכורת‪ :‬מסלול המילטון בגרף מכוון 𝐺 הוא מסלול פשוט (ללא מעגלים) שמבקר בכל צומת פעם אחת ויחידה‪.‬‬
‫}𝑡 𝑜𝑡 𝑠 𝑚𝑜𝑟𝑓 ‪𝐻𝐴𝑀𝑃𝐴𝑇𝐻 = {< 𝐺, 𝑠, 𝑡 > | 𝐺 𝑖𝑠 𝑎 𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ‬‬
‫משפט‪.𝐻𝐴𝑀𝑃𝐴𝑇𝐻 ∈ 𝑁𝑃𝐶 :‬‬

‫הוכחה‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 וגם 𝐻𝑃𝑁 ∈ 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 בעזרת רדוקציה פולינומית‬
‫𝐻𝑇𝐴𝑃𝑀𝐴𝐻𝑃≤𝑇𝐴𝑆‪.3‬‬
‫חלק א'‪ :‬הוכחנו כבר בפרק קודם כי 𝑃𝑁 ∈ 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 ‪.‬‬
‫חלק ב'‪ :‬נוכיח כי 𝐻𝑇𝐴𝑃𝑀𝐴𝐻𝑃≤𝑇𝐴𝑆‪.3‬‬
‫אם ‪ ϕ‬פסוק ספיק אז קיים מסלול אוילר בגרף 𝐺‪.‬‬
‫נשתמש בשני גאדג'טים‪:‬‬
‫● 𝑡 משתנים ‪ -‬לכל משתנה 𝑖𝑥 קיים גרף בצורת יהלום‬
‫שממשיך לגרף יהלום אחר של המשתנה ‪.𝑥𝑖+1‬‬
‫● 𝑘 פסוקיות ‪ -‬לכל פסוקית‪ ,‬קיים קודקוד בודד ללא שכנים‪.‬‬
‫תת הגרף הפנימי בכל יהלום (השרשרת) מכיל ‪ 3𝑘 + 3‬קודקודים‪:‬‬

‫‪ 3‬לכל פסוקית‪.‬‬ ‫●‬
‫● קודקוד כדי לבודד אותם מ‪ 2-‬קודקודי הליטרל‪.‬‬
‫● שני קודקודים נוספים לכל צד עבור הליטרלים 𝑖‾𝑥 ‪.𝑥𝑖,‬‬
‫טיפול בצלעות‪:‬‬
‫אם 𝑖𝑥 מופיע בפסוקית 𝑗𝑐‪ ,‬נוסיף ‪ 2‬צלעות מהקבוצה‬ ‫אם 𝑖𝑥 מופיע בפסוקית 𝑗𝑐‪ ,‬נוסיף ‪ 2‬צלעות מהקבוצה‬
‫ה‪-𝑗-‬ית בשרשרת לקודקוד הפסוקית ה‪ 𝑗-‬ביהלום‬ ‫ה‪-𝑗-‬ית בשרשרת לקודקוד הפסוקית ה‪ 𝑗-‬ביהלום‬
‫(המשתנה) ה‪ ,𝑥𝑖-‬אבל ברוורס‪.‬‬ ‫(המשתנה) ה‪.𝑥𝑖-‬‬
‫תקפות‪:‬‬
‫● 𝑇𝐴𝑆‪ ϕ ← < ϕ >∈ 3‬ספיק ← אם‬
‫נתעלם לרגע מקודקודי הפסוקיות‪ ,‬נשים‬
‫לב שביהלומים קיים מסלול המילטוני‪:‬‬
‫נתחיל מ‪ 𝑠-‬ונטייל לאורך כל יהלום עד‬
‫שנגיע ל‪ ← .𝑡-‬ביהלום ה‪ ,𝑖-‬הוא מטייל‬
‫משמאל לימין או מימין לשמאל‪ ,‬תלוי‬
‫בערך של 𝑖𝑥 (כלומר 𝐹‪ ← .)𝑇/‬קודקודי‬
‫הפסוקיות יכולים להשתלב במסלול בעזרת בניית ‪ 2‬הצלעות שסיפקנו להם מהיהלומים‪ ← .‬מצד אחד‪,‬‬
‫אם 𝑇 = 𝑖𝑥 ונמצא בפסוקית 𝑗𝑐‪ ,‬אז אפשר לעשות מסלול הלוך וחזור (אל הצומת 𝑗𝑐 וחזרה לשרשרת‬
‫בכיוון הנכון)‪ .‬מצד שני‪ ,‬אם 𝑇 = 𝑖‾𝑥 ונמצא בפסוקית 𝑗𝑐‪ ,‬אז אפשר לעשות מסלול הלוך וחזור (אל‬
‫הצומת 𝑗𝑐 וחזרה לשרשרת בכיוון הנכון) אבל בכיוון ההפוך‪< 𝐺 >∈ 𝐻𝐴𝑀𝑃𝐴𝑇𝐻 ← .‬‬
‫● 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 ∈> 𝐺 < ← קיים מסלול אוילר בגרף 𝐺 ← אם המסלול נורמלי‪ ,‬אז הוא מטייל מ‪𝑠-‬‬
‫בזיגזגים לאורך היהלומים ← קיימת השמה מספקת עבור ‪.< ϕ >∈ 3𝑆𝐴𝑇 ← .ϕ‬‬
‫∎‬
‫בעיית ‪ SUBSET-SUM‬היא ‪-NP‬שלמה‬

‫תזכורת‪ :‬הקלט הוא קבוצה 𝑆 של מספרים ומספר 𝑡‪ .‬השאלה‪ :‬האם יש ל‪ 𝑆-‬תת‪-‬קבוצה שהסכום שלה בדיוק 𝑡?‬
‫}𝑡 = 𝑖𝑦‪𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 = {< 𝑆, 𝑡 > | 𝑆 = {𝑥1,.., 𝑥𝑛}, ∃{𝑦1,.., 𝑦𝑘} ⊆ 𝑆, Σ‬‬
‫משפט‪.𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 ∈ 𝑁𝑃𝐶 :‬‬

‫הוכחה‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪ 𝑆𝑈𝐵𝑆𝐸𝑇 −‬וגם 𝐻𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪ 𝑆𝑈𝐵𝑆𝐸𝑇 −‬בעזרת רדוקציה פולינומית‬
‫𝑀𝑈𝑆 ‪.3𝑆𝐴𝑇≤𝑃𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫חלק א'‪ :‬הוכחנו כבר בפרק קודם כי 𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪. 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫חלק ב'‪ :‬נוכיח כי 𝑀𝑈𝑆 ‪.3𝑆𝐴𝑇≤𝑃𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫מפסוק 𝐹𝑁𝐶‪ ϕ ∈ 3‬נבנה קבוצת מספרים טבעיים 𝑆 ומספר טבעי 𝑡 באופן הבא‪:‬‬
‫● כל המספרים יהיו בייצוג עשרוני‪ ,‬כל המספרים יהיו באורך )𝑚 ‪( 𝑂(𝑛 +‬אם המספר יהיה קצר יותר אז‬
‫נרפד אותו באפסים)‪ .‬נסמן 𝑛 ‪ -‬מספר המשתנים ונסמן 𝑚 ‪ -‬מספר הפסוקיות‪.‬‬
‫● נייצר את המספרים בקבוצה 𝑆 כך שספרותיהם יהיו רק ‪.0, 1, 2‬‬
‫● כל ספרה במספרים שנייצר תייצג ערך 𝑇 לעמודה בה היא נמצאת‪.‬‬
‫● לכל משתנה 𝑖𝑥 בפסוק נייצר ‪ 2‬מספרים 𝑖𝑧 ‪.𝑦𝑖,‬‬
‫● לכל פסוקית 𝑗𝑐 נייצר ‪ 2‬מספרים 𝑗𝑔 ‪.ℎ𝑗,‬‬
‫● המספרים יווצרו על ידי הטבלה הבאה‪:‬‬
‫תיאור הטבלה ושיטתה‪:‬‬

‫● באגף הימני של המשתנים‪:‬‬
‫○ המשתנה 𝑇 = 𝑖𝑥 אם"ם בשורה 𝑖𝑦 ובעמודה 𝑖𝑥 יהיה ‪ .1‬ביתר השורה עבור יתר המשתנים יהיה ‪.0‬‬
‫○ המשתנה 𝐹 = 𝑖𝑥 אם"ם בשורה 𝑖𝑧 ובעמודה 𝑖𝑥 יהיה ‪ .1‬ביתר השורה עבור יתר המשתנים יהיה ‪.0‬‬
‫● באגף השמאלי של הפסוקיות‪:‬‬
‫○ בפסוקית 𝑖𝑐 קיים 𝑖𝑥 אם"ם בשורה 𝑖𝑦 ובעמודה 𝑖𝑐 יהיה ‪ .1‬ביתר השורה עבור יתר הפסוקיות יהיה ‪.0‬‬
‫○ בפסוקית 𝑖𝑐 קיים 𝑖‾𝑥 אם"ם בשורה 𝑖𝑧 ובעמודה 𝑖𝑥 יהיה ‪ .1‬ביתר השורה עבור יתר הפסוקיות יהיה ‪.0‬‬
‫באגף הימני של המשתנים‪ :‬נרפד ב‪.0-‬‬
‫באגף השמאלי של הפסוקיות‪ :‬בשורות 𝑗𝑔 ‪ ℎ𝑖,‬בעמודה ה‪ 𝑐𝑗-‬יהיה ‪ 1‬וביתר הפסוקיות יהיה ‪.0‬‬
‫בניית המספר ‪:t‬‬

‫● באגף הימני של המשתנים‪ :‬יהיה ‪1‬‬
‫בכל עמודה ‪ -‬זאת על מנת להבטיח‬
‫שלכל משתנה תהיה הצבה אחת‬
‫בדיוק שהיא ‪ 0‬או ‪.1‬‬
‫● באגף השמאלי של הפסוקיות‪ :‬יהיה ‪3‬‬
‫בכל עמודה‪ .‬בצורה זו לכל פסוק‪.‬‬
‫תרגיל ‪( 1‬עוד לא סיימנו להוכיח)‪ :‬איזו‬

‫ספרה תהיה במספר 𝑡 במקום של כל‬
‫פסוקית?‪ .‬תשובה‪.3 :‬‬
‫תרגיל ‪( 2‬עוד לא סיימנו להוכיח)‪ :‬בנו את‬

‫קבוצת המספרים 𝑆 ואת המספר 𝑡 המתאימים לפסוק הבא‪:‬‬
‫)‾𝑤 ∨ 𝑧 ∨ 𝑦( ∧ )𝑤 ∨ 𝑦 ∨ ‾𝑥( ∧ )‾𝑧 ∨ ‾𝑦 ∨ 𝑥(‬
‫תרגיל ‪( 3‬עוד לא סיימנו להוכיח)‪ :‬הוכיחו שהיא ניתנת לחישוב בזמן פולינומי‪ .‬הוכיחו שהרדוקציה תקפה‪.‬‬
‫פתרון ‪ :3‬יש לנו בדיוק 𝑚 ‪ 𝑛 +‬משתנים‪ ,‬כל אחד מהם בדיוק באורך 𝑚 ‪ .𝑛 +‬סה"כ )𝑚 × 𝑛(𝑂 ‪ -‬פולינומי‪.‬‬
‫מסקנה‪ 𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 :‬היא 𝑃𝑁‪-‬שלמה‪.‬‬
‫בעיות ‪-NP‬שלמות נוספות‬

‫‪ .1‬גרפים לא מכוונים שיש להם צביעה חוקית בשלושה צבעים נעשה ברדוקציה של 𝑇𝐴𝑆‪.3‬‬
‫‪ .2‬גרפים לא מכוונים שיש להם מסלול המילטון מ‪ 𝑠-‬ל‪ 𝑡-‬נעשה ברדוקציה על 𝐻𝑇𝐴𝑃𝑀𝐴𝐻‪.‬‬
‫‪ .3‬גרסה נוספת של מסלול המילטון‪:‬‬
‫}‪𝐻𝐴𝑀𝑃𝐴𝑇𝐻' = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ‬‬
‫‪ .4‬מעגל המילטון‪:‬‬
‫}𝑒𝑙𝑐𝑦𝑐 𝑛𝑎𝑖𝑛𝑜𝑡𝑙𝑖𝑚𝑎𝐻 𝑎 ‪𝐻𝐴𝑀𝐶𝑌𝐶𝐿𝐸 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎𝑛 𝑢𝑛𝑑𝑖𝑟𝑒𝑐𝑡𝑒𝑑 𝑔𝑟𝑎𝑝ℎ 𝑤𝑖𝑡ℎ‬‬
‫בעיית גרף ‪ 3‬צביע היא ‪-NP‬שלמה‬

‫הגדרה‪ :‬בתורת הגרפים‪ ,‬גרף 𝑛‪-‬צביע הוא גרף שאפשר לצבוע את הקודקודים‬
‫שלו ב‪ n-‬צבעים‪ ,‬כך ששני קודקודים סמוכים אינם צבועים באותו צבע‪ .‬עבור‬
‫גרף 𝐺 ‪ ,‬מסמנים ב‪ χ(𝐺)-‬את המספר הקטן ביותר של צבעים הדרוש לצביעת‬
‫הקודקודים שלו‪ .‬מספר זה נקרא מספר הצביעה (או המספר הכרומטי) של‬
‫הגרף‪.‬עבור ‪ , 𝑘 > 2‬ההכרעה האם 𝑘 = )𝐺(‪ χ‬היא בעיה ‪ NP‬שלמה‪ .‬לגרף יש‬
‫מספר כרומטי ‪ 2‬אם ורק אם הוא דו‪-‬צדדי‪ ,‬ותכונה זו ניתנת לזיהוי בזמן ליניארי במספר הקשתות‪.‬‬
‫משפט‪.3𝐶𝑂𝐿𝑂𝑅 ∈ 𝑁𝑃𝐶 :‬‬

‫הוכחה‪ :‬נוכיח כי 𝑃𝑁 ∈ 𝑅𝑂𝐿𝑂𝐶‪ 3‬וגם 𝐻𝑃𝑁 ∈ 𝑅𝑂𝐿𝑂𝐶‪ 3‬ברדוקציה פולינומית 𝑅𝑂𝐿𝑂𝐶‪.3𝑆𝐴𝑇≤𝑃3‬‬
‫הוכחנו כבר בפרק קודם ש‪ ,3𝐶𝑂𝐿𝑂𝑅 ∈ 𝑁𝑃 :‬בנינו מכונה א"ד פולינומית שמנחשת צבע עבור כל צומת בגרף‬
‫(צבע אחד מתוך ה‪ )3-‬ואז בודקת בכל צלע אם שני הקצוות שלו בעלות צבע שונה‪.‬‬
‫כעת נוכיח ברדוקציה פולינומית 𝑅𝑂𝐿𝑂𝐶‪ .3𝑆𝐴𝑇≤𝑃3‬בהינתן פסוק 𝐹𝑁𝐶‪ ,ϕ ∈ 3‬נרצה לבנות גרף שיהיה‬
‫‪-3‬צביע אם"ם הפסוק מסתפק‪ .‬הפסוק שנעסוק בו הוא )𝑛𝑥 ‪ ϕ(𝑥1,....,‬בעל 𝑚 פסוקיות‪.‬‬
‫הגרף )𝐸 ‪ 𝐺 = (𝑉,‬יבנה באופן הבא‪:‬‬
‫‪ .1‬ניצור ‪ 3‬קודקודים 𝐵 ‪ 𝑇, 𝐹,‬ונחבר אותם‪.‬‬
‫‪ .2‬לכל ליטרל בפסוק‪ ,‬ניצור קודקוד ונחבר אותו ל‪.𝐵-‬‬
‫‪ .3‬נחבר בין כל משתנה לשלילתו‪.‬‬
‫‪ .4‬לכל שלושה ליטרלים המהווים פסוקית‪ ,‬נוסיף 'תוספת' בעלת ‪ 6‬קודקודים ו‪ 13-‬צלעות‪.‬‬
‫סיבוכיות זמן הריצה‪ :‬גודל הקלט הוא )𝑛 ‪ ,𝑂(𝑚 +‬בגרף יש )𝑚 ‪ 𝑂(3 + 𝑛 + 3𝑚) = 𝑂(𝑛 +‬קודקודים ו‪-‬‬
‫)𝑚 ‪ 𝑂(3𝑛 + 13𝑛) = 𝑂(𝑛 +‬צלעות ולכן סה"כ פולינומי בגודל הקלט‪.‬‬
‫● נניח ש‪ ϕ-‬ספיק ונרצה להוכיח שהגרף הוא צביע‪ .‬לכל פסוקית יש לפחות ליטרל אחד חיובי‪ .‬ניקח ליטרל‬
‫אחד חיובי כזה ובהתאמה לאיור משמאל?‪ ,‬נצבע אותו בירוק‪ ,‬את הקודקוד תחתיו באדום ואת‬
‫הקודקוד תחתיו בכחול‪ .‬את יתר השורה העליונה נבצע באדום‪ .‬את יתר השורה האמצעית נצבע בכחול‪.‬‬
‫ואת יתר הקודקודים הנותרים בשורה התחתונה נצבע בהתאמה לאיור‪ .‬סה"כ לכל 'תוספת' של פסוקית‬
‫תהיה השמה מספקת‪ .‬ההשמות מכבדות זו את זה‪.‬‬
‫● נניח שישנו גרף בצורה הזו ונרצה לבנות ל‪ ϕ-‬השמה מספקת‪ .‬תחילה נשים לב שההשמות חוקיות‪ -‬לכל‬
‫ליטרל יהיה בדיוק ערך אחד )ירוק או אדום(‪ ,‬משום שהם מחוברים ל‪ . 𝐵 -‬בנוסף‪ ,‬לכל משתנה תהיה‬
‫השמה אחת בדיוק שהפוכה לשלילה שלו‪ -‬משום שבין כל משתנה ושלילתו יש צלע‪ .‬ניקח צביעה כלשהי‬
‫ונקבע השמה באופן הבא ‪ -‬כל ליטרל שבירוק יהיה 𝑇 ‪ .‬נותר להראות שכל פסוקית מסתפקת‪ .‬נניח‬
‫בשלילה שישנה פסוקית שלא מסתפקת‪ ,‬אם כך כל הקודקודי המייצגים את הליטרלים שלה הם‬
‫באדום‪ .‬אם כך‪ ,‬כל קודקודי האמצע הם כחולים בהכרח‪ ,‬משום שלכל אחד מהם שכן כחול ושכן ירוק‪.‬‬
‫סתירה‪.‬‬
‫סיכום מפת עולם לרדוקציות ‪-NP‬שלמות‬
‫תרגיל ‪ - 1‬הוכחת שפה ב‪ NPC-‬בעזרת הרכבת פונקציות רדוקציה ‪ -‬תרגול ‪7‬‬

‫נגדיר את השפה }𝑠𝑟𝑜𝑙𝑜𝑐 𝑘 ‪.𝐶𝑂𝐿𝑂𝑅 = {(< 𝐺 >, 𝑘)| 𝐺 𝑐𝑎𝑛 𝑏𝑒 𝑐𝑜𝑙𝑜𝑟𝑒𝑑 𝑤𝑖𝑡ℎ‬‬
‫הראו רדוקציה 𝑅𝑂𝐿𝑂𝐶𝑝≤𝑇𝐴𝑆 ‪.𝐶𝑁𝐹 −‬‬
‫הסבר‪ :‬אנחנו עושים רדוקציה 𝑅𝑂𝐿𝑂𝐶𝑝≤𝑇𝐴𝑆 ‪ ,𝐶𝑁𝐹 −‬נעזר ברדוקציות שכבר הוכחנו בקורס ככלי לפתרון‬
‫הבעיה שלנו‪ .‬נעביר לצורת 𝑇𝐴𝑆‪ 3‬בעזרת 𝑇𝐴𝑆 ‪ ,𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝3 − 𝐶𝑁𝐹 −‬לאחר מכן‪ ,‬נעביר לצורת‬
‫𝑅𝑂𝐿𝑂𝐶‪ 3‬בעזרת 𝑅𝑂𝐿𝑂𝐶‪ 3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝3‬ואז נבחר ‪ 𝑘 = 3‬שיתאים לבעיה 𝑅𝑂𝐿𝑂𝐶‪.‬‬
‫פונקצית הרדוקציה שלנו היא )‪ .𝑓(< ϕ >) = (𝑔(ℎ(ϕ)), 3‬כאשר > 𝐺 <= ))‪ 𝑔(ℎ(ϕ‬כלשהו‪.‬‬
‫נסמן ב‪ ℎ-‬את פונקצית הרדקוציה של 𝑇𝐴𝑆 ‪.𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝3 − 𝐶𝑁𝐹 −‬‬
‫נסמן ב‪ 𝑔-‬את פונקצית הרדקוציה של 𝑅𝑂𝐿𝑂𝐶‪.3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝3‬‬
‫פונקצית הרדוקציה‪.𝑓(< ϕ >) = (𝑔(ℎ(ϕ)), 3) :‬‬
‫● 𝑇𝐴𝑆 ‪ ,ℎ(< ϕ >) =< ϕ' >∈ 3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 ← < ϕ >∈ 𝐶𝑁𝐹 −‬מהתקפות של ‪← ℎ‬‬
‫𝑅𝑂𝐿𝑂𝐶‪ ,𝑔(ℎ(< ϕ >)) = 𝑔(< ϕ' >) =< 𝐺 >∈ 3‬מהתקפות של 𝑔 ←‬
‫𝑅𝑂𝐿𝑂𝐶 ∈ )‪.(𝑔(ℎ(< ϕ >)), 3‬‬
‫● 𝑅𝑂𝐿𝑂𝐶 ∈ )‪ ← 𝑔(ℎ(< ϕ >)) ∈ 3𝐶𝑂𝐿𝑂𝑅 ← (𝑔(ℎ(< ϕ >)), 3‬לפי התקפות של 𝑔 נקבל כי‬
‫𝑇𝐴𝑆 ‪ ← ℎ(< ϕ >) ∈ 3 − 𝐶𝑁𝐹 −‬לפי התקפות של ‪ ℎ‬נקבל כי 𝑇𝐴𝑆 ‪.< ϕ >∈ 𝐶𝑁𝐹 −‬‬
‫∎‬
‫תרגיל ‪ - 2‬מסלול המילטוני או קליקה ‪ -‬תרגול ‪7‬‬

‫נתונה השפה‪.𝐻𝑎𝑚𝑂𝑟𝐶𝑙𝑖𝑞𝑢𝑒 = {(𝐺, 𝑘)| 𝐺 ℎ𝑎𝑠 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ 𝑜𝑟 𝑎 𝐶𝑙𝑖𝑞𝑢𝑒 𝑜𝑓 𝑠𝑖𝑧𝑒 𝑘} :‬‬
‫האם 𝑃 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻 או 𝐶𝑃𝑁 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻?‬
‫פתרון‪.𝐻𝑎𝑚𝑂𝑟𝐶𝑙𝑖𝑞𝑢𝑒 ∈ 𝑁𝑃𝐶 :‬‬
‫תחילה נוכיח כי 𝑃𝑁 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻 בעזרת בנית מ"ט א"ד 𝑁 המכריעה את השפה 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻‬
‫בזמן פולינומי‪ .‬המכונה 𝑁 על קלט > 𝑘 ‪ < 𝐺,‬כאשר 𝐺 הוא גרף ו‪ 𝑘-‬מספר טבעי וחיובי‪ ,‬תבצע‪:‬‬
‫‪ .1‬נחש קבוצת קודקודים ‪ 𝑆1‬ונחש סדרת קודקודים ‪.𝑆2‬‬
‫‪ .2‬בדוק שכל קודקוד ב‪ 𝑆1-‬מופיע פעם אחת בלבד וגם בדוק שכל הקודקודים בגרף 𝐺 נמצאים ב‪𝑆2-‬‬
‫ומופיעים פעם אחת בלבד‪ .‬אם שתי הבדיקות נכשלו ‪ -‬דחה‪.‬‬
‫‪ .3‬עבור כל זוג קודקודים‪ 𝑣, 𝑢 ∈ 𝑆1‬כאשר 𝑣 ≠ 𝑢‪:‬‬
‫‪ .a‬בדוק בעזרת מטריצת שכנויות שקיימת צלע בין 𝑢 ל‪.𝑣-‬‬
‫‪ .4‬אם שלב ‪ 3‬הצליח‪ ,‬קבל‪.‬‬
‫‪ .5‬עבור כל קודקוד ‪ 𝑣𝑖 ∈ 𝑆2‬כאשר ]‪ 𝑖 ∈ [1, 𝑛 − 1‬בצע‪:‬‬
‫‪ .a‬בדוק שקיים צלע בינו לבין ‪ ,𝑣𝑖+1‬אחרת דחה‪.‬‬
‫‪ .b‬המשך לקודקוד הבא ‪.𝑣𝑖+1‬‬
‫‪ .6‬קבל‪.‬‬
‫| | | |‬
‫סיבוכיות זמן ריצה‪ :‬גודל הניחוש הוא )𝑛(𝑂 = ) ‪ .𝑂( 𝑆1 + 𝑆2‬בדיקת כפילויות בשימוש מטריצת שכנויות‬
‫‪2‬‬ ‫‪2‬‬ ‫‪2‬‬
‫) 𝑛(𝑂‪ .‬בדיקת הקליקה ) 𝑛(𝑂 ובדיקת המסלול ההמילטוני ) 𝑛(𝑂 (בעזרת מטריצת שכנויות) סה"כ פולינומי‪.‬‬
‫הוכחת נכונות הבניה‪:‬‬
‫● 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻 ∈> 𝑘 ‪ ← < 𝐺,‬קיים ב‪ 𝐺-‬קליקה בגודל 𝑘 או מסלול המילטוני ← קיים ניחוש של‬
‫קבוצת קודקודים ‪ 𝑆1‬המתארת קליקה או סדרת קודקודים ‪ 𝑆2‬המתארת מסלול המילטוני ← 𝑁 מנחש‬
‫נכון‪ ,‬מבצע בדיקה שכל הקודקודים ב‪ 𝑆1-‬מופיעים פעם אחת וגם שכל )𝐺(𝑉 נמצא ב‪ 𝑆2-‬ופעם אחת ‪:‬‬
‫←‬
‫○ בודק ב‪ 𝑆1-‬שכל זוג קודקודים קיימת צלע‪.‬‬
‫○ או שבודק ב‪ 𝑆2-‬שקיימת צלע בין כל ‪ 2‬קודקודים עוקבים בסדרה‪.‬‬
‫באחד מ‪ 2-‬המקרים 𝑁 מקבל ← )𝑁(𝐿 ∈> 𝑘 ‪.< 𝐺,‬‬
‫● 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻 ∉> 𝑘 ‪ ← < 𝐺,‬לא קיים ב‪ 𝐺-‬קליקה בגודל 𝑘 וגם לא מסלול המילטוני ←‬
‫לכל ניחוש של 𝑁‪:‬‬
‫○ קיים קודקוד המופיע לפחות פעמיים בקבוצה ‪.𝑆1‬‬
‫○ הקבוצה ‪ 𝑆2‬לא מכילה את כל הקודקודים ב‪.𝐺-‬‬
‫○ קיים קודקוד המופיע לפחות פעמיים בקבוצה ‪.𝑆2‬‬
‫○ בקבוצה ‪ 𝑆1‬קיימים זוג קודקודים שונים שאין ביניהם צלע‪.‬‬

‫○ בקבוצה ‪ 𝑆2‬קיימים זוג קודקודים עוקבים מהסדרה שאין ביניהם צלע‪.‬‬
‫כל אחת מהתרחישים האפשריים האלה 𝑁 דוחה‪.< 𝐺, 𝑘 >∉ 𝐿(𝑁) ← .‬‬
‫כעת נותר להוכיח כי 𝐻𝑃𝑁 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻‪ .‬נראה רדוקציה 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻𝑝≤𝐸𝑈𝑄𝐼𝐿𝐶‪.‬‬

‫פונקצית הרדוקציה‪.𝑓(< 𝐺, 𝑘 >) = (< 𝐺', 𝑘 >) :‬‬
‫הסבר‪ :‬אנחנו נרצה שאם ב‪ 𝐺-‬לא קיימת קליקה אז ב‪ 𝐺'-‬לא קיימת קליקה וגם לא קיים מסלול המילטוני‪.‬‬
‫כדי להבטיח את זה‪ ,‬נאלץ את '𝐺 לא להכיל אף פעם מסלול המילטוני ‪ -‬זאת בעזרת הוספת קודקוד חדש ובודד‬
‫לגרף '𝐺‪.‬‬
‫הפונקציה מלאה וניתנת לחישוב בזמן פולינומיאלי‪ :‬בניית '𝐺 על ידי העתקת גרף 𝐺 עם תוספת קודקוד בודד‬
‫אחד בזמן קבוע )‪.𝑂(1‬‬
‫● 𝐸𝑈𝑄𝐼𝐿𝐶 ∈> 𝑘 ‪ ← < 𝐺,‬קיים בגרף 𝐺 קליקה בגודל 𝑘 ← גרף '𝐺 הוא העתק של 𝐺 עם קודקוד‬
‫מבודד נוסף שלא פוגע בהגדרת הקליקה ← קיים ב‪ 𝐺'-‬קליקה בגודל 𝑘 ←‬
‫𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻 ∈> 𝑘 ‪.< 𝐺',‬‬
‫● 𝑒𝑢𝑞𝑖𝑙𝐶𝑟𝑂𝑚𝑎𝐻 ∈> 𝑘 ‪ ← < 𝐺',‬קיים בגרף '𝐺 קליקה בגודל 𝑘 או מסלול המילטוני← לא יתכן כי‬
‫קיים מסלול המילטוני כי קיים קודקוד מבודד ב‪ 𝐺'-‬ולכן קיים רק קליקה בגודל 𝑘 ← מאחר ו‪ 𝐺'-‬הוא‬
‫העתק של 𝐺 אך עם קודקוד מבודד נוסף‪ ,‬בהסרת הקודקוד הזה נקבל את 𝐺 ← קיים ל‪ 𝐺-‬קליקה‬
‫מגודל 𝑘 ← 𝐸𝑈𝑄𝐼𝐿𝐶 ∈> 𝑘 ‪.< 𝐺,‬‬
‫∎‬
‫תרגיל ‪ - 3‬מסלול המילטוני וגם קליקה ‪ -‬תרגול ‪7‬‬

‫נתונה השפה‪.𝐻𝑎𝑚𝐴𝑛𝑑𝐶𝑙𝑖𝑞𝑢𝑒 = {(𝐺, 𝑘)| 𝐺 ℎ𝑎𝑠 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ 𝑎𝑛𝑑 𝑎 𝐶𝑙𝑖𝑞𝑢𝑒 𝑜𝑓 𝑠𝑖𝑧𝑒 𝑘} :‬‬
‫האם 𝑃 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻 או 𝐶𝑃𝑁 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻?‬
‫פתרון‪.𝐻𝑎𝑚𝐴𝑛𝑑𝐶𝑙𝑖𝑞𝑢𝑒 ∈ 𝑁𝑃𝐶 :‬‬
‫נוכיח כי 𝑃𝑁 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻‪ .‬אותה הוכחה כמעט כמו תרגיל ‪ 2‬רק שנרצה ש‪ 2-‬הבדיקות עבור ‪ 𝑆1‬וגם ‪𝑆2‬‬
‫יעבדו‪ .‬נוכיח כי 𝐻𝑃𝑁 ∈ 𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻‪.‬‬
‫אבחנה‪ :‬קליקה 𝑆 בגודל ‪( 1‬הקודקוד עצמו) בגרף 𝐺 מחוברת לכל קודקוד אחר (עצמו) בקבוצה 𝑆‪.‬‬
‫נראה רדוקציה 𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻𝑝≤𝐻𝑇𝐴𝑃𝑀𝐴𝐻‪.‬‬
‫פונקצית הרדוקציה‪.𝑓(< 𝐺 >) = (< 𝐺 >, 1) :‬‬
‫● 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 ∈> 𝐺 < ← יש ב‪ 𝐺-‬מסלול המילטוני ← יש בגרף גם קליקה בגודל ‪← 1‬‬
‫𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻 ∈ )‪.(< 𝐺 >, 1‬‬
‫● 𝑒𝑢𝑞𝑖𝑙𝐶𝑑𝑛𝐴𝑚𝑎𝐻 ∈ )‪ ← (< 𝐺 >, 1‬יש ב‪ 𝐺-‬מסלול המילטוני וגם קליקה בגודל ‪← 1‬‬
‫𝐻𝑇𝐴𝑃𝑀𝐴𝐻 ∈> 𝐺 <‪.‬‬
‫∎‬
‫}𝑇 = )𝑗𝑥(‪𝐿log𝑛 = {ϕ| ϕ ℎ𝑎𝑠 𝑎 𝑠𝑎𝑡𝑖𝑠𝑓𝑦𝑖𝑛𝑔 𝑎𝑠𝑠𝑖𝑔𝑛𝑚𝑒𝑛𝑡 π, 𝑎𝑛𝑑 ∃𝑖 𝑠. 𝑡. ∀𝑗∉[𝑖+1,𝑖+2,...,𝑖+log𝑛]π‬‬
‫האם השפה ב‪ 𝑃-‬או ב‪?𝑁𝑃𝐶-‬‬
‫בשפת בני אנוש‪ :‬קיימת ל‪ ϕ-‬השמה מספקת‪ ,‬כך שכל המשתנים מקבלים 𝑇 חוץ מרצף של )𝑛(‪ log‬משתנים‬
‫שיכולים לקבל מה שבא להם 𝑇 או 𝐹‪.‬‬
‫)𝑛(‪log2‬‬
‫‪ 2‬אופציות‪ ,‬כי‬ ‫הסבר לפתרון‪ :‬אם יש לנו )𝑛(‪ log2‬משתנים שאפשר לשחק איתם איך שבא לנו‪ ,‬אז יש לנו‬
‫לכל אחד מה‪-log2(𝑛)-‬ים יש ‪ 2‬אפשרויות‪ .{𝑇, 𝐹} :‬בדרך כלל אמרנו שאנחנו לא יכולים לבדוק השמה מספקת‬
‫)𝑛(‪log2‬‬ ‫𝑛‬
‫‪ 2‬אופציות‪ ,‬ולפי חוקי לוג‬ ‫כי יש לנו לעבור על ‪ 2‬אופציות שזה אקספוננציאלי‪ ,‬אבל עכשיו יש לנו‬
‫)𝑛(𝑎‪log‬‬
‫𝑎 כלומר יש לנו 𝑛 אופציות וזה אכן פולינומי!‪ .‬לכן‪.𝐿log𝑛 ∈ 𝑃 ,‬‬ ‫𝑛=‬
‫פתרון‪ .𝐿log𝑛 ∈ 𝑃 :‬נבנה מ"ט דטרמיניסטית מכריעה עבור 𝑛‪.𝐿log‬‬
‫𝑀 על קלט ‪ ϕ‬תבצע‪:‬‬
‫● עבור )𝑛(‪: 0 ≤ 𝑖 ≤ 𝑛 − log‬‬
‫○ עבור כל השמה של המשתנים בסדר רציף )𝑛(‪:𝑥𝑖+1, 𝑥𝑖+2,..., 𝑥𝑖+log‬‬
‫■ אם ההשמה הנוכחית ‪ +‬כל שאר המשתנים קיבלו 𝑇 ‪ -‬קבל‪.‬‬
‫● דחה‪.‬‬
‫‪ ← 2‬סה"כ נבדוק )𝑛 · 𝑛(𝑂‬ ‫סיבוכיות זמן ריצה‪ :‬עבור כל 𝑖‪ ,‬מספר ההשמות האפשריות הוא 𝑛 =‬
‫‪3‬‬
‫השמות ← בדיקה של השמה אחת )𝑛(𝑂 ← זמן הריצה של המכונה הוא ) 𝑛(𝑂 ‪ -‬פולינומי‪.‬‬
‫נכונות הבניה‪ :‬נובעת ישירות מהבניה‪.‬‬
‫∎‬
‫תרגיל ‪ - EXACT-SUBSET-SUM - 5‬תרגול ‪7‬‬

‫תזכורת‪𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 = {< 𝑆, 𝑡 > | 𝑆 = {𝑥1,.., 𝑥𝑛}, ∃{𝑦1,.., 𝑦𝑘} ⊆ {𝑥1,..., 𝑥𝑛} 𝑠. 𝑡. Σ𝑦𝑖 = 𝑡} :‬‬
‫הוכחנו כי 𝐶𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪.𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫הגדרה‪𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 = {(𝑥1,.., 𝑥𝑛), 𝑘, 𝑚 | ∃𝐼 ⊆ [𝑛] 𝑠. 𝑡. Σ𝑖∈𝐼𝑥𝑖 = 𝑘 ∧ |𝐼| = 𝑚} :‬‬

‫בעברית‪ :‬בהינתן קבוצת מספרים )𝑛𝑥 ‪ ,𝑆 = (𝑥1,...,‬ומספרים טבעיים 𝑚 ‪ .𝑘,‬קיימת תת קבוצה 𝑆 ⊆ 𝑉 כך‬
‫שסכומה הוא 𝑘 וגם 𝑚 = |𝑉|‪.‬‬
‫תרגיל‪ :‬הוכיחו כי 𝐶𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪.𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬

‫פתרון‪ :‬תחילה נוכיח כי 𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪.𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫נבנה מ"ט א"ד 𝑁 המכריעה את השפה 𝑀𝑈𝑆 ‪.𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫המכונה 𝑁 על קלט 𝑚 ‪ (𝑥1,.., 𝑥𝑛), 𝑘,‬כאשר )𝑛𝑥 ‪ (𝑥1,..,‬היא קבוצת מספרים וגם 𝑚 ‪ 𝑘,‬מספרים טבעיים‪ ,‬תבצע‪:‬‬
‫‪ .1‬נחש קבוצה 𝑉 של 𝑚 מספרים‪.‬‬
‫‪ .2‬בדוק שכל המספרים ב‪ 𝑉-‬נמצאים ב‪ - ,(𝑥1,.., 𝑥𝑛)-‬אחרת‪ ,‬דחה‪.‬‬
‫‪ .3‬בדוק שסכום הקבוצה 𝑉 הוא 𝑘 ‪ -‬אחרת‪ ,‬דחה‪.‬‬
‫‪ .4‬קבל‪.‬‬
‫‪2‬‬
‫המכונה ניתנת לחישוב בזמן פולינומי‪ :‬גודל הניחוש )𝑚(𝑂‪ ,‬בדיקת קיימות ) 𝑛(𝑂‪ ,‬בדיקת סכימה )𝑚(𝑂‪.‬‬
‫‪2‬‬
‫סה"כ ) 𝑛(𝑂 ‪ -‬פולינומי‪.‬‬
‫● 𝑀𝑈𝑆 ‪ ← ((𝑥1,.., 𝑥𝑛), 𝑘, 𝑚) ∈ 𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬קיימת תת קבוצה )𝑛𝑥 ‪𝑉 ⊆ 𝑆 = (𝑥1,..,‬‬
‫כך שסכומה הוא 𝑘 וגם 𝑚 = |𝑉| ← קיים ניחוש של תת קבוצה 𝑉 סכומה הוא 𝑘 וגודלה הוא 𝑚 ← 𝑁‬
‫תנחש נכון את הקבוצה 𝑉‪ ,‬תבדוק שכל המספרים ב‪ 𝑉-‬נמצאים גם ב‪ ← 𝑆-‬תבדוק שסכום הקבוצה 𝑉‬
‫הוא 𝑘 ← 𝑁 תצליח בכל הבדיקות ותקבל ← )𝑁(𝐿 ∈ )𝑚 ‪.((𝑥1,.., 𝑥𝑛), 𝑘,‬‬
‫● 𝑀𝑈𝑆 ‪ ← ((𝑥1,.., 𝑥𝑛), 𝑘, 𝑚) ∉ 𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬לא קיימת תת קבוצה‬
‫)𝑛𝑥 ‪ 𝑉 ⊆ 𝑆 = (𝑥1,..,‬כך שסכומה הוא 𝑘 וגם 𝑚 = |𝑉| ← לכל ניחוש של 𝑉‪ ,‬המכונה 𝑁 תבדוק‪:‬‬
‫○ שכל המספרים ב‪ 𝑉-‬נמצאים גם ב‪𝑆-‬‬
‫○ תבדוק שסכום הקבוצה 𝑉 הוא 𝑘‬
‫← 𝑁 תדחה באחת הבדיקות לעיל ← )𝑁(𝐿 ∉ )𝑚 ‪.((𝑥1,.., 𝑥𝑛), 𝑘,‬‬
‫כעת נותר להוכיח כי 𝐻𝑃𝑁 ∈ 𝑀𝑈𝑆 ‪.𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫נראה רדוקציה 𝑀𝑈𝑆 ‪.𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀≤𝑝𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫פונקצית הרדוקציה‪.𝑓(< (𝑥1,...., 𝑥𝑛), 𝑘 >) = (< (𝑥1,...., 𝑥𝑛, 0, 0,...., 0, 0), 𝑘, 𝑛 >) :‬‬
‫הסבר‪ :‬אנחנו נרפד 𝑛 אפסים בקבוצה הימנית‪.‬‬
‫● 𝑀𝑈𝑆 ‪ ← < (𝑥1,...., 𝑥𝑛), 𝑘 >∈ 𝑆𝑈𝐵𝑆𝐸𝑇 −‬יש תת קבוצה המסתכמת ל‪ ,𝑘-‬בגודל 𝑟 כך ש‪𝑟 ≤ 𝑛 :‬‬
‫← אם נוסיף לקבוצה 𝑟 ‪ 𝑛 −‬אפסים‪ ,‬נקבל קבוצה שעדיין מסתכמת ל‪ 𝑘-‬וגודלה הוא 𝑛‪← .‬‬
‫𝑀𝑈𝑆 ‪.< (𝑥1,...., 𝑥𝑛, 0, 0,...., 0, 0), 𝑘, 𝑛 >∈ 𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬‬
‫● 𝑀𝑈𝑆 ‪ ← < (𝑥1,...., 𝑥𝑛, 0, 0,...., 0, 0), 𝑘, 𝑛 >∈ 𝐸𝑋𝐴𝐶𝑇 − 𝑆𝑈𝐵𝑆𝐸𝑇 −‬יש תת קבוצה‬
‫המסתכמת ל‪ 𝑘-‬וגודלה הוא 𝑛 ← אותה קבוצה בלי האפסים עדיין מסתכמת ל‪ ← 𝑘-‬זו תהיה תת‬
‫הקבוצה )𝑛𝑥 ‪. < (𝑥1,...., 𝑥𝑛), 𝑘 >∈ 𝑆𝑈𝐵𝑆𝐸𝑇 − 𝑆𝑈𝑀 ← (𝑥1,..,‬‬
‫∎‬

‫נגדיר שפה‪:‬‬
‫‪𝐿1/8 = {ϕ| ϕ 𝑖𝑠 3𝐶𝑁𝐹 𝑎𝑛𝑑 ∃ 𝑎 𝑠𝑎𝑡𝑖𝑠𝑓𝑦𝑖𝑛𝑔 𝑎𝑠𝑠𝑖𝑔𝑛𝑚𝑒𝑛𝑡 𝑡𝑜 ϕ,‬‬
‫‪1‬‬
‫𝑡𝑠𝑎𝑒𝑙 𝑡𝑎 𝑑𝑛𝑎‬ ‫‪8‬‬
‫}𝑔𝑛𝑖𝑦𝑓𝑠𝑖𝑡𝑎𝑠 𝑡𝑜𝑛 𝑒𝑟𝑎 𝑠𝑡𝑛𝑒𝑚𝑛𝑔𝑖𝑠𝑠𝑎 𝑒𝑙𝑏𝑖𝑠𝑠𝑜𝑝 𝑒‪𝑜𝑓 𝑡ℎ‬‬
‫הוכיחו ש‪.𝐿1/8 ∈ 𝑁𝑃𝐻 :‬‬
‫הוכחה‪ :‬נוכיח ברדוקציה ‪.3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝𝐿1/8‬‬
‫הסבר‪ :‬עד עכשיו תמיד בשאלות עם ‪ ϕ‬היינו לוקחים את הפסוק הקיים‪ ,‬ומוסיפים לו עוד פסוקית ב‪( 𝐴𝑁𝐷-‬או‬
‫‪1‬‬
‫מההשמות שלנו יהיו לא מספקות‪,‬‬ ‫‪8‬‬
‫כמה כאלה) שתעזור לנו להמיר לבעיה הנוכחית‪ .‬אנחנו נרצה שלפחות‬
‫לכן נרצה שהפסוקית החדשה תשלוט בקיום הדרישה הזאת‪ .‬לפסוקית הנוכחית‪ ,‬נוסיף פסוקית חדשה‪:‬‬
‫‪3‬‬
‫)𝑧 ∨ 𝑦 ∨ 𝑥( ∧ ‪ .ϕ‬נשים לב שקיימות בפסוקית החדשה ‪ 2 = 8‬השמות אפשריות‪ ,‬מתוכן קיימת השמה‬
‫‪1‬‬
‫מתוך ההשמות האפשריות של הפסוקית החדשה הם לא‬ ‫‪8‬‬
‫אחת שהיא לא מספקת‪ .(𝐹 ∨ 𝐹 ∨ 𝐹) :‬כלומר‪,‬‬
‫‪1‬‬
‫השמות לא מספקות‪ ,‬כי אם קיימת השמה מספקת בפסוקית החדשה‪ ,‬עדיין‬ ‫‪8‬‬
‫מספקות‪ .‬מכאן קיימות לפחות‬
‫‪1‬‬
‫ייתכן כי ב‪ ϕ-‬ההשמה תהיה לא מספקת ולכן זה "לפחות" ‪. 8‬‬
‫פונקצית הרדוקציה‪ .𝑓(ϕ) = ϕ ∧ (𝑥 ∨ 𝑦 ∨ 𝑧) :‬כאשר 𝑧 ‪ 𝑥, 𝑦,‬הם משתנים חדשים‪.‬‬
‫תקפות הפונקציה‪:‬‬
‫● 𝑇𝐴𝑆 ‪ ← ϕ ∈ 3 − 𝐶𝑁𝐹 −‬קיימת השמה מספקת ל‪ ← ϕ-‬יש השמה מספקת גם ל‪-‬‬
‫)𝑧 ∨ 𝑦 ∨ 𝑥( ∧ ‪ ← ϕ‬נשים לב כי לכל השמה ‪ π‬של ‪ ,ϕ‬אם נרחיב אותה ל‪ π · 𝐹𝐹𝐹-‬אז נקבל‬
‫השמה לא מספקת ← מכיוון של‪ 𝑥, 𝑦, 𝑧-‬יש שמונה השמות אפשריות‪ ,‬שמינית מכל ההשמות הם לא‬
‫מספקות ← ‪.ϕ ∧ (𝑥 ∨ 𝑦 ∨ 𝑧) ∈ 𝐿1/8‬‬
‫● ‪ ← ϕ ∧ (𝑥 ∨ 𝑦 ∨ 𝑧) ∈ 𝐿1/8‬קיימת השמה מספקת ל‪ ← ϕ ∧ (𝑥 ∨ 𝑦 ∨ 𝑧)-‬יש השמה מספקת‬
‫ל‪.ϕ ∈ 3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 ← ϕ-‬‬
‫∎‬
‫תרגיל ‪ - NAE-K-CNF-SAT - 7‬תרגול ‪7‬‬

‫הגדרה‪ :‬השפה 𝑇𝐴𝑆 ‪( 𝑁𝐴𝐸 − 𝐾 − 𝐶𝑁𝐹 −‬כאשר 𝑙𝑎𝑢𝑞𝐸 𝑙𝑙𝐴 𝑡𝑜𝑁 = 𝐸𝐴𝑁) זוהי שפה של פסוקיות‬
‫𝐹𝑁𝐶 ‪ ,𝑘 −‬שיש להן השמה מספקת‪ ,‬אבל בכל פסוקית יש ליטרל שמקבל 𝐹‪.‬‬
‫דוגמה‪ :‬נתון הפסוק )‾𝑧 ∨ ‾𝑦 ∨ 𝑥( ∧ )𝑧 ∨ 𝑦 ∨ 𝑥( = ‪.ϕ‬‬
‫נגדיר השמות‪:‬‬
‫‪ .1‬ההשמה )𝑇 ‪.π1 = (𝑥, 𝑦, 𝑧) = (𝑇, 𝑇,‬‬
‫‪ .2‬ההשמה )𝐹 ‪.π2 = (𝑥, 𝑦, 𝑧) = (𝑇, 𝑇,‬‬
‫נשים לב כי ‪ π1‬היא השמה מספקת‪ ,‬אבל לא 𝐸𝐴𝑁‪ .‬מצד שני‪ ,‬ההשמה ‪ π2‬היא מספקת וגם 𝐸𝐴𝑁‪.‬‬
‫תרגיל‪ :‬הוכיח ש‪.𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 ∈ 𝑁𝑃𝐶 :‬‬

‫פתרון‪ :‬תחילה נוכיח כי 𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪.𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬‬
‫נבנה מ"ט א"ד 𝑁 שתכריע את השפה 𝑇𝐴𝑆 ‪.𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬‬
‫𝑁 על קלט > ‪ < ϕ‬כאשר ‪ ϕ‬הוא פסוק‪ ,‬תבצע‪:‬‬
‫‪ .1‬תנחש השמה ‪.π‬‬
‫‪ .2‬בדוק השמה ‪ π‬על ‪:ϕ‬‬
‫‪ .a‬לכל פסוקית ‪ 𝑝 ∈ ϕ‬בצע השמה ‪ π‬ובדוק שאכן קיים ליטרל אחד שהוא 𝐹 ‪ -‬אחרת‪ ,‬דחה‪.‬‬
‫‪ .3‬אם ‪ π‬מספקת את ‪ ϕ‬אז קבל‪ .‬אחרת ‪ -‬דחה‪.‬‬
‫המכונה ניתנת לחישוב בזמן פולינומי‪ :‬גודל הניחוש )|‪ ,𝑂(|π‬בדיקת השמה היא )|‪ 𝑂(|ϕ‬ולכן פולינומי‪.‬‬
‫נכונות הבנייה‪:‬‬
‫● 𝑇𝐴𝑆 ‪ ← < ϕ >∈ 𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬קיימת השמה מספקת ‪ π‬כך שלכל פסוקית ב‪ ϕ-‬קיים‬
‫ליטרל שהוא 𝐹 ← קיים ניחוש של השמה ‪ π‬זו ש‪ 𝑁-‬תנחש‪ ,‬תבדוק אותה על ‪ ,ϕ‬תבדוק שאכן בכל‬
‫פסוקית קיים ליטרל שהוא 𝐹 ← ‪ π‬תצליח בבדיקה של 𝑁 ותקבל ← )𝑁(𝐿 ∈> ‪.< ϕ‬‬
‫𝑇𝐴𝑆 ‪ ← < ϕ >∉ 𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬לא קיימת השמה מספקת ‪ π‬כך שלכל פסוקית ב‪ϕ-‬‬ ‫●‬
‫קיים ליטרל שהוא 𝐹 ← לכל ניחוש של השמה ‪ π‬ש‪ 𝑁-‬תנחש‪ ,‬היא תבדוק אותה על ‪:ϕ‬‬
‫○ תבדוק שאכן בכל פסוקית קיים ליטרל שהוא 𝐹 ‪.‬‬
‫○ תבדוק שההשמה ‪ π‬מספקת את ‪.ϕ‬‬
‫לפחות אחד מהתרחישים לעיל נכשלו בבדיקה של 𝑁 ולכן היא תדחה ← )𝑁(𝐿 ∉> ‪.< ϕ‬‬
‫כעת נותר להראות כי 𝐻𝑃𝑁 ∈ 𝑇𝐴𝑆 ‪ 𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬על ידי שתי רדוקציות‪:‬‬
‫𝑇𝐴𝑆 ‪3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬‬
‫רדוקציה ראשונה‪.3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 :‬‬

‫נגדיר פונקציה כלשהי 𝑔 שמקבלת פסוקית )𝑧 ∨ 𝑦 ∨ 𝑥( = 𝑖‪ φ‬מ‪ ϕ-‬ומרחיבה אותה במשנה החדש 𝑤‪.‬‬
‫כלומר‪ :‬לכל פסוקית 𝑖‪ ,φ‬נגדיר משתנה חדש 𝑤 בצורה הבאה‪.𝑔(𝑥 ∨ 𝑦 ∨ 𝑧) = (𝑥 ∨ 𝑦 ∨ 𝑧 ∨ 𝑤) :‬‬
‫אבחנה‪ :‬אם השמה ‪ π‬היא 𝐸𝐴𝑁 ומספקת אז גם ‾‬
‫‪ π‬היא 𝐸𝐴𝑁 ומספקת‪.‬‬
‫פונקצית הרדוקציה‪ 𝑓(ϕ) = ϕ' :‬כך ש‪:‬‬
‫𝑚‪● ϕ = φ1 ∧ φ2 ∧... ∧ φ‬‬
‫)𝑚‪● ϕ' = 𝑔(φ1) ∧ 𝑔(φ2) ∧... ∧ 𝑔(φ‬‬
‫הפונקציה ניתנת לחישוב בזמן פולינומי‪ :‬להוסיף כמות קבועה של משתנה חדש )‪.𝑂(1‬‬
‫● 𝑇𝐴𝑆 ‪ ← ϕ ∈ 3 − 𝐶𝑁𝐹 −‬קיימת השמה מספקת ‪ π‬ל‪ ← ϕ-‬ההשמה 𝑤 · ‪ π‬כך ש‪ 𝑤 = 𝐹 :‬היא‬
‫𝐸𝐴𝑁 וגם מספקת ← 𝑇𝐴𝑆 ‪.ϕ' ∈ 𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 −‬‬
‫● 𝑇𝐴𝑆 ‪ ← ϕ' ∈ 𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 −‬קיימת השמה מספקת ‪ π‬וגם 𝐸𝐴𝑁 ← נחלק למקרים‪:‬‬
‫○ אם 𝐹 = )𝑤(‪ ,π‬בכל פסוקית יש משתנה "מהמקוריים" שקיבל 𝑇 ולכן ההשמה מספקת גם‬
‫את ‪. ϕ‬‬
‫○ אם 𝑇 = )𝑤(‪ ,π‬אז ניקח את ההופכה שלה ‾‬
‫‪ ,π‬ולפי האבחנה שהצגנו‪ ,‬גם ההשמה הזאת‬
‫מספקת את '‪ϕ‬‬
‫← 𝑇𝐴𝑆 ‪.ϕ ∈ 3 − 𝐶𝑁𝐹 −‬‬
‫רדוקציה שניה‪.𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 − 𝑆𝐴𝑇 :‬‬

‫נפעל בדומה להרחבות שעשינו לרדוקציה של 𝑇𝐴𝑆 ‪.𝐶𝑁𝐹 − 𝑆𝐴𝑇≤𝑝3 − 𝐶𝑁𝐹 −‬‬
‫נגדיר פונקציה כלשהי 𝑔 שמקבלת פסוקית )‪ φ𝑖 = (𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4‬מ‪ ϕ-‬ומפרקת אותה בעזרת המשנה‬
‫החדש 𝑤‪ ,‬לצורה של 𝐹𝑁𝐶‪ .3‬כלומר‪ :‬לכל פסוקית 𝑖‪ ,φ‬נגדיר משתנה חדש 𝑤 בצורה הבאה‪:‬‬
‫)‪𝑔(𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4) = (𝑥1 ∨ 𝑥2 ∨ 𝑤𝑖) ∧ (𝑤‾ 𝑖 ∨ 𝑥3 ∨ 𝑥4‬‬

‫פונקצית הרדוקציה‪ 𝑓(ϕ) = ϕ' :‬כך ש‪:‬‬
‫𝑚‪● ϕ = φ1 ∧ φ2 ∧... ∧ φ‬‬
‫)𝑚‪● ϕ' = 𝑔(φ1) ∧ 𝑔(φ2) ∧... ∧ 𝑔(φ‬‬
‫הפונקציה ניתנת לחישוב בזמן פולינומי‪ :‬להוסיף כמות קבועה של משתנה חדש )‪ 𝑂(1‬ולפצל לפסוקיות‪.‬‬
‫● 𝑇𝐴𝑆 ‪ ← ϕ ∈ 𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 −‬קיימת השמה 𝐸𝐴𝑁 מספקת ל‪ ← ϕ-‬לכל פסוקית‬
‫)‪ φ𝑖 = (𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4‬נבדוק‪:‬‬
‫○ אם ‪ 𝑥1 ≠ 𝑥2‬אז נבחר ‪.𝑤𝑖 = 𝑥3‬‬
‫○ אם ‪ 𝑥1 = 𝑥2‬אז נבחר ‪.𝑤𝑖 = 𝑥2‬‬
‫← בכל מקרה‪ ,‬נקבל השמה 𝐸𝐴𝑁 מספקת ל‪← (𝑥1 ∨ 𝑥2 ∨ 𝑤𝑖) ∧ (𝑤‾ 𝑖 ∨ 𝑥3 ∨ 𝑥4)-‬‬
‫𝑇𝐴𝑆 ‪.ϕ' ∈ 𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬‬
‫● 𝑇𝐴𝑆 ‪ ← ϕ' ∈ 𝑁𝐴𝐸 − 3 − 𝐶𝑁𝐹 −‬קיימת השמה 𝐸𝐴𝑁 מספקת לכל פסוקית‬
‫)‪ ← (𝑥1 ∨ 𝑥2 ∨ 𝑤𝑖) ∧ (𝑤‾ 𝑖 ∨ 𝑥3 ∨ 𝑥4‬בה"כ ניתן להניח ש‪ ← 𝑤𝑖 = 𝑇 :‬לכן ‪ 𝑥1‬או ‪ 𝑥2‬קיבלו 𝐹 ←‬
‫לכן 𝐹 = 𝑖 ‾𝑤 ← וגם ‪ 𝑥3‬או ‪ 𝑥4‬קיבלו 𝑇 ← ההשמה 𝐸𝐴𝑁 מספקת את )‪← (𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4‬‬
‫𝑇𝐴𝑆 ‪.ϕ ∈ 𝑁𝐴𝐸 − 4 − 𝐶𝑁𝐹 −‬‬
‫∎‬
‫דוגמה פרקטית להסבר תקיפות כיוון ‪:1‬‬

‫● אם )𝐹 ∨ 𝑇 ∨ 𝑇 ∨ 𝑇( = )‪ φ𝑖 = (𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4‬אז מאחר ו‪ 𝑥1 = 𝑥2-‬נבחר‬
‫𝐹 = ‾𝑇 = ‪ 𝑤𝑖 = 𝑥‾2‬ונקבל‪.𝑔(𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4) = (𝑇 ∨ 𝑇 ∨ 𝐹) ∧ (𝑇 ∨ 𝑇 ∨ 𝐹) :‬‬

‫● אם )𝑇 ∨ 𝑇 ∨ 𝐹 ∨ 𝑇( = )‪ φ𝑖 = (𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4‬אז מאחר ו‪ 𝑥1 ≠ 𝑥2-‬נבחר ‪𝑤𝑖 = 𝑥3‬‬
‫ונקבל‪.𝑔(𝑥1 ∨ 𝑥2 ∨ 𝑥3 ∨ 𝑥4) = (𝑇 ∨ 𝐹 ∨ 𝑇) ∧ (𝐹 ∨ 𝑇 ∨ 𝑇) :‬‬
‫תרגיל ‪( PLANAR COLOR - 8‬גרף מישורי צביע) ‪ -‬תרגול ‪7‬‬

‫לפני שנגיע לרדוקציה הבאה‪ ,‬נתבונן בגרף 𝑊 משמאל‪:‬‬
‫הגדרה‪ :‬גרף מישורי הוא גרף שניתן לצייר במישור מבלי שהקשתות‬
‫תחתוכנה זו את זו (חוץ מאשר בצמתי הגרף)‪.‬‬
‫תכונה ‪ :1‬בכל ‪-3‬צביעה חוקית של 𝑊‪ ,‬הצמתים 𝑏 ‪ 𝑎,‬יקבלו את אותו‬
‫הצבע‪ ,‬וגם הצמתים 𝑑 ‪ 𝑐,‬את אותו הצבע‪.‬‬
‫תכונה ‪ :2‬בכל צביעה של צמתים 𝑑 ‪ 𝑎, 𝑏, 𝑐,‬כך ש‪ 𝑎 = 𝑏 :‬וגם 𝑑 = 𝑐‪ ,‬ניתן להרחיב לצביעה יחידה של 𝑊 כולו‪.‬‬
‫הגדרת השפה‪:‬‬
‫}𝑔𝑛𝑖𝑟𝑜𝑙𝑜𝑐 ‪3 − 𝑃𝐿𝐴𝑁𝐴𝑅 − 𝐶𝑂𝐿𝑂𝑅 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑝𝑙𝑎𝑛𝑎𝑟 𝑔𝑟𝑎𝑝ℎ 𝑎𝑛𝑑 ℎ𝑎𝑠 𝑎 𝑣𝑎𝑙𝑖𝑑 3 −‬‬
‫תרגיל‪ :‬הוכיחו 𝐻𝑃𝑁 ∈ 𝑅𝑂𝐿𝑂𝐶 ‪.3 − 𝑃𝐿𝐴𝑁𝐴𝑅 −‬‬
‫פתרון‪ :‬נפתור ברדוקציה‪.3𝐶𝑂𝐿𝑂𝑅≤𝑃3 − 𝑃𝐿𝐴𝑁𝐴𝑅 − 𝐶𝑂𝐿𝑂𝑅 :‬‬
‫בעצם אנחנו רוצים לקחת גרף‬
‫ולהפוך אותו למישורי וגם לשמור‬
‫על תכונת הצביעות‪.‬‬
‫תיאור הרדוקציה (לא פורמלי)‪:‬‬
‫נצייר את הגרף במישור‪ .‬בכל‬
‫מקום שיש חיתוך בין שתי‬
‫צלעות‪ ,‬נכניס את הגרף 𝑊‬
‫שראינו‪ ,‬כך‪:‬‬
‫במקרה שיש לנו כמה חיתוכים באותו הצלע אז נבצע כמה העתקות של 𝑊‪:‬‬
‫● 𝑅𝑂𝐿𝑂𝐶‪ ← < 𝐺 >∈ 3‬קיימת ‪-3‬צביעה לגרף 𝐺 ← הקודקודים המקוריים יישארו עם אותם צבעים‬
‫← בכל עותק של 𝑊‪ ,‬נבצע את הקודקודים החיצוניים כך שקודקודים נגדיים יהיו באותו צבע ← לפי‬
‫תכונה ‪ ,2‬זה משרה צביעה על כל שאר הקודקודים ← יש ‪-3‬צביעה חוקית ל‪← .𝐺'-‬‬
‫𝑅𝑂𝐿𝑂𝐶 ‪.< 𝐺' >∈ 3 − 𝑃𝐿𝐴𝑁𝐴𝑅 −‬‬
‫● 𝑅𝑂𝐿𝑂𝐶 ‪ ← < 𝐺' >∈ 3 − 𝑃𝐿𝐴𝑁𝐴𝑅 −‬יש ‪-3‬צביעה חוקית ל‪ ← 𝐺'-‬לפי תכונה ‪ ,1‬בכל עותק של‬
‫𝑊 הקודקודים הנגדיים קיבלו את אותו הצבע ← כל זוג קודקודים שהיה מחובר בצלע בגרף המקורי‪,‬‬
‫קיבל צבע שונה כל אחד ← הצביעה על הקודקודים המקוריים היא צביעה חוקית ←‬
‫𝑅𝑂𝐿𝑂𝐶‪.< 𝐺 >∈ 3‬‬
‫טריק חשוב‪" :‬משפט ארבעת הצבעים" מבטיח שלכל גרף מישורי יש ‪-4‬צביעה‪.‬‬
‫כלומר‪ ,‬השפה 𝑃 ∈ 𝑅𝑂𝐿𝑂𝐶 ‪ 4 − 𝑃𝐿𝐴𝑁𝐴𝑅 −‬כי בעזרת המשפט‪ ,‬אפשר לבנות מ"ט דטרמיניסטית‬
‫שבהינתן גרף 𝐺‪ ,‬מספיק לה לבדוק כי 𝐺 מישורי‪ ,‬אם כן‪ ,‬אז בהכרח קיים ‪-4‬צביעה ל‪.𝐺-‬‬
‫תרגיל ‪ - kCOL - 9‬תרגול ‪7‬‬

‫הגדרה‪ :‬נגדיר את משפחת השפות‪𝑘𝐶𝑂𝐿 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑎𝑛𝑑 ℎ𝑎𝑠 𝑎 𝑘 − 𝑐𝑜𝑙𝑜𝑟𝑖𝑛𝑔} :‬‬
‫תרגיל ‪ :1‬האם 𝐶𝑃𝑁 ‪?1𝐶𝑂𝐿 ∈ 𝑃, 𝑁𝑃,‬‬
‫פתרון ‪ .1𝐶𝑂𝐿 ∈ 𝑃 :1‬ניתן לצבוע גרף בצבע בודד רק אם לא קיימות בו צלעות בכלל‪.‬‬
‫תרגיל ‪ :2‬האם 𝐶𝑃𝑁 ‪?2𝐶𝑂𝐿 ∈ 𝑃, 𝑁𝑃,‬‬

‫פתרון ‪ .2𝐶𝑂𝐿 ∈ 𝑃 :2‬נראה אלגוריתם באופן לא פורמלי‪ :‬נבנה מ"ט דטרמיניסטית 𝑀 המכריעה את 𝐿𝑂𝐶‪.2‬‬
‫𝑀 על קלט > 𝐺 < תבצע‪:‬‬
‫‪ .1‬נבחר קודקוד 𝑢 באקראי ונבצע אותו בצבע "‪."1‬‬
‫‪ .2‬מרגע זה‪ ,‬ניתן להכריח לצבוע את הקודקודים השכנים ל‪ 𝑢-‬בצבע "‪ ,"2‬לאחר מכן לכל אחד מהשכנים‬
‫נצבע גם את השכנים שלהם ב‪ "1"-‬וככה הלאה…‬
‫‪ .3‬נמשיך לצבוע עד שנגיע לסתירה או שנסיים את כל רכיב הקשירות‪.‬‬
‫‪ .4‬נבצע עבור כל רכיבי הקשירות ב‪.𝐺-‬‬
‫‪ .5‬אם צבענו את כל 𝐺 מבלי להגיע לסתירה ‪ -‬קבל‪ .‬אחרת ‪ -‬דחה‪.‬‬
‫הערה חשובה‪ :‬אם ביקשו ממנו גרף 𝑘‪-‬צביע כאשר בגרף יש רק 𝑛 קודקודים כך ש‪ 𝑘 ≥ 𝑛 :‬אז קיימים יותר‬
‫צבעים מקודקודים ולכן אפשר לפתור באופן דטרמיניסטי ובזמן פולינומי מקרים פרטיים כאלה‪.‬‬
‫בעיות חיפוש למול בעיות הכרעה‬

‫שפות ב‪ NP-‬כבעיות הכרעה‬
‫כל השפות שראינו ב‪ 𝑁𝑃-‬עד כה היו מהצורה‪.{< 𝑂𝑏𝑗𝑒𝑐𝑡 > | ∃(𝑎 𝑐𝑒𝑟𝑡𝑎𝑖𝑛 𝑝𝑟𝑜𝑝𝑒𝑟𝑡𝑦 π) 𝑖𝑛 𝑂𝑏𝑗𝑒𝑐𝑡} :‬‬
‫● ב‪ 𝐶𝐿𝐼𝑄𝑈𝐸-‬היינו צריכים להכריע האם קיימת קליקה בגודל הנתון‪.‬‬
‫● ב‪ 𝑉𝐶-‬שאלנו האם קיים כיסוי קודקודים בגודל הנדרש‪.‬‬
‫● ב‪ 𝑆𝐴𝑇-‬שאלנו האם קיימת השמה מספקת‪.‬‬
‫כל השפות‪/‬בעיות הללו הן בעיות הכרעה‪.‬‬
‫הגדרה ‪ -‬בעיות חיפוש‬

‫לכל אחת מבעיות ההכרעה שהצגנו‪ ,‬ניתן להתאים בעיית חיפוש‪:‬‬
‫● קלט‪.< 𝑂𝑏𝑗𝑒𝑐𝑡 > :‬‬
‫● פלט‪ :‬אם ‪ π‬קיים ‪ -‬נחזיר אותו‪ .‬אחרת ‪ -‬נחזיר סימן מוסכם (למשל את המחרוזת "לא קיים ‪ π‬כנדרש")‪.‬‬
‫בעיות אלו הן בעיות חיפוש והן שייכות למחלקה 𝑃𝑁𝐹 המכילה יחסים ולא שפות‪.‬‬
‫בעיית החיפוש המתאימה ל‪CNF-SAT-‬‬

‫הגדרה‪ :‬בעיית החיפוש המתאימה ל‪ 𝐶𝑁𝐹 = 𝑆𝐴𝑇-‬מוגדרת כך‪:‬‬
‫● קלט‪ :‬פסוק הנתון בצורת 𝐹𝑁𝐶‪.‬‬
‫● פלט‪ :‬השמה המספקת את הפסוק (אם קיימת)‪.‬‬
‫משפט‪ :‬אם 𝑃𝑁 = 𝑃 אזי קיים אלגוריתם דטרמיניסטי פולינומי לבעיית החיפוש של 𝑇𝐴𝑆 ‪.𝐶𝑁𝐹 −‬‬
‫(כלומר‪ :‬אם 𝑃 ∈ 𝑇𝐴𝑆 ‪ 𝐶𝑁𝐹 −‬אז קיים אלגוריתם דטרמיניסטי ופולינומי לבעיית החיפוש המתאימה ל‪-‬‬
‫𝑇𝐴𝑆 ‪.)𝐶𝑁𝐹 −‬‬
‫הוכחת המשפט‪ :‬ראשית‪ ,‬בהינתן פסוק ‪ ϕ‬בצורת 𝐹𝑁𝐶 עם 𝑛 משתנים )𝑛𝑥 ‪ ,(𝑥1,...,‬ניתן לבחור משתנה מסוים‬
‫ולהציב עבורו ערך אמת מסוים‪ .‬ונקבל פסוק 𝐹𝑁𝐶 חדש עם ‪ 𝑛 − 1‬משתנים‪ .‬באופן לא מדויק‪ ,‬נכתוב את ערך‬
‫האמת בתוך הפסוק‪ .‬נשתמש בכללי הלוגיקה הבאים‪( :‬השלימו)‬
‫𝑎≡ ‪𝑎∨0‬‬ ‫‪𝑎 ∧ 0 ≡0‬‬
‫‪𝑎∨1 ≡1‬‬ ‫𝑎≡ ‪𝑎 ∧ 1‬‬
‫נגדיר‪:‬‬
‫● ‪ ϕ0‬הוא הפסוק המתקבל מ‪ ϕ-‬ע"י הצבת ערך ‪ 0‬במשתנה עם האינדקס הקטן ביותר‪.‬‬
‫● ‪ ϕ1‬הוא הפסוק המתקבל מ‪ ϕ-‬ע"י הצבת ערך ‪ 1‬במשתנה עם האינדקס הקטן ביותר‪.‬‬
‫הוכחה‪ :‬נניח ש‪ .𝑃 = 𝑁𝑃 :‬אזי קיים אלגוריתם דטרמיניסטי פולינומי 𝑀 המכריע את 𝑇𝐴𝑆 ‪.𝐶𝑁𝐹 −‬‬
‫נתאר אלגוריתם 𝑇𝐴𝑆‪ 𝑆𝑒𝑎𝑟𝑐ℎ‬דטרמיניסטי המחזיר השמה מספקת לפסוק 𝐹𝑁𝐶 נתון‪ ,‬או מחזיר את המחרוזת‬
‫"לא קיימת השמה מספקת"‪ .‬נגדיר השמה לפסוק כמילה מעל }‪ ,{0, 1‬כך שהמקום ה‪ 𝑖-‬במילה יהיה ערך האמת‬
‫של המשתנה ה‪.𝑖-‬‬
‫האלגוריתם 𝑇𝐴𝑆‪ 𝑆𝑒𝑎𝑟𝑐ℎ‬על קלט ‪ ϕ‬כאשר ‪ ϕ‬הוא פסוק 𝐹𝑁𝐶 עם 𝑛 משתנים‪ ,‬תבצע‪:‬‬
‫‪ .1‬סמלץ את 𝑀 על הקלט ‪.ϕ‬‬
‫‪ .a‬אם ‪ 𝑀(ϕ) = 0‬אז החזר "לא קיימת השמה מספקת"‪.‬‬
‫‪ .b‬אחרת‪ ,‬המשך לשלב ‪.2‬‬
‫‪ .2‬אתחל השמה ריקה‪.π = ε :‬‬
‫‪ .3‬כל עוד ‪ 𝑛 > 0‬תבצע‪:‬‬
‫‪ .a‬הצב ערך '‪ '0‬במשתנה בעל האינדקס הנמוך ביותר של ‪ ϕ‬ונקבל את הפסוק ‪.ϕ0‬‬
‫‪ .b‬סמלץ את ריצת 𝑀 על הקלט ‪:ϕ0‬‬
‫אם ‪ 𝑀(ϕ0) = 1‬אז בצע‪:‬‬ ‫‪.i‬‬
‫‪π = 0 · π .1‬‬
‫‪ϕ = ϕ0 . 2‬‬
‫אחרת‪ ,‬אם ‪ 𝑀(ϕ0) = 0‬אז בצע‪:‬‬ ‫‪.ii‬‬
‫‪π = 1 · π .1‬‬
‫‪ϕ = ϕ0 . 2‬‬
‫‪.𝑛 = 𝑛 − 1 .c‬‬
‫‪ .4‬החזר את ההשמה ‪.π‬‬
‫הוכחת נכונות האלגוריתם‪:‬‬

‫● אם 𝑇𝐴𝑆 ‪ ← ϕ ∈ 𝐶𝑁𝐹 −‬בכל שלב‪ ,‬המכונה 𝑀 יכריע עבור משתנה יחיד האם הוא צריך לקבל ערך‬
‫של ‪ 0‬או ‪ ← 1‬בסוף התהליך תהיה לנו השמה מספקת‪.‬‬
‫● אם 𝑇𝐴𝑆 ‪ ← ϕ ∉ 𝐶𝑁𝐹 −‬בשלב ‪ 1‬המכונה 𝑀 תחזיר ‪ 𝑆𝑒𝑎𝑟𝑐ℎ𝑆𝐴𝑇 ← 0‬יחזיר "לא קיימת השמה"‪.‬‬
‫סיבוכיות זמן ריצה‪ :‬נסמן ב‪ 𝑡(·)-‬את הסיבוכיות של הריצה של 𝑀‪ ,‬על פי ההנחה‪ 𝑡(·) ,‬הוא פולינום‪.‬‬
‫האלגוריתם 𝑇𝐴𝑆‪ 𝑆𝑒𝑎𝑟𝑐ℎ‬קורא ל‪ 𝑀-‬כ‪ 𝑛-‬פעמים‪ ,‬לכן הסיבוכיות היא ))𝑛(𝑡 · 𝑛(𝑂 ‪ -‬פולינומית‪.‬‬
‫נשים לב שבכל שלב חישוב האלגוריתם "יורד" רמה אחת בעץ הבינארי שציירנו‪ ,‬ו‪ 𝑀-‬מכוון אותו בכל צומת‬
‫לאיזה בן לרדת‪ .‬עומק העץ הוא 𝑛 כך שהסיבוכיות של האלגוריתם שלנו היא אכן ))𝑛(𝑡 · 𝑛(𝑂‪.‬‬
‫דוגמאות לבעיות חיפוש ‪ -‬אלגוריתם דטרמיניסטי ל‪CLIQUE-‬‬

‫(שאלת מבחן)‪ :‬נניח שחוקר מוכשר הצליח למצוא אלגוריתם דטרמיניסטי פולינומי ל‪ ,𝐶𝐿𝐼𝑄𝑈𝐸-‬ומימש אותו‬
‫באמצעות מכונת טיורינג 𝐸𝑈𝑄𝐼𝐿𝐶𝑀‪ .‬תארו (במילים) מימוש של מ"ט יעילה שבהינתן קלט > 𝑘 ‪ ,< 𝐺,‬מחזירה‬
‫קליק ב‪ 𝐺-‬שגודלו 𝑘‪ ,‬או מחזירה "לא קיים"‪ ,‬אם לא קיים קליק כזה‪.‬‬
‫הרעיון‪ :‬נוריד קודקודים וכל פעם שהאלגוריתם 𝐸𝑈𝑄𝐼𝐿𝐶𝑀 יחזיר 𝐸𝑆𝐿𝐴𝐹‪ ,‬זה היה קודקוד נחוץ ולכן נחזיר אותו‪.‬‬
‫● בדיקה ראשונית‪ ,‬אם הקלט > 𝑘 ‪ < 𝐺,‬שייך לשפה 𝐸𝑈𝑄𝐼𝐿𝐶‪.‬‬
‫● בכל שלב נוריד קודקוד‪ ,‬ואת כל הצלעות החלות בו‪ ,‬יהי '𝐺 הגרף המתקבל לאחר ההורדה‪.‬‬
‫● נבדוק אם > 𝑘 ‪ < 𝐺',‬בשפה 𝐸𝑈𝑄𝐼𝐿𝐶‪ ,‬אם כן‪ ,‬נמשיך‪ ,‬אחרת נחזור אל 𝐺‪.‬‬
‫● נעצור כאשר גודל הגרף '𝐺 הוא בדיוק 𝑘 קודקודים‪.‬‬
‫● נחזיר את קבוצת הקודקודים של '𝐺‪.‬‬
‫האלגוריתם 𝐸𝑈𝑄𝐼𝐿𝐶‪ 𝑆𝑒𝑎𝑟𝑐ℎ‬על קלט > 𝑘 ‪ < 𝐺,‬כאשר 𝐺 הוא גרף ו‪ 𝑘-‬טבעי‪ ,‬תבצע‪:‬‬
‫‪ .1‬סמלץ את 𝐸𝑈𝑄𝐼𝐿𝐶𝑀 על קלט > 𝑘 ‪.< 𝐺,‬‬
‫‪ .a‬אם ‪ ,𝑀𝐶𝐿𝐼𝑄𝑈𝐸(< 𝐺, 𝑘 >) = 0‬החזר "לא קיים"‪.‬‬
‫‪ .b‬אחרת‪ ,‬עבור לשלב ‪.2‬‬
‫‪ .2‬הגדר קבוצת קודקודים ריקה }{ = 𝑆‪.‬‬
‫‪ .3‬עבור |)𝐺(𝑉| ≤ 𝑛 ≤ ‪ 1‬בצע‪:‬‬
‫‪ .a‬הוצא קודקוד 𝑛𝑣 והגדר }𝑛𝑣{\‪.𝐺𝑛 = 𝐺𝑛−1‬‬
‫‪ .b‬סמלץ את ריצת 𝐸𝑈𝑄𝐼𝐿𝐶𝑀 על > 𝑘 ‪.< 𝐺𝑛,‬‬
‫אם ‪ 𝑀𝐶𝐿𝐼𝑄𝑈𝐸(< 𝐺𝑛, 𝑘 >) = 0‬אז‪:‬‬ ‫‪.i‬‬
‫‪.𝑆 = 𝑆 ∪ {𝑣𝑛} .1‬‬
‫‪.𝐺𝑛−1 = 𝐺𝑛 ∪ {𝑣𝑛} .2‬‬
‫‪.𝑛 = 𝑛 + 1 .c‬‬
‫‪ .4‬החזר את ההשמה 𝑆‪.‬‬
‫הוכחת נכונות האלגוריתם‪:‬‬

‫● אם 𝐸𝑈𝑄𝐼𝐿𝐶 ∈> 𝑘 ‪ ← < 𝐺,‬קיימת קליקה בגודל 𝑘 ← היות והאלגוריתם בודק שייכות של כל‬
‫קודקוד בנפרד‪ ,‬הוא ימצא את הקליקה‪.‬‬
‫● אם 𝐸𝑈𝑄𝐼𝐿𝐶 ∉> 𝑘 ‪ ← < 𝐺,‬האלגוריתם יחזיר "לא קיים" כבר בשורה הראשונה‪.‬‬
‫סיבוכיות זמן הריצה‪ :‬נניח כי 𝐸𝑈𝑄𝐼𝐿𝐶𝑀 רץ בזמן 𝑡‪ .‬אזי האלגוריתם רץ בזמן )𝑡𝑛(𝑂 ‪ -‬פולינומי‪.‬‬
‫דוגמאות לבעיות חיפוש ‪ -‬אלגוריתם דטרמיניסטי ל‪HAMPATH-‬‬

‫(שאלת מבחן)‪ :‬נניח כי קיים אלגוריתם דטרמיניסטי פולינומי (הממומש במ"ט 𝐻𝑇𝐴𝑃𝑀𝐴𝐻𝑀) המכריע את השפה‪:‬‬
‫}‪𝐻𝐴𝑀𝑃𝐴𝑇𝐻 = {< 𝐺 > | 𝐺 𝑖𝑠 𝑎 𝑔𝑟𝑎𝑝ℎ 𝑡ℎ𝑎𝑡 ℎ𝑎𝑠 𝑎 𝐻𝑎𝑚𝑖𝑙𝑡𝑜𝑛𝑖𝑎𝑛 𝑝𝑎𝑡ℎ‬‬
‫סעיף א'‪ :‬מה ההשלכה של קיום האלגוריתם הזה לשאלה האם 𝑃𝑁 = 𝑃?‬
‫סעיף ב'‪ :‬הראו אלגוריתם דטרמיניסטי פולינומי אשר בהינתן קלט > 𝐺 < מחזיר פרמוטציה של קודקודי הגרף‬
‫אשר מהווה מסלול המילטוני‪ ,‬אם קיים כזה‪ ,‬אחרת ‪ -‬מחזירה את המחרוזת "לא קיים מסלול המילטוני"‪.‬‬
‫הסבירו את פעולת האלגוריתם במילים שלכם‪ .‬אין צורך להוכיח נכונות‪ ,‬אך יש להראות שהסיבוכיות הינה‬
‫פולינומית‪.‬‬
‫פתרון א'‪ :‬היות ו‪ ,𝐻𝐴𝑀𝑃𝐴𝑇𝐻 ∈ 𝑁𝑃𝐶-‬קיום אלגוריתם דטרמיניסטי פולינומי מעיד כי 𝑃 ∈ 𝐻𝑇𝐴𝑃𝑀𝐴𝐻 וגם‬
‫כל שאר השפות ב‪ 𝑁𝑃-‬מרדוקציה‪ .‬לכן‪.𝑃 = 𝑁𝑃 ,‬‬
‫פתרון ב'‪:‬‬
‫הרעיון‪:‬‬
‫● בדיקה ראשונית‪ ,‬אם הקלט > 𝐺 < בשפה 𝐻𝑇𝐴𝑃𝑀𝐴𝐻‪.‬‬
‫● בכל שלב נוריד צלע ונקבל את '𝐺‪.‬‬
‫● נבדוק אם > '𝐺 < בשפה‪ ,‬אם כן‪ ,‬נמשיך‪ ,‬אחרת נחזור אל 𝐺‪.‬‬
‫● נעצור כאשר כמות הצלעות בגרף '𝐺 היא בדיוק ‪.𝑛 − 1‬‬
‫● נשתמש בקבוצת הצלעות שנותרה כדי להחזיר את הסידור של הקודקודים על המסלול ההמילטוני‬
‫בגרף‪.‬‬
‫אלגוריתם 𝐻𝑇𝐴𝑃𝑀𝐴𝐻‪ 𝑆𝑒𝑎𝑟𝑐ℎ‬על קלט > 𝐺 < כאשר 𝐺 הוא גרף‪ ,‬תבצע‪:‬‬
‫‪ .1‬סמלץ את 𝐻𝑇𝐴𝑃𝑀𝐴𝐻𝑀 על קלט > 𝐺 <‪:‬‬
‫‪ .a‬אם ‪ - 𝑀𝐻𝐴𝑀𝑃𝐴𝑇𝐻(< 𝐺 >) = 0‬החזר "לא קיים מסלול המילטוני"‪.‬‬
‫‪ .b‬אחרת‪ ,‬המשך לשלב ‪.2‬‬
‫‪ .2‬נגדיר קבוצת צלעות ריקה }{ = 𝑆‪.‬‬
‫‪ .3‬עבור |)𝐺(𝐸| ≤ 𝑚 ≤ ‪ 1‬בצע‪:‬‬
‫‪ .a‬הוצא צלע 𝑚𝑒 והגדר }𝑚𝑒{\‪.𝐺𝑚 = 𝐺𝑚−1‬‬
‫‪ .b‬סמלץ את ריצת 𝐻𝑇𝐴𝑃𝑀𝐴𝐻𝑀 על קלט > 𝑚𝐺 <‪.‬‬
‫אם ‪ 𝑀𝐻𝐴𝑀𝑃𝐴𝑇𝐻(< 𝐺𝑚 >) = 0‬אז‪:‬‬ ‫‪.i‬‬
‫‪.𝑆 = 𝑆 ∪ {𝑒𝑚} .1‬‬
‫‪.𝐺𝑚−1 = 𝐺𝑚 ∪ {𝑒𝑚} .2‬‬
‫‪.𝑚 = 𝑚 + 1 .c‬‬
‫‪ .4‬החזר את 𝑆‪.‬‬
‫אז אחרי כמעט ‪ 4‬שנים של לימודים אינטנסיביים של ‪ 12‬שעות למידה ביום‪ ,‬גם אני‬
‫מסיים את התואר‪ .‬זה הקורס האחרון שלי‪ .‬חשוב לי להגיד שאין דבר העומד בפני‬
‫הרצון‪ .‬התחלתי את התואר בזלזול רב וחוסר רצון ללמוד‪ ,‬בנוסף יש לי הרבה קשיי‬
‫למידה ולוקח לי זמן להבין דברים‪ .‬עם הזמן תפסתי את עצמי ברצינות והתחלתי‬
‫לקחת את ענייני הסיכומים ברצינות כדי להוכיח לעצמי שאני יכול הכל‪ .‬אם יש לכם‬
‫מטרה שאולי מרגישה לכם בהתחלה מאוד מטופשת כמו האופן שבו אני סיכמתי כל‬
‫קורס‪ ,‬אני ממליץ לכם דווקא כן ללכת עליה ולהלחם עליה כי בסוף הדרך זה נותן‬
‫את הסיפוק הגדול ביותר (וגם אחלה של תוסף לרזומה)‪.‬‬
‫בהצלחה לכולנו בהמשך‪ ,‬זה רק ההתחלה! 😀‬
‫וכן‪ ,‬נותר רק לכתוב בפעם האחרונה‪ :‬חלאס‪.‬‬

חישוביות - מחברת הרצאות

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

חישוביות - מחברת הרצאות

Uploaded by

Copyright:

Available Formats

‫חישוביות‬

‫מחברת סיכום מתוך ההרצאות של דורון מור‬

‫חישוביות ‪ -‬מחברת הרצאות‬

‫ספר זה לא נבדק על ידי מרצה‪ ,‬יתכן שימצאו טעויות‪.‬‬

‫לסיכומים נוספים שלי במדעי המחשב ומתמטיקה‪:‬‬

‫‪:‬‬ ‫מוזמנים לעקוב אחרי 😊‬

‫חלק א' ‪ -‬חישוביות‬

‫‪5‬‬ ‫מכונת טיורינג‬

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

‫‪24‬‬ ‫המחלקות ‪ R‬ו‪RE-‬‬

‫‪59‬‬ ‫שפות שלמות‬

‫‪63‬‬ ‫משפט רייס‬

‫‪74‬‬ ‫בעיית העצירה החסומה ‪BHP -‬‬

‫‪78‬‬ ‫מכונות טיורינג אי‪-‬דטרמיניסטיות‬

‫‪94‬‬ ‫תרגילים ‪ -‬חישוביות‬

‫חלק ב' ‪ -‬סיבוכיות‬

‫‪104‬‬ ‫המחלקות ‪ P‬ו‪NP-‬‬

‫‪131‬‬ ‫רדוקציה פולינומית‬

‫‪137‬‬ ‫שפות ‪ NP‬שלמות‬

‫‪139‬‬ ‫בעיית הספיקות ‪ -‬השפה ‪SAT‬‬

‫‪156‬‬ ‫דוגמאות לשפות ‪-NP‬שלמות‬

‫‪183‬‬ ‫בעיות חיפוש למול בעיות הכרעה‬

‫בעיה קשה‬ ‫בעיה קלה‬

‫ייצוג בעיה על ידי שפה‬

‫רכיבי מכונת טיורינג‬

‫תכונות מכונת טיורינג‬

‫דוגמת בנייה למכונה המזהה שפה‬

‫פונקציה של מכונת טיורינג‬

‫דוגמה ‪ - 1‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫דוגמה ‪ - 2‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫דוגמה ‪ - 3‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫דוגמה ‪ - 4‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫● עבור ‪ 𝑏‾ ∈ Γ‬מתקיים‪. δ(𝑞0, 𝑏‾) = (𝑞𝑒𝑛𝑑, 𝑏‾, 𝑆) :‬‬

‫דוגמה רצינית ‪ -‬בנייה למכונת טיורינג המחשבת פונקצייה‬

‫פתרון‪ :‬נבנה טבלת מעברים שתמדל את הבעיה‪:‬‬

‫תוכן הסרט ‪α‬‬

‫עבור 𝑢 תוכן הסרט הנוכחי ו‪ 𝑖-‬הוא מיקום הראש הנוכחי אז‪:‬‬

‫רצף צעדי חישוב‬

‫תרגיל סדרת קונפיגורציה‬

‫דוגמת סימולציה של מכונת טיורינג עם קונפיגורציות‬

‫הקונפיגורציה ההתחלתית היא )‪.𝑐0 = (1001, 𝑞0, 1‬‬

‫כעת מכיוון ש‪ α[1] = 1 :‬אז נעבור ל‪ 𝑞1-‬אבל כיוון שאנחנו‬

‫שקילות מכונות טיורינג‬

‫איך מוכיחים שקילות מודלים בתכל'ס?‬

‫שינויים אפשריים למכונת טיורינג‬

‫מכונת טיורינג מרובת סרטים‬

‫הוכחת שקילות מ"ט רגילה עם מ"ט דו‪-‬סרטית‬

‫אם )𝑚 ‪ δ(𝑞, σ) = (𝑞', σ',‬אז )𝑆 ‪.δ‾(𝑞, σ, τ) = (𝑞', σ', 0, 𝑚,‬‬

‫דוגמה ויזואלית (לא חלק מההוכחה)‪:‬‬

‫הוכחת שקילות מ"ט רגילה עם מ"ט ‪-k‬סרטית‬

‫דוגמה ‪ -‬מ"ט דו‪-‬סרטית‬

‫מכונת טיורינג עם קבוצת מצבים אינסופית‬

‫מכונת טיורינג זריזה‬

‫)𝑎 ‪δ(𝑞, 𝑎): = δ'(𝑞,‬‬

‫תרגיל בית ‪ -‬שקילות מכונות‬

‫השוואה בין מ"ט לבין אוטומטים פשוטים‬

‫סמן את האות הראשונה של המילה ב‪.𝑥-‬‬ ‫‪2‬‬

‫לולאה‪ :‬חזור שמאלה עד לתא שמימין ל‪ 𝑥-‬הימני ביותר ותקבע‪:‬‬ ‫‪4‬‬

‫אם נפגשת ב‪ "1"-‬במהלך הריצה ימינה עד לסוף המילה ‪ -‬דחה‪.‬‬ ‫‪4.2.1‬‬

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

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

‫מקבילה בעולם שלנו‬ ‫מונח‬

‫מחשב מודרני ‪ /‬מערכת ההפעלה‬ ‫מכונת טיורינג אוניברסלית ‪𝑈 -‬‬

‫אלגוריתם ספציפי במחשב ‪ /‬תוכנה‬ ‫מכונת טיורינג רגילה ‪𝑀 -‬‬