+ חלק זה של הקורס עוסק בגבולות הכוח החישובי. הוא מתחיל בבניית המודל היסודי של מכונת טיורינג (מ"ט), עובר לניתוח היררכיית השפות והיחסים ביניהן (R, RE, co-RE, Neither), ומסתיים בטכניקות רידוקציה וסיווג שפות (משפט רייס). בפרקים הבאים נעבור לעולם הסיבוכיות, שם נבחן לא רק אם בעיה פתירה, אלא מה המשאבים (זמן ומקום) הנדרשים לכך.
+
+
+
+
פרק 1: יסודות ומודל מכונת טיורינג (מ"ט)
+
+
+ במילים פשוטות: מכונת מצבים עם זכרון בצורת סרט. יש לנו גישה חופשית לכל תא בזיכרון, עם אופציה לנוע ימינה וגם שמאלה על הסרט, ואף לשנות את תוכן הסרט.
+
+
+
ההגדרה הפורמלית (The 7-Tuple)
+
+
מכונת טיורינג מיוצגת על ידי 7 רכיבים:
+
+
+
+
+
פונקציית המעברים
+ δ:
+
+
+ δ
+ :
+ Q
+ × Γ
+ → Q
+ × Γ
+ × {L, R}
+
+
+ δ(q,
+ α) =
+ (q',
+ β,
+ D)
+
+
+ q — מצב נוכחי
+ α — תו הנקרא (מ-Γ)
+ q' — מצב הבא
+ β — תו הנכתב (ל-Γ)
+ D ∈ {L,R} — כיוון הראש
+
+
+
+
+
+ ★ חובה: qacc ≠ qrej
+ לכן |Q| ≥ 2 תמיד (כל מכונה צריכה לפחות 2 מצבים)
+ הערה: q0 יכול להיות מצב מקבל או דוחה (מכונה שעוצרת מיד)
+
+
+
+
3 התוצאות האפשריות לריצת מ"ט על קלט w
+
כאשר נריץ מכונת טיורינג M על מילה w, ייתכן אחד משלושה תרחישים בלבד:
+
+
המכונה מקבלת: החישוב עוצר במצב qacc. רק במקרה זה נגיד ש- w ∈ L(M).
+
המכונה דוחה: החישוב עוצר במצב qrej. במקרה זה נגיד ש- w ∉ L(M).
+
לולאה אינסופית: החישוב לא עוצר לעולם. גם במקרה זה נגיד ש- w ∉ L(M).
+
+
+ שימו לב להבדל החשוב: המושג "לא מקבלת" מכיל בתוכו 2 אפשרויות שונות — או שהמכונה דחתה אקטיבית (תרחיש 2), או שהיא נתקעה בלולאה אינסופית (תרחיש 3). אל תבלבלו בין "דוחה" ל"לא מקבלת"!
+
+
+
+
אופי החישוב: דטרמיניסטי (D) מול אי-דטרמיניסטי (N)
+
+
+
+
מ"ט דטרמיניסטית (DTM)
+
מ"ט אי-דטרמיניסטית (NDTM)
+
+
+
+
+
לכל מילה w, יש חישוב יחיד של המכונה.
+
לכל מילה w, ייתכנו חישובים שונים של המכונה במקביל.
+
+
+
החישוב מתואר ע"י סדרה/מסלול יחיד של קונפיגורציות (ממצב ההתחלה ועד לעצירה או לולאה).
+
החישוב מתואר ע"י עץ חישובים. שורש העץ הוא קונפיגורציית ההתחלה.
+
+
+
בחישוב סופי, הקונפיגורציה האחרונה היא קונפיגורציית עצירה (מקבלת או דוחה).
+
העלים של העץ הם קונפיגורציות עצירה. כל חישוב הוא מסלול מהשורש לעלה, או מסלול אינסופי.
+
+
+
+
+
+
+
עצי חישוב ב-NDTM — דוגמאות ויזואליות
+
+
+
+
+
+
+
עץ חישובים מקבל
+
+
יש לפחות מסלול מקבל אחד (ירוק)
+
+
+
+
+
עץ חישובים דוחה
+
+
כל המסלולים דוחים, העץ סופי
+
+
+
+
+
+
לא מקבל — שני מקרים אפשריים
+
+
+
+
+
דוחה
+
+
כל המסלולים עוצרים בדחייה
+
+
+
+
או
+
+
+
+
לא מקבל (וגם לא דוחה)
+
+
יש מסלולים אינסופיים — המכונה לא עוצרת
+
+
+
+
+
+
+ משפט השקילות — כוח חישוב מול יעילות:
+ מבחינת כוח חישוב טהור (חישוביות),
+ NDTMשקולה לחלוטין ל-DTM —
+ כל שפה שניתנת להכרעה/לקבלה ע"י NDTM ניתנת גם ע"י DTM (למשל ע"י סריקת עץ החישוב לרוחב — BFS).
+ אין לה שום "כוחות קסם" לפתור בעיות בלתי כריעות.
+
מבחינת יעילות (סיבוכיות),
+ אין שקילות ידועה —
+ NDTM יכולה לפתור בזמן פולינומי (NP) דברים של-DTM ייתכן ויידרש זמן אקספוננציאלי.
+
+
+
+ תנאי הקבלה ב-NDTM: המכונה מקבלת את המילה אם קיים לפחות מסלול אחד בעץ שמסתיים במצב קבלה. מספיק עלה אחד "ירוק" כדי שהמילה תתקבל, גם אם שאר המסלולים דוחים או נתקעים בלולאה.
+
+
+ תנאי הדחייה ב-NDTM (מלכודת קלאסית): המכונה דוחה אך ורק אם כל המסלולים בעץ ללא יוצא מן הכלל הם סופיים ומסתיימים בדחייה (העץ כולו אדום וסופי).
+ אם אין אף מסלול מקבל, אבל יש לפחות מסלול אחד אינסופי - המכונה לא מקבלת, אבל גם לא דוחה!
+
+
+
+
+ ⭐ L(M) תמיד שייכת ל-RE — תמיד!
+ כל מכונת טיורינג M היא בהגדרה מקבלת של השפה שלה: היא עוצרת ב-qacc על כל מילה שהיא מקבלת, ולכן L(M) ניתנת לקבלה על ידי M עצמה. זה בדיוק ההגדרה של RE.
+ על מילים שאינן בשפה — M יכולה לדחות (לעצור ב-qrej) או להיתקע בלולאה. בשני המקרים L(M) ∈ RE. השאלה אם היא גם ב-R (כריעה) תלויה אם היא גם תמיד עוצרת על מילים שאינן בשפה.
+
+
+ שפה כריעה לא אומרת שהמכונה מכריעה — השפה L יכולה להיות כריעה, אך מכונה ספציפית M עם L(M) = L עשויה בכל זאת להיתקע בלולאה על קלטים מסוימים — היא לא בהכרח המכונה שמכריעה אותה.
+
+
+ מכונת MLOOP — לעולם לא עוצרת: מכונה שנכנסת ללולאה אינסופית על כל קלט. לכן L(MLOOP) = ∅ — אף מילה לא מתקבלת, כי קבלה דורשת עצירה במצב קבלה.
+
+
+ מסלול חישוב אינסופי לא שולל הכרעה של w — אם ב-NDTM יש ענף שרץ לנצח, אך כל שאר הענפים עוצרים, המכונה עדיין יכולה לקבל או לדחות את w דרך הענפים הסופיים. מסלול אינסופי אחד אינו "מאפס" את התשובה.
+
+
+ אם w ∈ L(M) — קיים מסלול חישוב שמסתיים במצב מקבל: שייכות של מילה לשפה פירושה בדיוק שקיים לפחות מסלול חישוב אחד שמוביל למצב qacc. זה לא אומר שכל המסלולים מקבלים, ולא אומר שאין מסלולים אינסופיים — רק שקיים אחד מקבל.
+
+
+ יתרון ה-NDTM על ה-DTM בפועל: לדוגמה ב-SAT — DTM בודקת כל ההשמות אחת אחת (2ⁿ זמן), ואילו NDTM "מנחשת" בבת אחת השמה בכל ענף ובודקת — זמן פולינומי לכל ענף.
+
+
+
+
+
וריאציות של מכונות טיורינג (Robustness)
+
מודל מכונת הטיורינג הוא חזק ועמיד ("רובוסטי"). קיימות גרסאות שונות למודל הבסיסי, אך כולן שקולות בכוחן החישובי למודל הסטנדרטי (מ"ט עם סרט אחד, אינסופי ימינה).
+
+
מ"ט מרובת סרטים: במקום סרט אחד, יש למכונה k סרטים שונים שניתן לקרוא ולכתוב עליהם במקביל.
+
מ"ט עם סרט אינסופי לשני הכיוונים: הסרט אינו חסום משמאל ויכול להמשיך עד אינסוף לשני הכיוונים.
+
+
+ חוק השקילות: כל הווריאציות אינן מוסיפות כוח חישובי. כל שפה שכריעה/ניתנת לקבלה ע"י מ"ט מרובת סרטים, ניתנת להכרעה/קבלה גם ע"י מ"ט רגילה. הווריאציות רק משפיעות על היעילות (סיבוכיות הזמן והמקום), אך לא על השאלה "האם ניתן לפתור את הבעיה בכלל".
+
+ דוגמה העתקת מחרוזת w באורך n: מ"ט עם 2 סרטים עושה זאת ב-O(n) צעדים (כותבת תו תו לסרט השני). מ"ט עם סרט אחד צריכה O(n²) כי היא חייבת לנסוע הלוך ושוב כדי למצוא את המקום הפנוי. שתיהן מסוגלות לבצע את המשימה — רק המהירות שונה.
+
+
+
חישוב קונפיגורציות (מקום חסום)
+
+
כמה "תמונות מצב" שונות יכולות להיות עבור N תאים על הסרט?
+
+
+
+
+
✏️ דוגמת שאלת מבחן
+
+ נתנה מ"ט M עם:
+
+ Q = {q0, q1, q2, qacc, qrej},
+ Γ = {0, 1, ⊔},
+ Σ = {0, 1}
+
+ כמה קונפיגורציות שונות יכולות להיות כאשר מילת הקלט w ∈ Σ* באורך 20?
+
+ מכונת טיורינג האוניברסלית (UTM):
+ L(UTM) = ATM — מ"ט שמסמלצת כל מ"ט אחרת. על קלט ⟨M, w⟩ היא מקבלת בדיוק כאשר M מקבלת w.
+
+ מכונת K (הרדוקציה הקנונית):
+ זוהי מכונת-עזר שאנו בונים בהוכחות. היא "מתוכנתת" מראש עבור זוג ספציפי: מכונה M ומילה w.
+ איך היא פועלת כאשר נותנים לה קלט כלשהו x?
+
+
מתעלמת לחלוטין מהקלט x.
+
מריצה בתוכה את M על הקלט w.
+
אם הריצה הזו עוצרת — היא מאשרת ומקבלת את x (Accept).
+
+
+
+
+
+ L(KM,w) =
+
+
Σ*
+
+ כאשר M עוצרת על w — תקבל כל קלט x
+
+
+
+
∅
+
+ כאשר M לא עוצרת על w — תיתקע לנצח, לא תקבל שום קלט
+
+
+
+
+ שימוש: K היא כלי לבניית רידוקציות. בגלל שהיא מתעלמת מהקלט שלה, שפת המכונה שלה תלויה 100% רק בשאלה "האם M עוצרת על w".
+
+
+
🚩 רשימת "מוקשים" - מלכודות מבחן
+
+
+
1️⃣ אשליית הגרף (Static vs Dynamic)
+
קיום מסלול בגרף לא מבטיח שהשפה אינה ריקה!
+
מסלול גרפי מ-q0 ל-qaccלא מבטיח שקיימת מילה שמתקבלת. הגרף הוא מבנה סטטי — בזמן הריצה המכונה עשויה לדרוס לעצמה את התנאים הנדרשים על הסרט, ואף מילה לא תצליח להשלים את המסלול. השפה תישאר ריקה לחלוטין.
+
+ חוקי הברזל לשאלות מבחן:
+
+
אין מסלול בגרף ל-qacc ← השפה בהכרח ריקה (L(M) = ∅), כי אין למכונה שום דרך פיזית להגיע למצב קבלה.
+
יש מסלול בגרף ל-qacc ←לא ניתן להסיק מכך דבר! השפה יכולה להיות לא ריקה, אך היא עשויה עדיין להיות ריקה לחלוטין בגלל דינמיקת הסרט.
+
+
+
+
+
+
2️⃣ מלכודת המשלים ב-NDTM
+
החלפת q_acc עם q_rej לא תיצור את שפת המשלים!(ייתכן שכן תיצור את שפת המשלים, אבל לא בהכרח עבור כל מכונה)
+ למה? ב-NDTM מספיק מסלול אחד מקבל. אם תהפוך אותו לדוחה אך תשאיר מסלול שנתקע בלולאה, המכונה לא תקבל ולא תדחה.
+
+
+
+
3️⃣ ה"אין דחייה"
+
אם אין חץ ל-q_rej, זה לא אומר השפה היא Σ*!
+ מה קורה? המכונה פשוט תיתקע בלולאה על מילים שלא בשפה, במקום להגיע למצב דחייה.
+
+
+
P ו-NP (הקדמה לפרק 5)
+
+ P — בעיות הפתירות בזמן פולינומי (דטרמיניסטי). דוגמאות: מיון, חיפוש.
+ NP — בעיות שניתן לוודא פתרון בזמן פולינומי. דוגמאות: SAT, TSP.
+ היררכיה:P ⊆ NP ⊆ R ⊆ RE | השאלה הפתוחה: האם P = NP?
+
+
+
+
+
+
+
+
+
+
+
פרק 2+3: היררכיית השפות, סיווג שפות
+
+ פרק זה עוסק בסיווג שפות לפי היכולת של מ"ט להתמודד איתן. אנו מבחינים בין מה שניתן לפתרון מוחלט (R), מה שניתן רק לזיהוי (RE), ומה שבלתי פתיר לחלוטין (Neither).
+
+
+
המפה הכללית — ארבעת הקטגוריות
+
+
+
+
+
מחלקה
+
הגדרה
+
מילה בשפה ("כן")
+
מילה שלא בשפה ("לא")
+
דוגמאות
+
+
+
+
+
+ 🟢 R
+ כריעות
+
+
מ"ט שעוצרת תמיד ב"כן" או "לא".
+
עוצרת ב-qacc
+
עוצרת ב-qrej
+
AnBn, ADFA
+
+
+
+ 🟠 RE \ R
+ קבלה בלבד
+
+
מ"ט שעוצרת רק ב"כן".
+
עוצרת ב-qacc
+
לולאה אינסופית
+
ATM, HTM, ETM
+
+
+
+ 🟣 co-RE \ R
+ הפרכה בלבד
+
+
מ"ט שעוצרת רק ב"לא".
+
לולאה אינסופית
+
עוצרת ב-qrej
+
NotEmpty, ATM
+
+
+
+ 🔴 Neither
+ לא זה ולא זה
+
+
גם המכונה וגם המשלים לא ניתנים לקבלה.
+
לולאה אינסופית
+
לולאה אינסופית
+
EQTM, ALLTM, INFTM
+
+
+
+
+
סיווג השפות לפי דרגות קושי
+
+
+
+
+
+
תכונות סגירות (Closures)
+
אילו פעולות שומרות על הקטגוריה?
+
+
+
🟢 R (ניתנות להכרעה)
+
סגורה לכל הפעולות:
+
+ איחוד ∪
+ חיתוך ∩
+ משלים C
+ שרשור ·
+ כוכב *
+
+ אינטואיציה: אם יש דסידר עבור L ודסידר עבור L', אפשר לבנות דסידר לפעולות ביניהן
+
+
+
+
🟠 RE (ניתנות לקבלה)
+
סגורה:
+
+ איחוד ∪
+ חיתוך ∩
+ שרשור ·
+ כוכב *
+ ⚠️ משלים — לא סגורה!
+
+ למה? אם L ∈ RE וגם L̄ ∈ RE, אז L ∈ R (לפי משפט פוסט) - סתירה!
+
+
+
דוגמאות לשפות מוכרות — הגדרות פורמליות (מתוך דף נוסחאות)
+
+
+
הגדרות פורמליות:
+
+
+ AnBn
+ = {anbn | n ≥ 0} כל המילים מהצורה aⁿbⁿ —
+ R
+
+ ADFA
+ = {⟨D, w⟩ | D הוא אוטומט סופי דטרמיניסטי שמקבל את w} מריצים ורואים —
+ R
+
+ ATM
+ = {⟨M, w⟩ | M היא מ"ט שמקבלת את w} אם לא מקבלת, עלולה לרוץ לנצח —
+ RE \ R
+
+ HTM
+ = {⟨M, w⟩ | M היא מ"ט שעוצרת על w} גם דחייה נחשבת עצירה; אם לא, לולאה לנצח —
+ RE \ R
+
+ ETM
+ = {⟨M⟩ | L(M) = ∅} M לא מקבלת שום מילה (שפה ריקה) —
+ co-RE \ R
+
+ ALLTM
+ = {⟨M⟩ | L(M) = Σ*} M מקבלת את כל המילים; לא ניתן לאשר ולא להפריך —
+ Neither
+
+ INFTM
+ = {⟨M⟩ | L(M) אינסופית} M מקבלת אינסוף מילים; לא ניתן לאשר בוודאות —
+ Neither
+
+ FINTM
+ = {⟨M⟩ | L(M) סופית} = INFTMהמשלים של INFTM —
+ Neither
+
+ EQTM
+ = {⟨M1, M2⟩ | M1, M2 הן מ"ט שמקיימות L(M1) = L(M2)} שתי מ"טות עם שפות זהות —
+ Neither
+
+
+
+
+
+
שפות נוספות:
+
+
+ 📌 כל שפות P, NP ו-NPC הן כריעות (R) ולכן גם ב-RE — ניתן להכריע אותן בזמן סופי.
+
+
+
🔵 שפות ב-P (פולינומי — גם ב-R וב-RE)
+
+
+ PATH
+ = {⟨G, s, t⟩ | קיים מסלול מ-s ל-t בגרף G המכוון} BFS/DFS —
+ P
+
+ PAL
+ = {w | w היא פלינדרום — שווה להיפוך שלה} בדיקה לינארית —
+ P
+
+ PRIME
+ = {⟨n⟩ | n הוא מספר ראשוני} אלגוריתם AKS (2002) —
+ P
+
+ א"ס"ד
+ = {⟨D, w⟩ | אס"ד D מקבל את w} תמיד עוצר ← ב-R —
+ P
+
+ אסל"ד
+ = {⟨N, w⟩ | אסל"ד N מקבל את w} ממיר ל-DFA ← תמיד עוצר ← ב-R —
+ P
+
+
+
+
🔴 שפות ב-NPC (NP-שלמות — הקשות ביותר ב-NP, גם ב-R וב-RE)
+
+
+ SAT
+ = {⟨φ⟩ | φ היא נוסחה בוליאנית ספיקה בצורת CNF} משפט קוק-לוין —
+ NPNPC
+
+ 3SAT
+ = {⟨φ⟩ | φ היא נוסחה ספיקה בצורת 3-CNF} רדוקציה מ-SAT —
+ NPNPC
+
+ VC
+ = {⟨G, k⟩ | קיים כיסוי קודקודים בגודל k בגרף G — כל קשת נוגעת לפחות בקודקוד אחד מהקבוצה}
+ NPNPC
+
+ IS
+ = {⟨G, k⟩ | קיימת קבוצה בלתי-תלויה בגודל k בגרף G — אף שני קודקודים בקבוצה אינם שכנים}
+ NPNPC
+
+ CLIQUE
+ = {⟨G, k⟩ | קיימת קליקה בגודל k בגרף G — כל שני קודקודים בקבוצה שכנים}
+ NPNPC
+
+ HamPath
+ = {⟨G, s, t⟩ | קיים מסלול המילטוני מ-s ל-t בגרף G — עובר בכל קודקוד בדיוק פעם אחת}
+ NPNPC
+
+ SubsetSum
+ = {⟨S, t⟩ | קיימת תת-קבוצה של S שסכומה שווה ל-t} "עד" = האינדקסים —
+ NPNPC
+
+
+
+
+
סיווג השפות לפי דרגות קושי (מתוך דף נוסחאות)
+
+
+
+
+
מחלקה
+
משמעות בעברית פשוטה ✏️
+
סיווג (מדף נוסחאות)
+
שפות לדוגמה
+
+
+
+
+
R
+
מ"ט עוצרת תמיד — מחזירה "כן" או "לא" בוודאות
+
ניתנות להכרעה
+
+ AnBn, ADFA, AnBn, ADFA
+
+
+
+
RE \ R
+
מ"ט עוצרת ואומרת "כן" — אבל על "לא" עלולה להסתובב לנצח
+
+ ניתנות לקבלה אבל לא להכרעה
+ = ניתנות לקבלה עם משלימה שלא ניתנת לקבלה
+
+
+ ATM, HTM, ETM = NotEmpty
+
+
+
+
co-RE \ R
+
מ"ט עוצרת ואומרת "לא" — אבל על "כן" עלולה להסתובב לנצח
+
לא ניתנות לקבלה אבל משלימה כן ניתנת לקבלה
+
+ ATM, HTM, ETM = NotEmpty
+
+
+
+
Neither
+
אין מ"ט שיכולה לעצור בוודאות — לא על "כן" ולא על "לא"
+
לא ניתנות לקבלה וגם המשלימה לא ניתנת לקבלה
+
+ EQTM, ALLTM, EQTM, ALLTM, INFTM, FINTM
+
+
+
+
+
+
+ 📌 משפט פוסט - חוק הברזל:
+
+
+
+
+ שפה היא כריעה אם ורק אם ניתן גם לקבל אותה וגם לקבל את המשלים שלה.
+ כלומר השפהניתנת לקבלה (RE) וגם המשלים שלה ניתן לקבלה (RE).
+
+
+
+
משפט רייס (Rice's Theorem)
+
כלי להוכחת אי-כריעה (L ∉ R) לתכונות סמנטיות של שפות.
+
+ 3 תנאים לשימוש ברייס:
+
+
התכונה היא על שפת המכונה L(M) (סמנטית), לא על המבנה (כמו "מספר מצבים").
+
התכונה לא טריוויאלית: יש לפחות מ"ט אחת שמקיימת אותה ואחת שלא.
+
הקלט הוא רק המכונה ⟨M⟩ ולא זוג.
+
+ תכלס: שאלות כמו "האם השפה סופית/רגולרית/ריקה" ← לא כריע! (∉ R)
+
+
+
+ הקשר בין CLIQUE ל-IS
+ תהי G גרף ו-Ḡ גרף המשלים שלו (כל קשת שהיתה — הוסרה, וכל קשת שלא היתה — נוספה).
+ משפט: קיימת קליקה בגודל k ב-G ⟺ קיימת קבוצה בלתי-תלויה בגודל k ב-Ḡ.
+ הרדוקציהCLIQUE ≤p IS ו-IS ≤p CLIQUE — אותה פונקציה בשני הכיוונים:
+
השאלה המנחה: כמה בדיקות צריך לעשות כדי לענות "כן" או "לא"?
+
+
+ 🟢 1. חסם על כמות הצעדים ← R
+ אם יש הגבלה על כמות הצעדים בחישוב, ניתן פשוט לסמלץ את הריצה עד החסם ולקבל תשובה ודאית (האם המכונה עצרה בקבלה או לא).
+ דוגמה: "האם המכונה עוצרת תוך 3 צעדים?" – מריצים לכל היותר 3 צעדים. הריצה תמיד תהיה סופית, לכן תמיד ניתן להכריע. השפה ב-R.
+
+
+
+ 🟠 2. חסם על כמות מילים (חיפוש מילים) ← RE \ R
+ כאשר יש הגבלה על כמות המילים שצריך למצוא (למשל קבלת 3 מילים, או קבלת מילה באורך מסוים k).
+ התנהגות: מריצים את המכונה בסימולציה מקבילה (Interleaving) על כל המילים הרלוונטיות בעולם. ברגע שנמצא את הכמות המבוקשת — נעצור ונחזיר Accept. אך אם המילים אינן קיימות, ייתכן שלעולם לא נעצור. לכן ניתן לקבלה, אך לא להכרעה.
+ דוגמאות:L = { ⟨M⟩ | |L(M)| ≥ 3 } או לחלופין L = { ⟨M, k⟩ | M מקבלת מילה באורך k }.
+
+
+
+ 🔴 3. בעיות שלא ניתן לפתור ← Neither
+ שלושה סוגי בעיות שנופלות תמיד ל-Neither — לא ניתנות לקבלה ולא ל-co-RE:
+
+
+
+
+ א. בדיקת הכלה, שוויון, או זיהוי שפה ספציפית
+ לא ניתן לדעת באמצעות סימולציה אם שפת המכונה שווה לשפה ספציפית אחרת, מוכלת בה, או מכילה אותה. תכונות אלו דורשות גם וידוא של "מה המכונה לא מקבלת" — למשל, כדי לאשר L(M1) ⊆ L(M2) צריך לוודא שכל מילה שM1 מקבלת, גם M2 מקבלת, על אינסוף מילים. בדיקת שוויון היא מקרה פרטי — הכלה בשני הכיוונים — ולכן גם היא בלתי כריעה. כל זה זורק את השפה מחוץ ל-RE ול-co-RE — Neither.
+ דוגמאות:L = { ⟨M1, M2⟩ | L(M1) ⊆ L(M2) } , L = { ⟨M1, M2⟩ | L(M1) = L(M2) } , L = { ⟨M⟩ | L(M) = ATM }
+
+
+
+ ב. בדיקה על כל המילים בעולם (= שאלות על גודל השפה או תוכן השפה כולה)
+ אם נצטרך לבדוק את כל המילים בעולם כדי לאשר שהתנאי מתקיים, השפה אינה ניתנת לקבלה. אי אפשר לדעת מתי סיימנו לבדוק כי יש אינסוף מילים, ולכן לעולם לא נגיע לנקודה שבה נוכל להחזיר Accept בביטחון.
+ דוגמאות:L = { ⟨M⟩ | L(M) = Σ* } , L = { ⟨M1, M2⟩ | L(M1) = L(M2) }
+
+
+
+ ג. בדיקת אי-קבלה
+ כדי לוודא שמילה מסוימת לא מתקבלת, נצטרך לבדוק את כל המסלולים האפשריים של המכונה — וייתכן שלעולם לא יסתיימו. לכן גם ה-co-RE לא עוזר כאן, והשפה נופלת ל-Neither.
+ דוגמאות:L = { ⟨M, w⟩ | w ∉ L(M) } , L = { ⟨M, w⟩ | M לא מקבלת את w } , L = { ⟨M⟩ | L(M) = ∅ }
+
+
+
+ ד. בדיקת אי-עצירה (יכול להיות co-RE, לא בהכרח Neither)
+ לעולם לא ניתן לבדוק אם מ"ט M לא עוצרת על w — כדי לדעת זאת, היינו צריכים להריץ אותה עד אינסוף, וזה בלתי אפשרי בזמן סופי. לכן H̄TM ∉ RE — המשלים של בעיית העצירה אינו ב-RE.
+ כלל אצבע: כל שפה שדורשת לוודא "M לא עוצרת / לא מקבלת לנצח" נמצאת לכל הפחות ב-co-RE — ולרוב Neither.
+ דוגמאות:L = { ⟨M, w⟩ | M לא עוצרת על w } , H̄TM
+
+
+
+
+
+
+
עובדות מפתח וטקטיקות "תאכלס"
+
+
1. שפת המכונה תמיד ב-RE
+
לכל מכונת טיורינג M, תמיד מתקייםL(M) ∈ RE
+
+ המלכודת: שאלות שדורשות מ-L(M) להיות שפה שאינה ב-RE (כמו משלים של ATM) — הן בעצם מגדירות קבוצה ריקה של מכונות.
+ דוגמה:L = { ⟨M⟩ | L(M) = משלים(ATM) } → קבוצה ריקה → השפה ב-R
+
+
+
2. שפות טריוויאליות: ∅ ו-Σ*
+
השפה הריקה (∅) והשפה הכוללת (Σ*) הן כריעות (R)
+
+ למה: ניתן לבנות מכונה שתמיד דוחה (עבור ∅) או תמיד מקבלת (עבור Σ*) — שתיהן עוצרות תמיד.
+ חשיבות: אי אפשר לבצע רידוקציה לא-טריוויאלית לשפות אלו — הן לא "מבדילות" בין מקרים.
+ כלל אצבע: אם בניית הרידוקציה מניבה תמיד ∅ או Σ* — בדוק שוב, כנראה טעית.
+
+
+
3. כל שפה רגולרית / חסרת הקשר (ח"ה) ∈ R
+
כל שפה שניתן לזהות ע"י DFA, NFA או דקדוק חסר-הקשר — כריעה
+
+ למה: עבור כל שפה רגולרית/ח"ה קיים אלגוריתם שעוצר תמיד (סימולציה של DFA, או אלגוריתם CYK לח"ה).
+ כלל אצבע: קלט = אוטומט / דקדוק → התשובה = R.
+ דוגמאות: ADFA, ANFA, ACFG — כולן ב-R.
+
+
+
4. שפות כריעות שמתקבלות ע"י מכונה לא-מכריעה
+
יש שפות ב-R שניתן לקבל גם ע"י מכונה שאינה מכריעה (נתקעת על חלק מהמילים)
+
+ הסבר: "כריעות" פירושה שקיימת מכונה שעוצרת תמיד — אבל זה לא מונע קיום מכונה נוספת, לא-מכריעה, שמקבלת אותה שפה ונתקעת על מילים שאינן בשפה.
+ דוגמה: מ"ט שמסמלצת מכונה אחרת לנצח על "לא" — מקבלת שפה כריעה, אך היא עצמה אינה מכריעה.
+
+
+
5. סגירות R תחת חיתוך ואיחוד
+
אם L₁ וגם L₂ ניתנות להכרעה, אז גם L₁ ∪ L₂ וגם L₁ ∩ L₂ ניתנות להכרעה
+
+ הסבר: ניתן להריץ את שני הדסידרים ברצף ולהחליט לפי תוצאותיהם — כל ריצה עוצרת, ולכן גם השילוב עוצר.
+ הרחבה:R סגורה גם תחת משלים, שרשור וכוכב. RE סגורה תחת הכל חוץ ממשלים.
+ כלל אצבע: המרת הפרש: B \ A = B ∩ Ā — אם A ∈ R אז Ā ∈ R, וחיתוך RE עם R נותן RE.
+ דוגמה:L = ATM \ Lreg → התוצאה: RE \ R
+
+
+
6. טריק ההצבה — שפות קצה להפרכת טענות
+
+ כששואלים "לאיזו מחלקה שייכת התוצאה של פעולה בין קבוצות?" — השתמשו ב-∅ וב-Σ* כדי לפסול תשובות!
+ שתיהן שפות טריוויאליות ששייכות ל-R. הצבה שלהן כנעלמים חושפת מיד את גבולות הגזרה של התוצאה.
+
+ תרגיל קלאסי: נתון A ∈ R וגם B ∈ RE \ R. מה ניתן לומר על B \ A?
+
+
הצבה 1: נבחר A = ∅ (חוקי, כי ב-R). נקבל B \ ∅ = B. התוצאה יכולה להיות RE \ R — פוסל טענה שהתוצאה חייבת להיות ב-R.
+
הצבה 2: נבחר A = Σ* (חוקי, כי ב-R). נקבל B \ Σ* = ∅. התוצאה יכולה להיות R — פוסל טענה שהתוצאה חייבת להיות RE \ R.
+
+ מסקנה: מכיוון שהתוצאה יכולה להיות גם וגם, החסם הכולל הנכון הוא RE — לא ניתן לצמצם יותר.
+
+
+
+
+
+
+
+
+
+
+
פרק 4: רידוקציות (Reductions) –
+
+
+ רידוקציה היא הדרך שלנו להשוות בין רמות קושי של בעיות. בחישוביות, אנו משתמשים ב"תרגום" בעיה A לבעיה B כדי להוכיח ש-Bקשה לפחות כמו A. זהו הנושא המרכזי והמאתגר ביותר במבחן.
+
+
+
הגדרת רידוקציית מיפוי (A ≤m B)
+
+
קיימת רידוקציה מ-A ל-B אם קיימת פונקציה f המקיימת שני תנאים:
+
+
ניתנת לחישוב (Computable): קיימת מ"ט שעוצרת תמיד ומחשבת את הפלט f(x) (עריכת קוד בלבד — ללא סימולציה!).
+
+ חוקי (ניתן לחישוב): פונקציה שבודקת האם קלט הוא אוטומט (DFA) תקין — בדיקה כריעה שניתן לבצע בזמן סופי.
+
+ פסול (לא ניתן לחישוב): פונקציה שבודקת האם M מקבלת את w — בלתי אפשרי! דורשת פתרון לבעיית העצירה.
+ אי אפשר לבדוק אי עצירה.
+
+
+
שימור התשובה (Iff):x ∈ A ⇔ f(x) ∈ B — חובה להוכיח בשני כיוונים:
+
+
כיוון חיובי: אם x ∈ A ⇒ f(x) ∈ B
+
כיוון שלילי: אם x ∉ A ⇒ f(x) ∉ B
+
+
+
+
+
+
אלגוריתם העבודה: איך ניגשים לשאלת הוכחת/פסילת רידוקציה?
+
כשמציגים לכם פונקציה f (שמייצרת מכונה Q) ושואלים האם היא רידוקציה, עבדו תמיד לפי השלבים הבאים:
+
+
בדיקת מחלקות קושי (פסילת בזק): האם הרידוקציה חוקית מבחינת היררכיה? (אי אפשר להעביר מ-Neither ל-RE).
+
בדיקת הכיוון החיובי (∈ ⇒ ∈): הניחו שהקלט תקין (כגון: M עוצרת על w). האם L(Q) מקיימת את דרישת שפת היעד? (חייב לצאת כן).
+
בדיקת הכיוון השלילי (∉ ⇒ ∉): הניחו שהקלט פגום (כגון: M נתקעת בלולאה). האם L(Q) עדיין מקיימת את תנאי היעד? (כדי שהרידוקציה תעבוד, התשובה חייבת להיות לא).
+
+
+
+
דוגמה מלאה מתוך מבחן: ניתוח שלב-אחר-שלב
+
+
+
+ השאלה: נתונה השפה L = { ⟨M⟩ | L(M) ⊆ PALINDROMES }.
+ מנסים להוכיח כי L ∉ RE בעזרת רדוקציה:
+ HTM ≤m L.
+ מוצעת הפונקציה f(⟨M,w⟩) = ⟨Q⟩, כאשר Q על קלט x:
+
+ if x ∈ PALINDROMES then { M(w); ACCEPT }
+ else REJECT
+
+ המשימה: האם f היא רדוקציה חוקית?
+
+
+
+
+ שלב 1 — הנתונים ותרגום ליעד ה-Iff:
+
+
+ הנתונים ומשמעותם:
+
+
HTM = { ⟨M,w⟩ | M לא עוצרת על w } — שפת הזוגות שבהם המכונה נתקעת בלולאה. שייכת ל-Neither.
+
L = { ⟨M⟩ | L(M) ⊆ PALINDROMES } — שפת כל המכונות שהשפה שלהן מוכלת בפלינדרומים. (השפה שרוצים להוכיח שהיא ∉ RE).
+
הרידוקציה המוצעת: f(⟨M,w⟩) = ⟨Q⟩ — בונה מכונה Q שמשלבת בדיקת פלינדרום עם ריצת M(w).
+
+
+
קלט חוקי:f מקבלת ⟨M, w⟩ — הפורמט תואם את שפת המקור HTM. ✓
+ ההנחה במילים:Mנתקעת בלולאה אינסופית על w — כלומר ⟨M,w⟩לא שייך ל-HTM (שפת המכונות שעוצרות), לכן שייך ל-HTM.
+ מה לבדוק לפי השאלה: האם L(Q) ⊆ PALINDROMES? (כי זו דרישת שפת היעד L).
+
ננתח את Q(x) לכל קלט:
+ • x ∉ PAL: Q דוחה מיד.
+ • x ∈ PAL: Q מריצה M(w) — M נתקעת, לכן Qנתקעת גם היא ולא מקבלת.
+
+ ✓ מסקנה: L(Q) = ∅, וכיוון שהקבוצה הריקה מוכלת בכל קבוצה — ⟨Q⟩ ∈ L. הכיוון החיובי עובר.
+
+
+
+
+
+
+ שלב 3 — כיוון שלילי (∉ ⇒ ∉)
+
+ הנחה: ⟨M,w⟩ ∉ HTM
+ ►
+ להוכיח: ⟨Q⟩ ∉ L
+
+
+ ההנחה במילים:Mעוצרת על w — כלומר ⟨M,w⟩שייך ל-HTM, ולכן לא שייך ל-HTM.
+
ננתח את Q(x) לכל קלט:
+ • x ∉ PAL: Q דוחה.
+ • x ∈ PAL: Q מריצה M(w) — M עוצרת, לכן Q עוצרת ומגיעה ל-ACCEPT.
+
+ ✗ מסקנה: L(Q) = PAL, ולכן ⟨Q⟩ ∈ L — גם כשהקלט פגום! הכיוון השלילי נכשל.
+
+
+
+
+
+
+ מסקנה: הרדוקציה פסולה — הכיוון השלילי אינו מתקיים. כדי לתקן, צריך שכאשר M עוצרת, Q תניב L(Q) ⫅̸ PAL.
+
+
+
+
תכונות של רידוקציית מיפוי
+
+
+
משפטי הרדוקציה הבסיסיים (הורשת קושי וקלות)
+
בהינתן שקיימת רדוקציה A ≤m B, מתקיימים 4 הכללים הבאים:
+
+
הורשת קלות ל-R: אם B ∈ R אזי A ∈ R. (B היא חסם עליון — אם היא "קלה", גם A קלה).
+
הורשת קלות ל-RE: אם B ∈ RE אזי A ∈ RE.
+
הורשת קושי מ-R: אם A ∉ R אזי B ∉ R. (A היא חסם תחתון — אם היא "קשה", גם B קשה).
+
הורשת קושי מ-RE: אם A ∉ RE אזי B ∉ RE.
+
+
+ אינטואיציה: פתרו את B ← פתרתם את A. נתקעתם ב-A ← תיתקעו גם ב-B.
+
+ דגש קריטי: היחס A ≤m Bבפני עצמו לא נותן מידע! כדי להסיק מסקנה (כגון "B לא ב-R"), חייב לדעת קודם ש-A לא ב-R.
+
+
+
+
+ סימטריה של משלים:
+ A ≤m B ⇔ A≤mB
+ אותה פונקציה f ששומרת "כן/לא" תשמור גם על "לא/כן".
+
+ משפט מהדף נוסחאות
+ A ≤m B ⇔ A ≤mB
+
+
+
+
+ הרידוקציה אינה סימטרית:
+ A ≤m B אינו גורר B ≤m A
+ רידוקציה היא חסם — A"קל לא יותר מ-B", אך B יכולה להיות קשה בהרבה.
+ דוגמה:ATM ≤m ALLTM, אך ALLTM ≰m ATM (ALLTM ∈ Neither, קשה יותר מ-RE).
+
+
+
+ טרנזיטיביות:
+ אם A ≤m B וגם B ≤m C, אז A ≤m C
+
+
+
+ שפות ב-R הן הקלות ביותר:
+ מכל שפה A ∈ R קיימת רידוקציה לכל שפה B שאינה טריוויאלית (B ≠ ∅ וגם B ≠ Σ*).
+ כלומר: לכל A ∈ R ו-B לא טריוויאלית — A ≤m B.
+
+ משפט מהדף נוסחאות
+ אם A ∈ R ואם B שפה כלשהי כך ש-B ≠ ∅ וגם B ≠ Σ*, אז A ≤m B מתקיים.
+
+
+
+
+
ארגז הכלים למבחן: מלכודות נפוצות ודוגמאות אמיתיות
+
+
🚫 מלכודת הלולאה האינסופית (Call to M(w))
+
+ הכלל: אם המכונה Q מריצה את M(w) בתוכה — אם Mנתקעת, גם Q נתקעת לעד!
+ נתקעות ≠ דחייה — לא ניתן להסיק "דחה" מתוך "לא הגעתי לקבלה".
+
+
+ דוגמה ממבחן
+
רידוקציה מ-ATM לשפה "קבלת אינסוף ראשוניים". מכונה T:
+ "אם הקלט אינו ראשוני ← קבל. אם ראשוני ← הרץ M(w) ואז דחה."
+
+ למה נכשלת: בכיוון החיובי — M לא מקבלת (עלולה להיתקע). לראשוני, T תריץ M(w)ותיתקע איתה — לא תגיע ל"דחה". שפת T = 0 ראשוניים. הכיוון החיובי נשבר.
+
+
+
🌍 מלכודת הכל-יכול (Σ*) וסכנת המעקף
+
+ הכלל: ענף "קבל מיד" לתנאי קבוע — מילים אלו תמיד יהיו בשפה, ללא קשר להתנהגות M.
+ זה עלול לגרום ל-L(Q) = Σ* גם כשהמקור אינו בשפה.
+
+
+ דוגמה ממבחן
+
רידוקציה מ-HTM לשפה "קבלת אינסוף פלינדרומים". מכונה Q:
+ "אם פלינדרום ← קבל מיד. אחרת ← הרץ M(w), אם עצרה קבל."
+
+ למה נכשלת: בכיוון השלילי — M כן עוצרת. לפלינדרומים Q מקבלת מיד; לשאר — M עוצרת ו-Q מקבלת גם אותם. סה"כ: L(Q) = Σ*. הכיוון השלילי נשבר.
+
+
+
📐 מלכודות תנאי יעד: אמת ריקה וזמן סימולציה
+
+
+ 1. אמת באופן ריק (Vacuous Truth)
+ הכלל: כאשר שפת היעד מכילה תנאי בסגנון "לכל מילה שמתקבלת, מתקיים ש..." — מכונה שהשפה שלה ריקה (∅) תקיים את התנאי תמיד בטעות, כי אין אף מילה שתפר אותו.
+
+
+ הסכנה
+
זה כמעט תמיד הורס את הכיוון השלילי ברדוקציה: קלט פגום שמוביל לסירוב גורף מייצר L(Q) = ∅, שנכנסת לשפת היעד בניגוד למצופה — ו-⟨Q⟩ נמצאת ב-L למרות שהקלט פגום.
+
+
+
+ 2. מלכודת זמן הסימולציה (Simulation Overhead)
+ הכלל: כאשר שפת היעד דורשת שמכונה תסיים חישוב תחת חסם צעדים מדויק ונוקשה (למשל, עוצרת תוך 2|w| צעדים).
+
+
+ הסכנה
+
פונקציית רדוקציה שבונה מכונה העוטפת בתוכה מכונה אחרת (if/else + סימולציה) תמיד מוסיפה צעדי עבודה פנימיים (בדיקת קלט, מעבר מצבים). עבור מילה כמו ε, החסם הנדרש יכול להיות צעד אחד בלבד, ואילו המכונה המדומה תמיד תחרוג ממנו — זה יהרוס את הכיוון החיובי!
+
+
+
🛑 פסילת בזק עפ"י מחלקות קושי (Class Mismatch)
+
+ הכלל: ברידוקציה A ≤m B, שפת B היא חסם עליון לקושי של A.
+ לא ניתן לרדד שפה קשה לשפה קלה ממנה.
+ דגש: לא ניתן לבצע רידוקציה משפה שאינה ניתנת לקבלה (co-RE / Neither) לשפה שניתנת לקבלה (RE) — co-RE קשה יותר מ-RE.
+
+
+ דוגמה ממבחן
+
האם תיתכן רידוקציה S1TM ≤m HTM?
+
+ פסילה בשנייה:HTM ∈ RE, אך S1TM ∈ Neither — קשה יותר מ-RE. לא ניתן לרדד קשה לקל. הטענה נפסלת מיד!
+
+
+
🎯 מלכודת פונקציית הזהות (f(x)=x)
+
+ הכלל: פונקציית הזהות כרידוקציה כמעט תמיד שגויה. קיימים שני סוגי כשלים:
+
+
+
+
+ כשל תחבירי — פורמט שונה:
+ ATM מקבל ⟨M, w⟩ אך ALLTM מקבל ⟨M⟩ — אי-התאמת פורמט = פסול מיידי.
+
+
+ כשל לוגי — עצירה ≠ קבלה:
+ מכונה שדוחה הכל עוצרת (∈ H*TM) אך לא מקבלת (∉ ALLTM) — הזהות לא מגשרת על הפער.
+
+
+
+
+
🎩 מלכודת פונקציית הקסם המותנית (Piecewise Functions)
+
+ הכלל: פונקציה המוגדרת בתנאי של "אם w ∈ A החזר x, אחרת החזר y" — חייבת ש-A תהיה כריעה (R) כדי להיות ניתנת לחישוב!
+
+
+ דוגמה קלאסית ממבחן
+
נתונה שפה A ∉ R (לא ניתנת להכרעה). נגדיר פונקציה:
+ f(w) = { x if w ∈ A ; y if w ∉ A }
+
+ למה פונקציה כזו לא ניתנת לחישוב?
+ כדי לחשב פונקציה, המכונה המחשבת חייבת לעצור תמיד ולפלוט את התשובה. מכיוון ש-A לא כריעה, אם המכונה תקבל מילה w ∉ A, היא עלולה להיתקע בלולאה אינסופית כשתנסה לברר זאת (כי לא ניתן לוודא אי-עצירה בזמן סופי). אם היא נתקעת, היא לעולם לא תפלוט את y.
+ מסקנה: אי אפשר להתנות פלט של פונקציית רידוקציה בהשתייכות לשפה שאינה ב-R!
+
+
+
+ 🔀 מלכודת הלוגיקה (היפוך מול שלילה):
+ במבחנים, מרצים אוהבים לקחת טענה נכונה שהוכחתם ולתת מיד אחריה את הטענה ההפוכה כדי לבלבל. נניח שהטענה המקורית היא:
+
+ A ⇒ B (טענה מקורית)
+
+
+
+
✅ קונטרה-פוזיטיב — מותר
+
+ B
+ ⇒
+ A
+
+
שלילה + היפוך הכיוון. תמיד נכון — אין צורך להוכיח מחדש.
+
+
+
❌ כשל ההיפוך — אסור
+
+ A
+ ⇒
+ B
+
+
שלילה בלבד — ללא היפוך הכיוון. שגוי! כמעט תמיד קיימת דוגמה נגדית.
+
+
+
+ דוגמה ממבחן (שאלות 15 ו-19):
+
+
+ הטענה המקורית (שהוכחה כנכונה):
+ "אם M ∈ ETM אז התוצאה ∈ L1"
+ — מבנה של A ⇒ B.
+
+
+ המלכודת בשאלה העוקבת:
+ "אם M ∉ ETM אז התוצאה ∉ L1"
+ — מבנה של A ⇒ B.
+
+
+ ההפרכה — למה זו טעות:
+ ניתן לבנות מכונה M"עצלנית" שמקבלת מילה אחת אך לוקח לה 50 צעדים.
+ בגלל האיטיות, רדוקציה שבודקת אותה תפספס את הקבלה, החיתוך יישאר ריק, והתוצאה
+ כן תיכנס ל-L1
+ למרות ש-M ∉ ETM.
+ הטענה מופרכת!
+
+
+
+
+
+
+
+
+
+
פרק 5: סיבוכיות זמן (Time Complexity) ומחלקות P ו-NP
+
+
+ כעת אנו עוברים מן השאלה "האם קיים פתרון?" לשאלה "האם קיים פתרון יעיל?". בחלק זה של הקורס אנו מתמקדים בבעיות שניתנות להכרעה (בשפות R), אך בודקים את כמות המשאבים הנדרשים — בעיקר זמן חישוב, כלומר מספר צעדי המכונה כפונקציה של גודל הקלט.
+
+
+
מבוא: מחישוביות לסיבוכיות
+
+
זמן חישוב מוגדר בתור מספר צעדי המכונה מקונפיגורציית ההתחלה עד לקונפיגורציית עצירה.
+
סיבוכיות זמןT(n) מתארת את מספר הצעדים הגרוע ביותר במקרה הקשה ביותר כפונקציה של גודל הקלט n.
+ דוגמה: חיפוש בעץ בינארי — המקרה הגרוע הוא כשהאלמנט נמצא בעלה הרחוק ביותר. T(n) = O(log n).
+
+
+
+
+
+
+ היררכיית מחלקות הסיבוכיות:
+
+
+ השפות הכריעות — עוצרות תמיד
+ R
+
+
+ ניתנות לווידוא פולינומי
+ NP
+
+
+ הקשות ביותר — מוכלות במלואן בתוך NP (נפרדות מ-P בהנחה ש-P≠NP)
+ NPC
+
+
+ פתרון דטרמיניסטי פולינומי
+ P
+
+
+
+ הנחה: אם P ≠ NP, אז NPC ∩ P = ∅ — קיימת בעיה ב-NPC שאינה פתירה פולינומית.
+
+
+
+
+
תכונות סגירות של מחלקות הסיבוכיות
+
+
+
+
+
+
פעולה
+
P
+
NP
+
NPC
+
+
+
+
+
איחוד (A ∪ B)
+
✓ כן
+
✓ כן
+
✗ לא *
+
+
+
חיתוך (A ∩ B)
+
✓ כן
+
✓ כן
+
✗ לא *
+
+
+
משלים (A)
+
✓ כן
+
? לא ידוע
+
✗ לא
+
+
+
שרשור (A · B)
+
✓ כן
+
✓ כן
+
✗ לא *
+
+
+
כוכב קליני (A*)
+
✓ כן
+
✓ כן
+
✗ לא *
+
+
+
+
+
+ הערות:
+
+
* — אם שני האיברים ב-NPC, התוצאה בדרך כלל אינה ב-NPC.
+
משלים ב-NP: לא ידוע האם NP סגורה למשלים — מאוד לא סביר שכן (P ≠ NP). דגש: אם P = NP אז בהכרח מתקיים A ∈ NP לכל A ∈ NP.
+
+
+
+
הרובוסטיות של מודל הטיורינג בסיבוכיות
+
בחישוביות ראינו שמודלים שונים של מ"ט שקולים בכוחם. בסיבוכיות, קיים הבדל ביעילות ביניהם, אך ההבדל הוא פולינומי בלבד.
+
+
+ דוגמה: העתקת מחרוזת באורך n
+
+
מ"ט עם 3 סרטים:O(n) צעדים (כתיבה ישירה)
+
מ"ט עם סרט אחד:O(n²) צעדים (תנועה הלוך ושוב)
+
+ מסקנה: גדל הפרש של פולינום (n² לעומת n), אך שניהם פולינומיים!
+
+
+
+ משפט חשוב: אם שפה L ניתנת להכרעה בזמן O(t(n)) על ידי מ"ט דטרמיניסטית מרובת סרטים, אז קיימת מ"ט דטרמיניסטית עם סרט יחיד המכריעה אותה בזמן O(t(n)²).
+
+ מסקנה:זמן פולינומי נחשב ליעיל, והוא נשמר (עד כדי העלאה בחזקה) בין כל המודלים הדטרמיניסטיים. זה מצדיק את בחירת הפולינום ככותר בין "יעיל" ל"לא יעיל".
+
+
+
🔵 המחלקה P (Polynomial Time)
+
+
+
🔵 הגדרה:
+
+ המחלקה P היא אוסף כל השפות שניתנות להכרעה על ידי מ"ט דטרמיניסטית (DTM) בזמן ריצה פולינומי — כלומר O(nk) לאיזה קבוע k.
+
+
+ P = {L | ∃ DTMM, ∃ k: M מכריעה L בזמן O(nk)}
+
+
+
+
+
דוגמאות לשפות ב-P:
+
+
+ PATH
+ = { ⟨G, s, t⟩ | G גרף מכוון, קיים מסלול מ-s ל-t } BFS/DFS — O(n²) —
+
+ PALINDROMES
+ = { w | w שווה להיפוך שלה } O(n) —
+
+ PRIME
+ = { ⟨n⟩ | n הוא מספר ראשוני } אלגוריתם AKS (2002) —
+
+ AnBn
+ = { anbn | n ≥ 0 } O(n) —
+
+ GCD
+ = { ⟨a, b, d⟩ | d הוא המחלק המשותף הגדול של a ו-b } אלגוריתם אוקלידס — O(log n) —
+
+
+
+
+
🟣 המחלקה NP (Non-Deterministic Polynomial Time)
+
+
+
🟣 הגדרה 1 — דרך אי-דטרמיניסטית:
+
+ אוסף כל השפות שקיימת עבורן מ"ט אי-דטרמיניסטית (NDTM) המכריעה אותן בזמן פולינומי. זמן החישוב מוגדר לפי עומק העץ (המסלול הארוך ביותר), לא סכום כל הענפים.
+
+
+ NP = {L | ∃ NDTMM, ∃ k: M מכריעה L בזמן פולינומי O(nk)}
+
+
+
+
+
🟣 הגדרה 2 — דרך מוודא (Verifier):
+
+ אוסף השפות שניתן לוודא את נכונות הפתרון שלהן בזמן פולינומי. אם מספקים לנו "עד" (certificate), מ"ט דטרמיניסטית יכולה לבדוק בזמן פולינומי האם הוא נכון.
+
+ הקשר בין NDTM לזמן דטרמיניסטי:
+ אם קיימת NDTM המכריעה שפה בזמן O(t(n)), אזי קיימת DTM המכריעה אותה בזמן אקספוננציאלי2O(t(n)).
+ ההסבר: המ"ט הדטרמיניסטית חייבת לחקור את כל ענפי העץ האי-דטרמיניסטי — וגודלו אקספוננציאלי בעומק.
+
+
+
+
דוגמאות לשפות ב-NP (כולן גם NPC — ה"עד" מאפשר ווידוא פולינומי):
+
+
+ SAT
+ = { ⟨φ⟩ | φ ספיקה בצורת CNF } "עד" = השמת ערכים —
+
+ 3SAT
+ = { ⟨φ⟩ | φ ספיקה בצורת 3-CNF } "עד" = השמת ערכים —
+
+ CLIQUE
+ = { ⟨G, k⟩ | קיימת קליקה בגודל k בגרף G } "עד" = רשימת הקודקודים —
+
+ IS
+ = { ⟨G, k⟩ | קיימת קבוצה בלתי-תלויה בגודל k } "עד" = רשימת הקודקודים —
+
+ HamPath
+ = { ⟨G, s, t⟩ | קיים מסלול המילטוני מ-s ל-t } "עד" = סדר הקודקודים —
+
+ VC
+ = { ⟨G, k⟩ | קיים כיסוי קודקודים בגודל k } "עד" = רשימת הקודקודים —
+
+ SubsetSum
+ = { ⟨S, t⟩ | קיימת תת-קבוצה של S שסכומה שווה ל-t } "עד" = האינדקסים —
+
+
+
+
+
היחס בין P ו-NP
+
+
+ 🌟 P ⊆ NP:
+ כל שפה שניתנת לפתרון יעיל דטרמיניסטית ניתנת גם לווידוא יעיל. הסיבה: אם יש דסידר, אפשר להשתמש בו כמוודא בלי צורך בעד.
+
+ ❓ האם P = NP?
+ זו השאלה הפתוחה המפורסמת ביותר במדעי המחשב (בעיה מילניום ב-Clay Mathematics Institute — פרס של מיליון דולר).
+ דגש: אם P = NP אז בהכרח מתקיים A ∈ NP לכל A ∈ NP (כי P סגורה למשלים).
+
+
+
🔴 המחלקה NPC (NP-Complete / NP-שלמות)
+
+
+
🔴 הגדרה:
+
+ נאמר ששפה L היא NP-שלמה (שייכת ל-NPC) אם מתקיימים שני התנאים הבאים:
+
+
+
L∈ NP: השפה עצמה שייכת ל-NP (ניתנת לווידוא פולינומי)
+
∀A ∈ NP: A ≤p L — כל שפה ב-NP ניתנת לרדוקציה פולינומית ל-L
+
+
+ משמעות:L היא "הקשה ביותר" בתוך NP. פתרון יעיל לבעיה אחת מ-NPC יבטיח פתרון יעיל לכל בעיות NP.
+
+
+
+
+
דוגמאות לשפות ב-NPC (NP-Complete) — מתוך דף נוסחאות:
+
+
+ SAT
+ = { ⟨φ⟩ | φ היא נוסחא ספיקה בצורת CNF }
+
+ 3SAT
+ = { ⟨φ⟩ | φ היא נוסחא ספיקה בצורת 3-CNF }
+
+ CLIQUE
+ = { ⟨G, k⟩ | G הוא גרף לא-מכוון, k מספר טבעי כך ש: קיימת ב-G קליקה בגודל k }
+
+ IS
+ = { ⟨G, k⟩ | G הוא גרף לא-מכוון, k מספר טבעי כך ש: קיימת ב-G קבוצה בלתי-תלויה בגודל k }
+
+ HamPath
+ = { ⟨G, s, t⟩ | G הוא גרף לא-מכוון, s,t קודקודים ב-G כך ש: יש ב-G מסלול המילטוני מ-s אל t }
+
+
+
+ קליקה בגרף: קבוצת קודקודים C כך שכל שני קודקודים מ-C הם שכנים.
+ קבוצה בלתי-תלויה (ב"ת) בגרף: קבוצת קודקודים S כך שאין ב-S אף זוג קודקודים שכנים.
+ מסלול המילטוני בגרף: מסלול פשוט שמבקר בכל קודקודי הגרף (מסלול פשוט — לא מבקר באף קודקוד יותר מפעם אחת).
+
+
+
+
איך מוכיחים ששפה חדשה היא NPC?
+
+
+ שיטת השרשור (Chaining):
+
+ אם ידוע ששפה B שייכת ל-NPC, וגם נתון שהשפה החדשה A שייכת ל-NP, אז מספיק להראות שמתקיימת הרדוקציה B ≤p A כדי להוכיח ש-A שייכת ל-NPC.
+
+ כלל חשוב: תמיד מרדקטים מהבעיה הידועה (B) אל הבעיה החדשה (A), לא ההפך!
+
+
+
משפטים קריטיים על NPC 📄 מדף הנוסחאות
+
+
+
🔴 משפט 1: קריסת המחלקות(מדף הנוסחאות)
+
+ אם שפה כלשהי A שייכת לשתי המחלקות (A ∈ NPC וגם A ∈ P), אזי בהכרח P = NP.
+
+
+ הוכחה קצרה: אם A ∈ NPC, כל בעיה ב-NP ניתנת לרדוקציה אליה. אם גם A ∈ P, אז כל בעיה ב-NP ניתנת לפתרון ב-P (בעזרת הרדוקציה והדסידר). לכן P = NP.
+
+
+
+
+
🔴 משפט 2: חיתוך המחלקות(מדף הנוסחאות)
+
+ P = NP ⟺ P ∩ NPC ≠ ∅
+
+
+ כלומר: P שווה ל-NP אם ורק אם קיימת בעיה שהיא גם NP-שלמה וגם ב-P (בהנחה ש-P ≠ NP, זה לא קורה).
+
+
+
+
רדוקציה פולינומית (A ≤p B)
+
+
+ הגדרה: שפה A ניתנת לרדוקציה פולינומית לשפה B
+ (A ≤p B)
+ אם קיימת פונקציה f שניתנת לחישוב בזמן פולינומי כך שלכל מילה x מתקיים:
+
+
+ x ∈ A ⟺ f(x) ∈ B
+
+ הרדוקציה מתארת חסם עליון: אם B ניתנת לפתרון יעיל, אז גם A ניתנת לפתרון יעיל.
+
+
+
+
משפטי הרדוקציה הפולינומית:
+
+
הורשת קלות: אם A ≤p B וגם B ∈ P, אזי A ∈ P. (כנ"ל לגבי NP).
+
הורשת קושי: אם A ≤p B וגם A ∉ P, אזי B ∉ P. (כנ"ל לגבי NP).
+
טרנזיטיביות: אם A ≤p B וגם B ≤p C, אזי A ≤p C.
+
אי-סימטריה כללית:A ≤p B אינו גורר ש-B ≤p A — אלא אם שניהם ב-NPC.
+
+
+
+
+ רדוקציות בין שפות NPC ובין שפות P (בהנחת P=NP):
+
+ 1. בין כל שתי שפות NPC — לכל A, B ∈ NPC מתקיים תמיד:
+
+ A ≤p B וגם B ≤p A
+
+ כל שפות ה-NPC שקולות בקושי — מכיוון שכל שפה ב-NP ניתנת לרדוקציה לכל שפה ב-NPC.
+
+ 2. בין כל שתי שפות לא-טריוויאליות ב-P, בהנחה ש-P = NP:
+
+ A ≤p B וגם B ≤p A
+
+ הסבר: אם P = NP, אז כל שפה לא-טריוויאלית ב-P היא גם NPC — ולכן כולן מצמצמות אחת לשנייה.
+
+
+
+
דוגמאות לרדוקציות ידועות:
+
+
Clique ≤p IS וגם IS ≤p Clique: שקולות בקושי — עוברים מגרף לגרף המשלים
+
HAMPATH ≤p SAT: בדיקת מסלול המילטוני ניתנת לקידוד כנוסחה בוליאנית
+
3SAT ≤p Clique: ניתן לעבור מנוסחה בוליאנית לבעיית הקליקה
+
+
+
+
עובדות וטריקים למבחן
+
+
+ כל שפה ב-P היא גם ב-NP:
+ וידוא ישיר בלי צורך בעד. אם יש דסידר דטרמיניסטי — הוא עצמו הוא המוודא.
+
+
+
+ אם בעיה אינה ב-NP, היא בוודאות לא ב-NPC:
+ כי NPC ⊂ NP בהגדרה. אם בעיה קשה לוודא אפילו עם עד — היא אינה NP-שלמה.
+
+
+
+ לא ניתן לרדד מ-NPC לבעיה קטנה יותר:
+ בעיות NPC הן "קשות אל הקצה" — אם B ∈ NPC ו-A ≤p B, זה לא אומר שום דבר חדש על A אלא אם A מובטחת כ-NP גם כן.
+
שים לב: NPC אינה ההכי קשה בכל העולם — קיימות שפות מחוץ ל-R (כמו ALLTM, EQTM) שקשות בהרבה מ-NPC. NPC היא רק הקשה ביותר בתוך NP.
+
+
+
+ בנייה פולינומית בתוך רדוקציה:
+ כשמרדקטים בעיה מ-NPC לבעיה חדשה, הרדוקציה אמורה לתרגם את הקלט בזמן פולינומי, לא לפתור את הבעיה. רדוקציה היא "תרגום" + "הוספת משהו חכם", לא "סימולציה".
+
+ דוגמה נכונה: מ-SAT ל-3-SAT: ממירים clause עם 5 ליטרלים ל-clause בגודל 3 — בזמן פולינומי. לא פותרים את SAT.
+
+
+
+ מלכודת הפרמטר הקבוע (Fixed Parameter):
+ אם הפרמטר קבוע מראש (כמו CLIQUE2024 — האם יש קליקה בגודל 2024), השפה בהכרח ב-P — ללא קשר לכך שבעיית CLIQUE הכללית היא NPC.
+ למה? עוברים על כל תתי-הקבוצות בגודל k בזמן O(nk). מכיוון ש-k קבוע — זמן פולינומי, והשפה ב-P!
+
+
+
+ כוחה של ההגדרה (רדוקציה בחינם):
+ אם נתון שפה C ∈ NPC ושפה A ∈ NP, מתקיים תמיד ובהכרחA ≤p C.
+ זהו פשוט ציטוט של הגדרת NPC — "כל בעיה ב-NP ניתנת לרדוקציה פולינומית אליה". אין צורך להוכיח, זה נכון מעצם ההגדרה.
+
+
+
+ עירוב חישוביות וסיבוכיות (≤m מול ≤p):
+ כל מחלקות הסיבוכיות (P, NP, NPC) נמצאות עמוק בתוך מחלקת R.
+ לכן, כל שפה L ∈ NP היא כריעה, ולכן L ≤m HTM (אם L לא טריוויאלית).
+ שימו לב: הרדוקציה כאן היא רדוקציית מיפוי (≤m), לא פולינומית! אי אפשר לרדקט פולינומית בעיה כריעה לבעיה בלתי כריעה.
+
+
+
+ פעולות בין שפות ממחלקות שונות:
+ כאשר מבצעים פעולה (כמו איחוד או חיתוך) על שפות ממחלקות שונות, למשל L1 ∈ NPC ו-L2 ∈ P:
+ הורידו את שתיהן למכנה המשותף הרחב ביותר שידוע שהן שייכות אליו וסגור לפעולה. במקרה הזה, שתיהן ב-NP, ו-NP סגורה לאיחוד/חיתוך. לכן בוודאות L1 ∪ L2 ∈ NP.
+ אי אפשר להבטיח שהתוצאה תישאר ב-NPC (כי אם L_2 היא Σ* למשל, האיחוד יהיה Σ*, שהיא בכלל ב-P).
+
+
+
+ רדוקציה פולינומית גוררת רדוקציית מיפוי (אבל לא להפך!):
+ אם מתקיים A ≤p B, אז בהכרח מתקיים גם A ≤m B.
+ למה? כי אם קיימת פונקציית רדוקציה שרצה בזמן פולינומי, היא בוודאות רצה בזמן סופי — כלומר, היא כריעה וניתנת לחישוב.
+ הכיוון ההפוך שגוי: יכולה להיות פונקציית מיפוי כריעה שלוקח לה זמן אקספוננציאלי לרוץ — לכן היא תהיה ≤m תקינה, אך לא≤p.
+
+
+ A ≤p B
+ ⟹
+ A ≤m B
+
+ אבל לא להפך!
+
+
+
+
+ 🔗 הקשר בין CLIQUE ל-IS (Independent Set):
+ תהי G גרף ו-G גרף המשלים שלו (כל קשת שהייתה — הוסרה, וכל קשת שלא הייתה — נוספה).
+
+ משפט: קיימת קליקה בגודל k ב-G
+ ⟺
+ קיימת קבוצה בלתי-תלויה בגודל k ב-G.
+
+ הרדוקציה:
+ IS ≤p CLIQUE
+ ו-
+ CLIQUE ≤p IS
+ — אותה פונקציה בשני הכיוונים:
+
+ 
+ 
+