1. No category

‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫מודלים חישוביים – פתרון תרגיל ‪2‬‬
‫‪.1‬‬
‫הוכח את הגרסה היותר כללית למשפט רייס בו סמנטיקה מוגדרת להיות שקילות בשפה‪ .‬כלומר‬
‫אם )‪ L(p1)=L(p2‬אז )‪.P(p1)=P(p2‬‬
‫הוכחה‪:‬‬
‫נחלק את הבעיות הלא‪-‬טריוויאליות והסמנטיות ל‪ 2-‬סוגים‪ :‬סוג א' וסוג ב'‪ .‬בעיות מסוג א' הן‬
‫בעיות שמחזירות ‪ F‬עבור התוכנית שמתבדרת לכל קלט )‪ .(loopy‬ובעיות מסוג ב' הן בעיות‬
‫שמחזירות ‪ T‬עבור התוכנית שמתבדרת לכל קלט )‪ .(loopy‬תהי ‪ P‬לא טריוויאלית וסמנטית ונניח‬
‫בשלילה ש‪ P‬כן כריעה ונראה רדוקציה ‪.halt0 ≤ P‬‬
‫אם ‪ P‬היא בעיה מסוג א‪:‬‬
‫‪.P(loopy) = F .1‬‬
‫‪ .2‬קיימת תוכנית ‪ yes‬כך ש‪) P(yes) = T -‬כי ‪ P‬אינה טריוויאלית(‪.‬‬
‫נגדיר את הרדוקציה ‪:halt0 ≤ P‬‬
‫)( ‪ yes ( y ) f () = f‬‬
‫‪g = λy.‬‬
‫‪ yes ( y ) otherwise‬‬
‫‪where‬‬
‫) ‪halt 0 ( f ) := P( g‬‬
‫אם ‪ P‬היא בעיה מסוג ב‪:‬‬
‫‪.P(loopy) = T .1‬‬
‫‪ .2‬קיימת תוכנית ‪ no‬כך ש‪) P(no) = F -‬כי ‪ P‬אינה טריוויאלית(‪.‬‬
‫נגדיר את הרדוקציה ‪:halt0 ≤ P‬‬
‫)( ‪no( y ) f () = f‬‬
‫‪g = λy.‬‬
‫)‬
‫‪no( y ) otherwise‬‬
‫‪where‬‬
‫) ‪halt 0 ( f ) := not ( P( g‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬הנחנו ש‪ P-‬היא בעיה כריעה‪ ,‬לכן עבור כל תוכנית יוחזר ‪ T‬או ‪ F‬וערך זה יועבר‬
‫ל‪ halt0‬ומכאן שבכל מקרה התוכנית תעצור‪.‬‬
‫הערך המוחזר נכון‪:‬‬
‫עבור בעיות מסוג א' – אם ‪ f‬עוצרת‪ ,‬אזי הביטוי )(‪ f()=f‬ניתן לחישוב )כלומר אינו נכנס‬
‫ללולאה אינסופית( ויחזיר ‪ .T‬במקרה זה‪ ,‬עבור כל ‪ ,y‬התוכנית ‪ g‬תתנהג באותה הצורה‬
‫כמו ‪ yes‬ובפרט‪ ,‬תחזיר ‪ T‬עבור אותם ערכים ש‪ yes-‬מחזירה עבורם ‪) T‬ורק עבורם(‪.‬‬
‫כלומר ‪ g‬שקולה ל‪) yes-‬השפות של שתיהן שקולות(‪ .‬היות ו‪ P-‬סמנטית‪P(g)=P(yes)=T ,‬‬
‫ולכן ‪ halt0‬יחזיר ‪ T‬כנדרש‪ .‬אם ‪ f‬אינה עוצרת‪ ,‬אז לכל קלט ‪ y‬שיועבר ל‪ ,g-‬התוכנית ‪g‬‬
‫תכנס ללולאה אינסופית )כי חישוב הביטוי )(‪ f()=f‬יכנס ללולאה אינסופית( ומכאן ש‪g-‬‬
‫לא תחזיר ‪ T‬עבור אף ערך‪ .‬כלומר‪ g ,‬שקולה לתוכנית ‪) loopy‬השפות שלהן שקולות(‪.‬‬
‫היות ו‪ P-‬סמנטית ‪ .P(g)=P(loopy)=F‬כלומר‪ halt0 ,‬יחזיר ‪ F‬כנדרש‪.‬‬
‫עבור בעיות מסוג ב' – אם ‪ f‬עוצרת‪ ,‬אזי הביטוי )(‪ f()=f‬ניתן לחישוב )כלומר אינו נכנס‬
‫ללולאה אינסופית( ויחזיר ‪ .T‬במקרה זה‪ ,‬עבור כל ‪ ,y‬התוכנית ‪ g‬תתנהג באותה הצורה‬
‫כמו ‪ no‬ובפרט‪ ,‬תחזיר ‪ T‬עבור אותם ערכים ש‪ no-‬מחזירה עבורם ‪) T‬ורק עבורם(‪ .‬כלומר‬
‫‪ g‬שקולה ל‪) no-‬השפות של שתיהן שקולות(‪ .‬היות ו‪ P-‬סמנטית‪ P(g)=P(no)=F ,‬ולכן‬
‫לאחר ‪ not‬יוחזר מ‪ halt0-‬הערך ‪ T‬כנדרש‪ .‬אם ‪ f‬אינה עוצרת‪ ,‬אז לכל קלט ‪ y‬שיועבר ל‪,g-‬‬
‫התוכנית ‪ g‬תכנס ללולאה אינסופית )כי חישוב הביטוי )(‪ f()=f‬יכנס ללולאה אינסופית(‬
‫ומכאן ש‪ g-‬לא תחזיר ‪ T‬עבור אף ערך‪ .‬כלומר‪ g ,‬שקולה לתוכנית ‪) loopy‬השפות שלהן‬
‫שקולות(‪ .‬היות ו‪ P-‬סמנטית ‪ P(g)=P(loopy)=F‬ולאחר ‪ not‬יוחזר מ‪ halt0 -‬הערך ‪ F‬כנדרש‪.‬‬
‫סה"כ הראנו רדוקציה ‪ .halt0 ≤ P‬כיוון ש‪ halt0-‬אינה חשיבה‪ ,‬נסיק שגם ‪ P‬אינה חשיבה‪.‬‬
‫‪1‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫‪.2‬‬
‫‪.a‬‬
‫כתוב רדוקציית מיפוי ‪.Halt-- ≤m Sort‬‬
‫פיתרון‪:‬‬
‫‪.i‬‬
‫טענה‪ :‬הפונקציה ‪ Sort‬היא פונקציה חשיבה‪.‬‬
‫הוכחה‪:‬‬
‫יהי ‪ l‬רשימה של מספרים‪ .‬נכתוב פונקציה שמקבלת את ‪ l‬ועוברת איבר איבר‬
‫ברשימה החל מתחילתה‪ .‬בכל שלב‪ ,‬התוכנית תשווה בין ‪ 2‬איברים עוקבים‪.‬‬
‫התוכנית תמשיך לרוץ כל עוד ‪ li≤li+1‬או עד שנגיע לסוף הרשימה‪ .‬אם במהלך‬
‫הבדיקה נגלה כי קיים ‪ i‬עבורו ‪ li>=li+1‬נחזיר ‪ .F‬אם הגענו לסוף הרשימה מבלי‬
‫לעצור‪ ,‬נחזיר ‪.T‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית תעצור‪ :‬הרשימה היא סופית ולכן בכל מקרה או שנעצור מתישהו‬
‫במהלך סריקת הרשימה )כי היא לא מסודרת( או שנעצור בסופה )כאשר נגיע‬
‫לסוף הרשימה(‪.‬‬
‫הערך המחוזר נכון‪ :‬ע"פ ההגדרה‪ ,‬אם הרשימה ממוינת לכל איבר ברשימה‬
‫מתקיים ‪ .li≤li+1‬אם מצאנו ‪ 2‬איברים עוקבים להם לא מתקיים תנאי זה – הרי‬
‫שהרשימה אינה ממוינת‪ .‬אם הגענו לסוף הרשימה מבלי להפר את התנאי‪ ,‬כל‬
‫האיברים ממוינים כראוי ע"פ טרנזיטיביות של ≤‪.‬‬
‫‪ .ii‬נראה רדוקציית מיפוי‬
‫‪list (5,6,7) p( x) = T‬‬
‫‪f = λp, x.‬‬
‫‪list (5,2,7) otherwise‬‬
‫‪where‬‬
‫))‪halt − −( p, x) := Sort ( f ( p, x‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ f :‬מוגדרת ע"י הפרדיקט ‪ p‬והקלט ‪ p .x‬הוא פרדיקט בשפה ‪c--‬‬
‫וככל תוכנית בשפה זו‪ ,‬הוא חייב לעצור‪ .‬לכן ‪ p‬יעצור ויחזיר ערך ‪ T‬או ‪ .F‬בכל‬
‫מקרה‪ ,‬התוכנית ‪ f‬לאחר מכן תחזיר רשימה )מסודרת או לא( ובפרט תעצור‪.‬‬
‫הערך המוחזר נכון‪ f :‬מקבלת את הפרדיקט ‪ p‬והקלט ‪ .x‬כיוון ש‪ p‬בהכרח‬
‫עוצרת‪ ,‬הפלט המוחזר מ‪ p(x)-‬הוא בהכרח ‪ T‬או ‪ f .F‬בודקת איזה ערך מחזיר‬
‫)‪ .p(x‬אם מוחזר ‪ f ,T‬תחזיר רשימה מסודרת )שתועבר ל‪ sort-‬אשר יחזיר ‪T‬‬
‫כנדרש(‪ .‬אם מוחזר ‪ f ,F‬תחזיר רשימה שאינה ממוינת )שתועבר ל‪ sort-‬אשר‬
‫יחזיר ‪ F‬כנדרש(‪.‬‬
‫מסקנות מרדוקציית המיפוי‬
‫כיוון ש‪ f‬חשיבה וכן כיוון ש‪ Sort‬חשיבה‪ ,‬רדוקציית המיפוי שהראנו מוכיחה כי גם ‪halt--‬‬
‫חשיבה‪.‬‬
‫‪.b‬‬
‫הוכחת הנכונות שלנו ברדוקציית המיפוי ל‪ halt---‬מסתמכת על כך שהפונקציה ‪ f‬עוצרת‪.‬‬
‫‪ f‬בוודאות עוצרת כיוון ש‪ p-‬היא תוכנית הכתובה בשפה ‪ c--‬ולכן חייבת לעצור‪ .‬בשפות‬
‫אחרות כמו ‪ ,c++‬אין הכרח ש‪ p-‬תעצור ולכן ‪ f‬אינה תעצור בוודאות‪ .‬בשל כך‪ ,‬לא ניתן‬
‫לבצע רדוקצייה ל‪ halt-‬אך כן ניתן לבצע לפונקציה ‪.halt--‬‬
‫‪.c‬‬
‫כתוב רדוקציית מיפוי ‪ A ≤m Halt‬כאשר ‪ A‬שפה רקורסיבית )כריעה(‪.‬‬
‫פתרון‪:‬‬
‫‪ A‬היא שפה כריעה ולכן קיים פרדיקט ‪ p‬המכריע אותה‪ .‬נגדיר‪:‬‬
‫‪p( x) = T‬‬
‫> ‪< λx.T ,1‬‬
‫‪f = λx.‬‬
‫‪< λx.loopy ( x),1 > otherwise‬‬
‫‪where‬‬
‫))‪A( x) := Halt ( f ( x‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ A :‬היא שפה כריעה ולכן הפרדיקט שמכריע את השפה יחזיר ‪ T‬או ‪F‬‬
‫)ובוודאות יעצור(‪ .‬התוכנית ‪ f‬משתמשת בפרדיקט זה ובהתאם לערך שהוא מחזיר‬
‫מחזירה זוג סדור של פונקציה וערך‪ .‬אין הרצה נוספת ב‪ f-‬ולכן ‪ f‬בוודאות תעצור‪.‬‬
‫‪2‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫הערך המוחזר נכון‪ :‬אם ‪ x‬שייך לשפה ‪ ,A‬הפרדיקט ‪ p‬המכריע את ‪ A‬חייב להחזיר‬
‫בעבורו ‪ .T‬לכן ‪ f‬תחזיר את הזוג הסדור של התוכנית שתמיד מחזירה ‪ T‬והערך ‪ .1‬תוכנית‬
‫זו עוצרת על כל ערך ובפרט על הערך ‪ 1‬ולכן כאשר תועבר ל‪ Halt‬יוחזר ‪ T‬כנדרש‪.‬‬
‫אם ‪ x‬אינו שייך לשפה ‪ ,A‬הפרדיקט ‪ p‬המכריע את ‪ A‬חייב להחזיר בעבורו ‪ .F‬לכן ‪ f‬תחזיר‬
‫את הזוג הסדור של התוכנית ‪ loopy‬שאינה עוצרת והערך ‪ .1‬תוכנית זו אינה עוצרת על‬
‫אף ערך ובפרט אינה עוצרת עבור הערך ‪ 1‬ולכן כאשר תועבר ל‪ Halt‬יוחזר ‪ F‬כנדרש‪.‬‬
‫‪.d‬‬
‫הוכח או הפרך‪ :‬אם קיימת רדוקציה ‪ A≤B‬אז קיימת גם רדוקציית מיפוי ‪.A≤mB‬‬
‫פיתרון‪ :‬הטענה אינה נכונה‪.‬‬
‫הוכחה‪:‬‬
‫נגדיר את השפה ‪ diverge‬המכילה את כל הזוגות הסדורים >‪ <p.x‬כך ש)‪ p(x‬מתבדרת‪.‬‬
‫נשים לב כי למעשה ‪ diverge‬היא משלים לתוכנית ‪ .halt‬בין התוכניות קיימת רדוקציה‬
‫‪ halt ≤ diverge‬המוגדרת להיות ))‪ .halt(p,x):=not(diverge(p,x‬נכונות הרדוקציה נובעת‬
‫ישירות מכך ש‪ diverge‬הוא משלים של ‪) halt‬נשים לב כי ‪ halt‬כריעה למחצה(‪.‬‬
‫נניח בשלילה שהטענה כן נכונה‪ .‬כלומר‪ ,‬קיימת גם רדוקציית מיפוי ‪ .halt≤mdiverge‬לכן‪,‬‬
‫ע"פ מה שהוכחנו בכיתה קיימת גם רדוקצית המיפוי של המשלימים ‪. halt ≤ m diverge‬‬
‫הראנו בכיתה ש ‪ halt ∉ RE‬ולכן‪ ,‬ע"פ רדוקציית המיפוי של המשלימים גם‬
‫‪ . diverge ∉ RE / R‬אבל ‪ diverge = halt‬וכן מתקיים ‪ . halt ∈ RE / R‬קיבלנו סתירה ולכן‬
‫ההנחה בשלילה אינה נכונה‪ .‬כלומר אם קיימת רדוקציה בין ‪ 2‬שפות‪ ,‬אין הכרח שקיימת‬
‫גם רדוקצית מיפוי בינהן‪.‬‬
‫‪.3‬‬
‫הוכח או הפרך‪ :‬הפונקציה ‪s : N → N‬‬
‫‪s (n) = max{ f i ( j ) : i, j ≤ n} + 1‬‬
‫חשיבה‪.‬‬
‫כאשר‬
‫‪f 0 , f 1 ...‬‬
‫הוא סידור של כל הפונקציות המספריות‬
‫החשיבות‪.‬‬
‫פיתרון‪:‬‬
‫הטענה אינה נכונה‪ .‬נניח בשלילה ש‪ s-‬חשיבה‪ .‬היות ו‪ s-‬חשיבה‪ ,‬היא תופיע בסידור הפונקציות‬
‫המספריות החשיבות‬
‫‪f 0 , f 1 ...‬‬
‫‪ .‬נניח שמיקומה של ‪ s‬בסידור הוא ‪.t‬‬
‫ניתן להסתכל על קבוצת הפלטים‬
‫מסמלות את הפונקציות‬
‫}‪{ f i ( j ) : i, j ≤ n‬‬
‫‪f 0 , f 1 ... f n −1‬‬
‫כמטריצה ‪ A‬בגודל ‪ nXn‬כאשר השורות‬
‫והעמודות מסמלות קלטים אפשריים )כלומר את‬
‫המספרים הטבעיים ‪ .(1…n‬נשים לב כי הפונקציה ‪ s‬בוחרת למעשה את הערך המקסימאלי‬
‫במטריצה זו ומוסיפה לו ‪.1‬‬
‫לכל ‪ ,n>t‬הפונקציה ‪ s‬נמצאת בשורה ה‪ t+1‬של הפונקציה )מספור הפונקציות מתחיל מ‪.(0-‬‬
‫כלומר ערך הפונקציה )‪ s(n‬הוא ‪ .At+1,n‬ע"פ ההגדרה של ‪ At+1,n ,s‬הוא הערך המקסימאלי‬
‫במטריצה‪ .‬אך ‪ s‬מוסיפה לערך זה ‪ ,1‬כלומר קיבלנו כי ‪.s(n)=s(n)+1 <= s(n) = At+1,n + 1‬‬
‫זו כמובן סתירה ולכן הטענה המקורית אינה נכונה‪.‬‬
‫‪.4‬‬
‫הוכח שהמחלקה ‪ R‬סגורה תחת הפעולות הבאות )ניתן להשתמש במילים במקום בקוד(‪:‬‬
‫‪.a‬‬
‫איחוד‬
‫נראה שהשפה‬
‫כאשר‬
‫‪p1 , p 2‬‬
‫‪L1 ∪ L2‬‬
‫)‪p(c) = p1 (c) ∨ p 2 (c‬‬
‫כריעה ע"י הגדרת פרדיקט שיכריע אותה‪:‬‬
‫הם פרדיקטים המכריעים את השפות‬
‫‪L1 , L2‬‬
‫בהתאמה‪.‬‬
‫הוכחת נכונות‪:‬‬
‫‪ L1 , L2‬הן שפות כריעות‪ .‬לכן‪ ,‬קיימים ‪p1 , p 2‬‬
‫‪ c ∈ L1 , p1 (c ) = T‬אחרת ‪ p1 (c ) = F‬וכן לכל ‪ c ∈ L2 , p 2 (c ) = T‬אחרת‬
‫‪ . p 2 (c ) = F‬יהי ‪ , c ∈ L1 ∪ L2‬אזי ‪ c ∈ L1‬או ‪) c ∈ L2‬או לשניהם כמובן(‪ .‬אם‬
‫‪ c ∈ L1‬אז ‪ p1 (c ) = T‬ואם ‪ c ∈ L2‬אז ‪ . p 2 (c ) = T‬כלומר‪ ,‬אם ‪ c ∈ L1 ∪ L2‬על‬
‫פרדיקטים‪ ,‬כך שלכל‬
‫‪3‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫אחד הפרדיקטים לפחות להחזיר ‪ .T‬לכן‪p(c) = p1 (c) ∨ p 2 (c) = T ,‬‬
‫אם ‪ c ∉ L1 ∪ L2‬אזי ‪ c ∉ L1‬או ‪ c ∉ L2‬ולכן ‪ p1 (c ) = F‬וגם ‪ . p 2 (c ) = F‬לכן‪,‬‬
‫‪ p (c ) = p1 (c ) ∨ p 2 (c) = F ∨ F = F‬כנדרש‪.‬‬
‫‪.‬‬
‫‪.b‬‬
‫חיתוך‬
‫נראה שהשפה‬
‫כאשר‬
‫‪p1 , p 2‬‬
‫‪L1 ∩ L2‬‬
‫)‪p(c) = p1 (c) ∧ p 2 (c‬‬
‫כריעה ע"י הגדרת פרדיקט שיכריע אותה‪:‬‬
‫הם פרדיקטים המכריעים את השפות‬
‫‪L1 , L2‬‬
‫בהתאמה‪.‬‬
‫הוכחת נכונות‪:‬‬
‫‪ L1 , L2‬הן שפות כריעות‪ .‬לכן‪ ,‬קיימים ‪p1 , p 2‬‬
‫‪ c ∈ L1 , p1 (c ) = T‬אחרת ‪ p1 (c ) = F‬וכן לכל ‪ c ∈ L2 , p 2 (c ) = T‬אחרת‬
‫‪ . p 2 (c ) = F‬יהי ‪ , c ∈ L1 ∩ L2‬אזי ‪ c ∈ L1‬וגם ‪ . c ∈ L2‬לכן‬
‫‪ . p(c) = p1 (c) ∧ p 2 (c) = T ∧ T = T‬אם ‪ c ∉ L1 ∩ L2‬אזי ‪ c ∉ L1‬או ‪c ∉ L2‬‬
‫)או שאינו שייך לשניהם(‪ .‬לכן‪ p1 (c ) = F ,‬או ‪) p 2 (c ) = F‬או שניהם(‪ .‬ומכאן שגם‪,‬‬
‫‪ p (c ) = p1 (c ) ∧ p 2 (c ) = F‬כנדרש‪.‬‬
‫פרדיקטים‪ ,‬כך שלכל‬
‫‪.c‬‬
‫שרשור‬
‫נראה ש‪ R‬סגור גם עבור שירשור‪ ,‬ע"י הגדרת פרדיקט שיכריע שרשור של ‪ 2‬שפות‪:‬‬
‫)‪p(c‬‬
‫{‬
‫;)‪len = length(c‬‬
‫)‪for (int i=0; i<= len; i++‬‬
‫{‬
‫))‪p1 (subStr(c,0,i)) && p 2 (subStr(c,i,len‬‬
‫(‪if‬‬
‫{‬
‫;‪return true‬‬
‫}‬
‫}‬
‫;‪return false‬‬
‫}‬
‫כאשר‪:‬‬
‫‪.1‬‬
‫‪p1 , p 2‬‬
‫הם פרדיקטים המכריעים את השפות‬
‫‪L1 , L2‬‬
‫בהתאמה‪.‬‬
‫‪ length(s) .2‬היא פונקציה המחזירה את אורך המחרוזת ‪) s‬מספר התווים במחרוזת(‪.‬‬
‫‪ subStr(s,st,en) .3‬היא פונקציה המחזירה את תת המחרוזת המתחילה בתו ה‪st-‬‬
‫ומסתיימת בתו ה‪ en‬של המחרוזת ‪.s‬‬
‫נשים לב‪ ,‬שהפונקציות ‪ length‬ו‪ subStr -‬הן פונקציות חשיבות ומוגדרות היטב‪.‬‬
‫הוכחת נכונות‪:‬‬
‫עצירה‪ :‬אורך המחרוזת ‪ c‬הוא סופי‪ .‬לכן ‪ p‬תעבור על כל המחרוזת בזמן סופי ובסופו של‬
‫דבר תיעצר )כשהתנאי שבתוך הלולאה יתקיים או כשהלולאה ‪ for‬תיעצר(‪ .‬בסיום‬
‫הריצה תמיד יוחזר ערך ‪ T‬או ‪.F‬‬
‫הערך המוחזר נכון‪ :‬אם ‪ c‬הוא שרשור של ‪ 2‬מחרוזות‪ ,‬אחת מ‪L1 -‬‬
‫והשנייה מ‪ , L2 -‬לאחר‬
‫שהאינדקס ‪ i‬יגיע לאורך המחרוזת הראשונה בשרשור‪ ,‬חלוקת המחרוזת תהיה בדיוק ל‪-‬‬
‫‪ 2‬תת‪-‬המחרוזות המקוריות‪ .‬לכן‪ ,‬עבור תת מחרוזת אחת‪,‬‬
‫‪p1‬‬
‫יחזיר ‪ T‬ועבור השנייה‬
‫‪p2‬‬
‫יחזיר ‪ .T‬מכאן‪ ,‬שהתנאי בתוך הלולאה יהיה גם ‪ ,T‬הלולאה תפסק ו‪ p-‬יחזיר ‪.T‬‬
‫אם ‪ c‬אינו שרשור של ‪ 2‬המחרוזות‪ ,‬בכל שלב של ריצת הלולאה‪ ,‬לפחות אחד‬
‫הפרדיקטים ‪p1 , p 2‬‬
‫יחזיר ‪ F‬על אחד מתתי‪-‬המחרוזת‪ .‬לכן‪ ,‬התנאי בתוך הלולאה תמיד‬
‫יהיה ‪ ,F‬הלולאה תסתיים באופן טבעי ו‪ p-‬יחזיר ‪.F‬‬
‫‪4‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫‪.d‬‬
‫‪Kleene Star‬‬
‫נראה ש‪ R‬סגור גם עבור ‪ ,Kleene Star‬ע"י הגדרת פרדיקט שיכריע שרשור של ‪ 2‬שפות‪.‬‬
‫פעולת הפרדיקט‪ :‬הפרדיקט מקבל מחרוזת ‪ s‬ומתחיל את הבדיקה‪ .‬מאפסים אינדקס ‪i‬‬
‫להיות ‪ 0‬ובודקים האם תת המחרוזת עד האינדקס ‪ i‬שייכת לשפה )באמצעות הפרדיקט‬
‫המקורי של ‪ .(L‬אם לא‪ ,‬מגדילים את ‪ i‬ב‪ 1-‬וחוזרים על הבדיקה בשנית‪ .‬אם כן‪ ,‬חותכים‬
‫את תת‪-‬המחרוזת מתחילת ‪ s‬וממשיכים בסבב בדיקות חדש על המחרוזת שנשארה וכך‬
‫הלאה‪ .‬פעולת הבדיקה מתבצעת בדומה לרקורסיה‪ .‬לצורכי נוחות נתייחס לכל "עומק"‬
‫של רקורסיה כמעגלים‪ ,‬כך שהמעגל הראשון הוא הבדיקה המקורית‪ .‬אם הגענו למצב‬
‫בו באחד משלבי הרקורסיה‪ ,‬האינדקס המקומי הגיע לסוף המחרוזת והיא אינה שייכת‬
‫ל‪ ,L-‬נחזור "מעגל" אחד אחורה‪ ,‬נקדם את האינדקס במעגל זה ב‪ 1-‬ונמשיך בבדיקה‪ .‬אם‬
‫בשלב מסוים הגענו לסוף המחרוזת וגם זנב המחרוזת האחרון שייך ל‪ ,L-‬נחזיר ‪ .T‬אם‬
‫נגיע לסוף המחרוזת במעגל החיצוני וגם המחרוזת השלמה ‪ s‬אינה שייכת לשפה‬
‫)בבדיקה האחרונה האפשרית(‪ ,‬נחזיר ‪.F‬‬
‫הוכחת נכונות‪:‬‬
‫עצירה‪ :‬אורך המחרוזת ‪ c‬הוא סופי‪ .‬לכן ‪ p‬תעבור רקורסיבית על כל המחרוזת בזמן סופי‬
‫ובסופו של דבר תיעצר )כאשר נגיע באחד המעגלים לסוף המחרוזת והיא תהיה שייכת‬
‫לשפה או כאשר במעגל הראשון נגיע לסוף והיא תהיה שייכת‪/‬אינה שייכת לשפה(‪.‬‬
‫בסיום הריצה תמיד יוחזר ערך ‪ T‬או ‪.F‬‬
‫הערך המוחזר נכון‪ :‬אם ‪ c‬הוא שרשור של מספר מחרוזות סופי מ‪ ,L-‬הרקורסיה תמצא‬
‫חלוקה זו )כי אנו למעשה עוברים על כל החלוקות האפשריות למחרוזת(‪ .‬במקרה כזה‪,‬‬
‫עבור כל תת מחרוזת בחלוקה‪ ,‬הפרדיקט של ‪ L‬יחזיר ‪ T‬ולכן‪ ,‬במעגל האחרון של‬
‫אפשרות זו יוחזר גם לזנב המחרוזת ‪ T‬ולכן גם הבדיקה הכללית של ‪ s‬תחזיר ‪.T‬‬
‫אם ‪ c‬אינו שרשור של מחרוזות מ‪ ,L-‬בכל אפשרות חלוקה תהיה לפחות תת מחרוזת‬
‫אחת שאינה שייכת ל‪ L-‬ועבורה יוחזר ‪ .F‬לכן‪ ,‬נגיע לאחר כל הבדיקות לבדיקה‬
‫האחרונה‪ s ,‬כמחרוזת שלמה אינה שייכת ל‪ L-‬ולכן גם בבדיקה זו יוחזר ‪ F‬וכפועל יוצא‬
‫הפרדיקט שהגדרנו יחזיר גם ‪ F‬כנדרש‪.‬‬
‫‪.5‬‬
‫קבע לכל אחת מהשפות האם היא שייכת ל‪ co-RE/R,RE/R ,R-‬או לאף אחת מהקבוצות‪ .‬הוכח‬
‫נכונות‪.‬‬
‫‪.a‬‬
‫קלט‪ :‬תוכנית ‪ .p‬שאלה‪ :‬האם קיים ‪ x‬עבורו ‪ p‬עוצרת?‬
‫פתרון‪ :‬נראה ש זוהי שפה הכריעה למחצה )שייכת ל‪.(RE/R-‬‬
‫‪.i‬‬
‫טענה‪ :‬זוהי שפה הכריעה למחצה )שייכת ל‪.(RE/R-‬‬
‫הוכחה‪:‬‬
‫נראה אלגוריתם המשתמש בשיטת השבלול באמצעות סטפר‪ .‬יהי ‪s1 , s 2 ,...‬‬
‫קלטים אפשריים עבור ‪ .p‬נרוץ על הקלטים באופן הבא‪ :‬עבור כל ‪ i ∈ Ν‬נרוץ‬
‫על הקלטים ‪ s1 ,..., s i‬למשך ‪ i‬צעדים‪ .‬במידה ועבור אחד הקלטים הסטפר‬
‫עצר באופן טבעי‪ ,‬נחזיר ‪ T‬ונסיים את הבדיקה‪ ,‬אחרת נמשיך הלאה‪.‬‬
‫הוכחת נכונות‪:‬‬
‫במידה וקיים קלט ‪ x‬עבורו התוכנית ‪ p‬עוצרת‪ ,‬נגיע לקלט זה לאחר ‪ i1‬צעדים‪.‬‬
‫כיוון שהתוכנית ‪ p‬עוצרת עבור קלט זה‪ ,‬קיים ‪ ,i2‬מספר צעדים שעבורו )‪p(x‬‬
‫עוצרת באופן טבעי‪ .‬לכן‪ ,‬כאשר האלגוריתם שלנו יגיע ל} ‪ i=max{i1, i2‬הסטפר‬
‫יעצור באופן טבעי והתוכנית תחזיר ‪ T‬כנדרש‪.‬‬
‫במידה ולא קיים קלט ‪ x‬עבורו ‪ p‬עוצרת‪ ,‬הסטפר לא ייעצר באופן טבעי בשום‬
‫שלב ולכן התוכנית תתבדר‪.‬‬
‫‪.ii‬‬
‫טענה‪ :‬זוהי אינה שפה כריעה )אינה שייכת ל‪.(R-‬‬
‫הוכחה‪:‬‬
‫נניח בשלילה שהשפה כן כריעה ונראה רדוקציה ל‪ .halt‬כלומר קיים פרדיקט‬
‫‪ stopsForSomeX‬המכריע את השפה )מחזיר ‪ T‬אם בשפה קיים ‪ x‬שעבורה‬
‫התוכנית עוצרת ו‪ F-‬אחרת(‪.‬‬
‫‪5‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫)‪Halt(p,x) := stopsForSomeX (g) where g:= λz.if z=x then return p(x‬‬
‫)(‪else return loopy‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬אנו מניחים כי ‪ stopsForSomeX‬כריעה ולכן תעצור עבור כל‬
‫קלט‪ Halt .‬מוגדרת להיות הערך ש‪ stopsForSomeX-‬מחזירה ולכן תמיד תעצור‬
‫)כי ע"פ ההנחה ‪ stopsForSomeX‬תמיד עוצרת(‪.‬‬
‫הערך המוחזר נכון‪ :‬אנו רוצים לבדוק האם התוכנית ‪ p‬עוצרת עבור ‪ .x‬התוכנית‬
‫אינה עוצרת בוודאות עבור קלטים השונים מ‪ .x-‬כאשר ‪ x‬ניתן כקלט ל‪,g-‬‬
‫התוכנית תעצור רק אם )‪ p(x‬עוצרת‪ .‬כלומר‪ ,‬אם )‪ p(x‬עוצרת‪ ,‬קיים ‪ x‬עבורו ‪p‬‬
‫עוצרת ולכן ‪ stopsForSomeX‬יחזיר ‪ T‬כנדרש‪ .‬אחרת‪ g ,‬לא תעצור עבור אף‬
‫קלט ו‪ stopsForSomeX-‬תחזיר ‪.F‬‬
‫‪.b‬‬
‫קלט‪ :‬תוכנית ‪ .p‬שאלה‪ :‬האם כל מספר זוגי הגדול מ‪ ,2-‬ניתן להציג כסכום של ‪2‬‬
‫מספרים ראשוניים?‬
‫פתרון‪ :‬נראה שזוהי שפה כריעה )שייכת ל‪.( R-‬‬
‫הנחת גולדבאך אומנם עדיין לא הוכחה או הופרכה אך באופן כללי לשאלה זו יש‬
‫תשובה יחידה ‪ T‬או ‪ .F‬לכן שפה זו היא שפה טריוויאלית‪ :‬אין תלות בקלט ‪ p‬ובהכרח‬
‫ניתן להכריע אותה ע"י התוכנית ‪ λp, x.T‬או ‪ . λp, x.F‬נשים לב‪ ,‬שאין צורך שנדע את‬
‫התשובה לשפה טריוויאלית‪ ,‬כמו בדוגמה של שפת חברי הכנסת ה‪ 18-‬שטרם הוכרעה‬
‫רשמית )נכון לכתיבת שורות אלו( כפי שהוצגה בכיתה‪.‬‬
‫‪.c‬‬
‫קלט‪ :‬תוכנית ‪ p‬ו‪ 2-‬משתנים‪ x :‬ו‪ .y-‬שאלה‪ :‬האם ‪ p‬עוצרת בדיוק על ‪ 1‬משני המשתנים?‬
‫פתרון‪ :‬נראה ששפה זו אינה שייכת לאף אחת מהקבוצות ‪.R,RE/R,co-RE/R‬‬
‫‪.i‬‬
‫טענה‪ :‬שפה זו אינה שייכת ל‪ R-‬ואינה שייכת ל‪.co-RE/R-‬‬
‫הוכחה‪:‬‬
‫נוכיח באמצעות רדוקציית מיפוי‪ .‬נניח בשלילה שקיים )‪haltsOnOne(p,x,y‬‬
‫ונראה רדוקציה מ‪.halt-‬‬
‫‪Halt (p,x) := haltsOnOne(f(p,x)) where‬‬
‫>‪f:= λp,x.<g,x,ε‬‬
‫)‪g:= λz.if (z==x) then return p(x‬‬
‫)(‪else return loopy‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬אנו מניחים כי ‪ haltsOnOne‬כריעה ולכן תעצור עבור כל קלט‪.‬‬
‫‪ Halt‬מוגדרת להיות הערך ש‪ haltOnOne‬מחזירה ולכן תמיד תעצור )כי ע"פ‬
‫ההנחה ‪ haltsOnOne‬תמיד עוצרת(‪.‬‬
‫הערך המוחזר נכון‪ :‬אנו רוצים לבדוק האם התוכנית ‪ p‬עוצרת עבור ‪ .x‬התוכנית‬
‫‪ g‬אינה עוצרת עבור כל ערך השונה מ‪ .x-‬כמו כן‪ ,‬עבור קלט השווה ל‪g ,x-‬‬
‫מחזירה את )‪ p(x‬ולכן תעצור רק במקרה ו‪ p(x)-‬עוצרת‪ .‬נשים לב‪ :‬כאשר )‪p(x‬‬
‫אינה עוצרת‪ g ,‬אינה עוצרת על ‪ 2‬הקלטים ולכן ‪ haltsOnOne‬תחזיר ‪ F‬כנדרש‪.‬‬
‫כאשר )‪ p(x‬עוצרת‪ g ,‬תעצור רק עבור ‪ x‬ולכן ‪ haltsOnOne‬תחזיר ‪ T‬כנדרש‪.‬‬
‫הראנו כי קיימת רדוקצית מיפוי מ‪ halt-‬ל‪ haltsOnOne-‬זאת בסתירה לכך ש‪halt-‬‬
‫אינה כריעה‪ .‬לכן‪ ,‬גם ‪ haltsOnOne‬אינה כריעה‪ .‬היות ו‪ halt‬גם אינה שייכת ל‪-‬‬
‫‪ Co-RE/R‬נוכל להסיק בצורה דומה שגם ‪ haltsOnOne‬אינה שייכת ב‪.Co-RE/R-‬‬
‫‪.ii‬‬
‫טענה‪ :‬שפה זו אינה שייכת ל‪.RE/R-‬‬
‫הוכחה‪:‬‬
‫נוכיח באמצעות רדוקציית מיפוי‪.‬‬
‫>‪f:= λp,x.<g,x,ε‬‬
‫)‪g:= λz.if (z==x) then return p(x‬‬
‫‪else return T‬‬
‫‪halt (p,x) := haltsOnOne(f(p,x)) where‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬אנו מניחים כי ‪ haltsOnOne‬כריעה ולכן תעצור עבור כל קלט‪.‬‬
‫‪6‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫‪ halt‬מוגדרת להיות הערך ש‪ haltOnOne‬מחזירה ולכן תמיד תעצור )כי ע"פ‬
‫ההנחה ‪ haltsOnOne‬תמיד עוצרת(‪.‬‬
‫הערך המוחזר נכון‪ :‬אנו רוצים לבדוק האם התוכנית ‪ p‬אינה עוצרת עבור ‪.x‬‬
‫התוכנית ‪ g‬עוצרת עבור כל ערך השונה מ‪ .x-‬כמו כן‪ ,‬עבור קלט השווה ל‪g ,x-‬‬
‫מחזירה את )‪ p(x‬ולכן תעצור רק במקרה ו‪ p(x)-‬עוצרת‪ .‬נשים לב‪ :‬כאשר )‪p(x‬‬
‫אינה עוצרת‪ g ,‬עוצרת רק על קלט ‪ 1‬ולכן ‪ haltsOnOne‬תחזיר ‪ T‬כנדרש‪ .‬כאשר‬
‫)‪ p(x‬עוצרת‪ g ,‬תעצור על ‪ 2‬הקלטים ולכן ‪ haltsOnOne‬תחזיר ‪ F‬כנדרש‪.‬‬
‫הראנו כי קיימת רדוקצית מיפוי מ‪ halt -‬ל‪ .haltsOnOne-‬היות ו ‪halt‬‬
‫אינה‬
‫שייכת ל‪ ,RE/R-‬נסיק כי גם ‪ haltsOnOne‬אינה שייכת לקבוצה זו‪.‬‬
‫סה"כ הראנו ב‪ 2-‬הטענות כי השפה אינה שייכת לאף קבוצה‪.‬‬
‫‪.d‬‬
‫קלט‪ :‬תוכנית ‪ .p‬שאלה‪?|L(p)|>3 :‬‬
‫פתרון‪ :‬נראה שזוהי שפה הכריעה למחצה )שייכת ל‪.(RE/R-‬‬
‫‪.i‬‬
‫טענה‪ :‬זוהי שפה הכריעה למחצה )שייכת ל‪.(RE/R-‬‬
‫הוכחה‪:‬‬
‫נראה אלגוריתם המשתמש בשיטת השבלול באמצעות סטפר‪ .‬יהי ‪s1 , s 2 ,...‬‬
‫קלטים אפשריים עבור ‪ .p‬נרוץ על הקלטים באופן הבא‪ :‬עבור כל ‪i ∈ Ν‬‬
‫על הקלטים ‪ s1 ,..., s i‬למשך ‪ i‬צעדים‪ .‬בכל פעם שעבור אחד הקלטים‬
‫נרוץ‬
‫הסטפר עצר באופן טבעי לראשונה‪ ,‬נקדם מונה ב‪ .1-‬אם המונה יגיע ל‪ 4-‬נחזיר‬
‫‪ T‬ונסיים את הבדיקה‪ ,‬אחרת נמשיך הלאה‪.‬‬
‫הוכחת נכונות‪:‬‬
‫במידה וקיימים יותר מ‪ 3-‬קלטים עבורם ‪ p‬מחזירה ‪ ,T‬נגיע לפחות ל‪ 4-‬מהם‬
‫לאחר ‪ i1‬צעדים‪ .‬כיוון שהתוכנית ‪ p‬מחזירה ‪ T‬בוודאות עבור כל אחד מהקלטים‬
‫הללו )ולכן בהכרח עוצרת(‪ ,‬קיים ‪ ,i2‬מספר צעדים שעבורו ‪ p‬עוצרת עבור כל‬
‫אחד מהקלטים באופן טבעי ומחזירה ‪ .T‬לכן‪ ,‬כאשר האלגוריתם שלנו יגיע‬
‫ל} ‪ i=max{i1, i2‬הסטפר יעצור בפעם הרביעית‪ ,‬המונה יתעדכן ל‪ ,4-‬והתוכנית‬
‫תחזיר ‪ T‬כנדרש‪.‬‬
‫במידה ולא קיימים לפחות ‪ 4‬קלטים עבורם ‪ p‬מחזירה ‪ ,T‬הסטפר לא ייעצר‬
‫באופן טבעי מספיק פעמים והמונה לא יגיע ל‪ .4-‬לכן‪ ,‬התוכנית תמשיך לרוץ‪,‬‬
‫ובמילים אחרות ‪ -‬התוכנית תתבדר‪.‬‬
‫‪.ii‬‬
‫טענה‪ :‬זוהי אינה שפה כריעה )אינה שייכת ל‪.(R-‬‬
‫הוכחה‪:‬‬
‫נניח בשלילה שהשפה כן כריעה ונראה רדוקציה מ‪ .halt‬כלומר קיים פרדיקט‬
‫‪ moreThan3‬המכריע את השפה )מחזיר ‪ T‬אם בשפה יש יותר מ‪ 3-‬קלטים‬
‫שעבורם התוכנית ‪ p‬עוצרת‪ ,‬ו‪ F-‬אחרת(‪.‬‬
‫)‪Halt(p,x) := moreThan3(g) where g:= λz.if z=x then return p(x‬‬
‫‪else if z=next(x) then T‬‬
‫‪else if z=next(next(x)) then T‬‬
‫‪else if z=next(next(next(x))) then T‬‬
‫)(‪else return loopy‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬אנו מניחים כי ‪ moreThan3‬כריעה ולכן תעצור עבור כל קלט‪.‬‬
‫‪ Halt‬מוגדרת להיות הערך ש‪ moreThan3‬מחזירה ולכן תמיד תעצור )כי ע"פ‬
‫ההנחה ‪ moreThan3‬תמיד עוצרת(‪.‬‬
‫הערך המוחזר נכון‪ :‬אנו רוצים לבדוק האם התוכנית ‪ p‬עוצרת עבור ‪ .x‬התוכנית‬
‫‪ g‬עוצרת בוודאות עבור ‪ 3‬קלטים‪ .‬עבור יתר הקלטים )פרט לקלט ‪ ,(x‬תכנס ‪g‬‬
‫ללולאה אינסופית‪ .‬כאשר נשלח ל‪ g-‬הקלט ‪ x‬מוחזר הערך של )‪ .p(x‬לכן‪ ,‬אם‬
‫עבור ‪ x‬התוכנית ‪ p‬עוצרת‪ ,‬הרי ש‪ g-‬תעצור עבור יותר מ‪ 3-‬קלטים ולכן יוחזר ‪T‬‬
‫כנדרש‪ .‬אחרת‪ p ,‬תעצור עבור ‪ 3‬קלטים בדיוק ולכן יוחזר ‪ F‬כנדרש‪.‬‬
‫‪7‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫‪.e‬‬
‫קלט‪ :‬תוכנית ‪ .p‬שאלה‪?|L(p)|≤3 :‬‬
‫פתרון‪ :‬זוהי שפה שהמשלים שלה היא שפה הכריעה למחצה )שייכת ל‪.(Co-RE/R-‬‬
‫‪.i‬‬
‫טענה‪ :‬זוהי שפה שהמשלים שלה היא שפה הכריעה למחצה‬
‫)שייכת ל‪(Co-RE-‬‬
‫הוכחה‪ :‬נשים לב כי המשלים הוא ‪ .|L(p)|>3‬כפי שהוכחנו בסעיף הקודם‪,‬‬
‫המשלים שייך ל‪ RE/R-‬ואינו שייך ל‪ .R-‬לכן‪ ,‬באופן מיידי )ע"פ מה שהוכחנו‬
‫בכיתה( נסיק כי שפה זו שייכת ל‪.Co-RE-‬‬
‫טענה‪ :‬זוהי אינה שפה כריעה )אינה שייכת ל‪.(R-‬‬
‫הוכחה‪:‬‬
‫נניח בשלילה שהשפה כן כריעה‪ .‬מכאן שגם המשלים של השפה שייך ל‪ R-‬אך‬
‫בסעיף הקודם הראנו כי הוא אינו שייך ל‪ .R-‬קיבלנו סתירה ולכן השפה אינה‬
‫שייכת ל‪.R-‬‬
‫‪.f‬‬
‫קלט‪ :‬פרדיקט ‪ .P‬שאלה‪ :‬האם )‪ L(P‬היא כריעה?‬
‫פתרון‪ :‬נראה ששפה זו אינה שייכת לאף אחת מהקבוצות ‪.R,RE/R,co-RE/R‬‬
‫‪.i‬‬
‫טענה‪ :‬שפה זו אינה כריעה ואינה שייכת ל‪.co-RE/R-‬‬
‫הוכחה‪:‬‬
‫נוכיח באמצעות רדוקציית מיפוי מ‪:halt‬‬
‫נניח שהשפה כריעה ומוכרעת ע"י הפרדיקט ‪ .Q‬נסמן את הפרדיקט של השפה‬
‫‪ haltε‬כ‪Pε -‬‬
‫)שפת התוכניות שעוצרות עבור הערך אפסילון(‪.‬‬
‫)‪g := λp, x.λz.Pε ( z) ∨ f ( z‬‬
‫)‪p(x) = p(x‬‬
‫‪T‬‬
‫‪f := λz.‬‬
‫‪loopy() o.w.‬‬
‫‪halt (p,x) := Q(g(p,x)) where‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬אנו מניחים כי ‪ Q‬כריעה ולכן תעצור עבור כל קלט‪ .‬התוכנית‬
‫‪ g‬תעצור בוודאות כיוון שהיא בסך הכל מחזירה תוכנית חדשה )ולא מפעילה‬
‫תוכנית זו עדיין(‪ halt .‬מוגדרת להיות הערך ש‪ Q‬מחזירה ולכן תמיד תעצור )כי‬
‫ע"פ ההנחה ‪ Q‬תמיד עוצרת(‪.‬‬
‫הערך המוחזר נכון‪ :‬אנו רוצים לבדוק האם התוכנית ‪ p‬אינה עוצרת עבור ‪ .x‬אם‬
‫‪ p‬עוצרת על ‪ ,x‬ל‪ Q-‬יועבר הפרדיקט ‪, λz.Pε ( z) ∨ f ( z) = λz.Pε ( z) ∨ T = T‬‬
‫כלומר הפרדיקט המחזיר ‪ T‬לכל ערך‪ .‬במקרה כזה‪ ,‬השפה המוגדרת ע"י‬
‫הפרדיקט היא שפת כל המחרוזות והיא כמובן שפה כריעה‪ .‬לכן ‪ Q‬יחזיר ‪T‬‬
‫כנדרש‪ .‬אם ‪ p‬אינה עוצרת על ‪ ,x‬ל‪ Q-‬יועבר הפרדיקט )‪. λz.Pε ( z) ∨ f ( z‬‬
‫בעת בדיקת ערך בפרדיקט זה‪ ,‬אם הערך שייך ל‪ , haltε -‬יוחזר ‪) T‬והתנאי‬
‫השני לא ייבדק(‪ .‬אם הערך לא שייך ל‪ , haltε -‬יוחזר מהפרדיקט של‬
‫‪haltε‬‬
‫‪ F‬ולכן ננסה לבדוק באמצעות )‪ .f(z‬במקרה זה‪ ,‬כיוון ש‪ p-‬אינה עוצרת‪,‬‬
‫הפרדיקט כולו יתבדר )הערה‪ :‬כדי לא לסבך את הקוד השתמשתי בתנאי "או"‬
‫פשוט‪ .‬כיוון ש‪ haltε -‬אינה כריעה‪ ,‬נאלץ להשתמש בסטפר עד שאחת‬
‫הפונקציות תחזיר ‪ .(T‬כלומר‪ ,‬עבור קלטים השייכים ל‪haltε -‬‬
‫קלטים שאינם שייכים ל‪haltε -‬‬
‫הפרדיקט היא בעצם ‪ . haltε‬זו שפה שאינה כריעה ולכן ‪ Q‬יחזיר ‪ F‬כנדרש‪.‬‬
‫יוחזר ‪ T‬ועבור‬
‫הפרדיקט יתבדר‪ .‬לכן‪ ,‬השפה שתוגדר ע"י‬
‫הראנו כי קיימת רדוקצית מיפוי מ‪ halt -‬ל‪ .Q-‬היות ו ‪halt‬‬
‫אינה כריעה ואינה‬
‫שייכת ל‪ ,co-RE/R-‬נסיק כי גם ‪ Q‬אינה שייכת לקבוצה זו‪.‬‬
‫‪8‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫‪.ii‬‬
‫טענה‪ :‬שפה זו אינה שייכת ל‪.RE/R-‬‬
‫הוכחה‪:‬‬
‫נסמן את השפה כ ‪ . L R‬בכיתה הראנו והוכחנו כי קיימת רדוקצית מיפוי מ‪Halt-‬‬
‫לשפה המשלימה ‪ . L‬כלומר מתקיים‬
‫‪R‬‬
‫בכיתה( גם מתקיים‬
‫היות ו‪halt -‬‬
‫‪halt ≤ m LR‬‬
‫‪≤ m LR ⇒ halt ≤ m LR‬‬
‫ומכאן )ע"פ מה שהוכחנו‬
‫‪. halt‬‬
‫אינה כריעה ואינה שייכת ל‪ RE/R-‬נסיק כי גם‬
‫‪LR‬‬
‫אינה שייכת‬
‫כריעה ואינה שייכת ל‪.RE/R-‬‬
‫הראנו כי קיימת רדוקצית מיפוי מ‪ halt-‬ל‪ haltsOnOne-‬זאת בסתירה לכך ש‪halt-‬‬
‫אינה כריעה‪ .‬לכן‪ ,‬גם ‪ haltsOnOne‬אינה כריעה‪ .‬היות ו‪ halt‬גם אינה שייכת ל‪-‬‬
‫‪ Co-RE/R‬נוכל להסיק בצורה דומה שגם ‪ haltsOnOne‬אינה שייכת ב‪.Co-RE/R-‬‬
‫סה"כ הראנו ב‪ 2-‬הטענות כי השפה אינה שייכת לאף קבוצה‪.‬‬
‫‪.g‬‬
‫קלט‪ :‬פרדיקט ‪ .p‬שאלה‪ :‬האם )‪ L(P‬מוכרעת למחצה?‬
‫פתרון‪ :‬זוהי שפה כריעה )שייכת ל‪.(R-‬‬
‫הוכחה‪:‬‬
‫ע"פ ההגדרה‪ ,‬כל שפה )‪ L(p‬מוכרעת למחצה ע"י הפרדיקט שלה ‪ .p‬כלומר‪ ,‬השפה )‪L(P‬‬
‫מוגדרת להיות כל הערכים להם ‪ P‬מחזיר אמת‪ .‬לכן‪ ,‬השפה )‪ L(p‬מעצם ההגדרה‬
‫מוכרעת למחצה ע"י ‪ .P‬מכאן ששאלה זו היא שאלה טריוויאלית ומוכרעת ע"י הפרדיקט‬
‫‪ . λx.T‬הראנו כי קיים פרדיקט המכריע את השפה ולכן שפה זו שייכת ל‪.R-‬‬
‫‪.h‬‬
‫קלט‪ :‬תוכנית ‪ p‬ללא קלט‪ ,‬שמקיימת )‪.|p|<bb(1000‬‬
‫שאלה‪ :‬האם ‪ p‬עוצרת?‬
‫פתרון‪ :‬זוהי שפה כריעה )שייכת ל‪.(R-‬‬
‫הוכחה‪:‬‬
‫מספר התוכניות ללא קלט שמקיימות את התנאי )‪ |p|<bb(1000‬הוא מספר סופי‪ .‬לכן‪,‬‬
‫קיימים מספר סופי של שאילתות שניתן לבצע על הבעיה‪ .‬ע"פ מה שנלמד בכיתה‪ ,‬כל‬
‫בעיה עם מספר סופי של שאילתות היא בעיה כריעה )בדומה לבעיית חברי הכנסת ה‪-‬‬
‫‪ .(18‬לכן‪ ,‬זוהי שפה כריעה‪.‬‬
‫הערה‪ :‬נשים לב‪ ,‬שמשפט רייס אינו תופס במקרה זה כיוון שהבעיה אינה סמנטית‪ .‬תהי‬
‫‪ f‬תוכנית עוצרת באורך )‪ .bb(1000‬התוכנית ) ‪ g = λx. f ( x‬שקולה לתוכנית ‪ f‬היות‬
‫והערכים שהיא מחזירה זהים לערכים של ‪ .f‬עם זאת‪ ,‬ברור שהאורך של ‪ g‬גדול‬
‫מ)‪ .bb(1000‬לכן‪ ,‬למרות שהתוכניות שקולות סמנטית‪ ,‬הבעיה תחזיר עבור ‪ F g‬כי היא‬
‫אינה שייכת לשפה‪.‬‬
‫‪.6‬‬
‫נתון‪:‬‬
‫‪.a‬‬
‫‪∈ RE / R‬‬
‫‪ . L1 , L2‬הוכח האם הביטויים הבאים אפשריים‪:‬‬
‫‪L1 ∪ L2 ∈ R‬‬
‫פתרון‪ :‬מצב זה הוא מצב אפשרי‪.‬‬
‫הוכחה‪:‬‬
‫נגדיר‬
‫}‪L1 = {< p, x > | p halts on x or | p | is even‬‬
‫} ‪L2 = {< p, x > | p halts on x or | p | is odd‬‬
‫‪9‬‬
‫‪u.multinet.co.il‬‬
‫עידן דויטש‬
‫‪u.multinet.co.il‬‬
‫‪ L1‬ו‪ L2‬הן שפות כריעות למחצה )כלומר‬
‫‪∈ RE / R‬‬
‫‪ :( L1 , L2‬פונקצית האורך היא‬
‫פונקציה מוגדרת היטב שתמיד עוצרת‪ .‬כמו כן הפרדיקטים ‪ odd‬ו‪ even-‬הם פרדיקטים‬
‫שעוצרים תמיד ומוגדרים היטב‪ .‬עם זאת הראנו ש‪ halt-‬היא בעיה הכריעה למחצה‬
‫)כאשר התוכנית עוצרת נוכל תמיד בקלות להחזיר ‪ T‬אך כאשר התוכנית אינה עוצרת‪,‬‬
‫גם הפרדיקט המכריע את ‪ halt‬יתבדר(‪.‬‬
‫נשים לב כי‬
‫}> ‪∪ L2 = {< p, x‬‬
‫‪ . L1‬כלומר‪ ,‬זוהי שפה טריוויאלית של כל התוכניות‬
‫והקלטים ולכן מוכרעת על ידי הפרדיקט ‪ . λp, x.T‬פרדיקט זה תמיד עוצר ומחזיר ‪T‬‬
‫לכל תוכנית ולכן מתקיים‬
‫‪.b‬‬
‫‪L1 ∪ L2 ∈ R‬‬
‫וגם‬
‫‪L1 ∪ L2 ∈ R‬‬
‫כנדרש‪.‬‬
‫‪L1 ∩ L2 ∈ R‬‬
‫פתרון‪ :‬מצב זה אינו אפשרי‪.‬‬
‫הוכחה‪:‬‬
‫נניח בשלילה שהמצב כן אפשרי‪ .‬היות ו‪L1 ∪ L2 ∈ R -‬‬
‫השפה ‪ . L1 ∪ L2‬כמו כן‪ ,‬היות ו‪ L1 ∩ L2 ∈ R -‬קיים פרדיקט ‪ p2‬המכריע את השפה‬
‫‪ . L1 ∩ L2‬נראה כעת כי ניתן להכריע את השפה ‪ L1‬באמצעות הגדרת פרדיקט‪:‬‬
‫קיים פרדיקט ‪ p1‬המכריע את‬
‫)‪p1 ( x) ∧ p 2 ( x‬‬
‫‪T‬‬
‫‪‬‬
‫‪Pl1 ( x) =  F‬‬
‫)‪¬p1 ( x‬‬
‫) ‪ g ( x ) p ( x ) ∧ ¬p ( x‬‬
‫‪1‬‬
‫‪2‬‬
‫‪‬‬
‫כאשר )‪ g(x‬היא תוכנית המקבלת מחרוזת ‪ x‬ומשתמשת בסטפר בצורה הבאה‪ :‬בכל‬
‫פעם היא מפעילה את הסטפר ‪ i‬פעמים לחילופין על הפרדיקט שמכריע את ‪L1‬‬
‫והפרדיקט שמכריע את ‪ .L2‬אם הפרדיקט של ‪ L1‬עוצר באופן טבעי בשלב מסויים ומחזיר‬
‫‪ g ,T‬מחזירה ‪ .T‬אם ‪ L2‬עוצר באופן טבעי בשלב מסויים ומחזיר ‪ g ,T‬מחזירה ‪.F‬‬
‫הוכחת נכונות‪:‬‬
‫התוכנית עוצרת‪ :‬שפות האיחוד והחיתוך הן שפות כריעות על פי ההנחה‪ .‬לכן‪,‬‬
‫הפרדיקטים המכריעים אותן יעצרו בוודאות על כל ערך‪ .‬כמו כן‪ ,‬הפונקציה ‪ g‬תעצור‬
‫תמיד כיוון שאם ‪ x‬שייך לאיחוד ואינו שייך לחיתוך‪ ,‬הוא שייך רק לאחת מהשפות‪ .‬לכן‪,‬‬
‫בשלב מסוים הפרדיקט של השפה אליה הוא שייך יסתיים באופן טבעי ויחזיר ‪ L1) T‬ו‪L2-‬‬
‫הן שפות כריעות למחצה לכן אחד הפרדיקטים חייב להסתיים(‪.‬‬
‫התשובה המוחזרת נכונה‪ :‬אם ‪ x‬שייך לאיחוד ולחיתוך‪ ,‬הוא שייך ל‪ 2-‬השפות בוודאות‬
‫ובפרט שייך ל‪ .L1-‬לכן‪ P ,‬מחזירה ‪ T‬כנדרש‪ .‬אם ‪ x‬לא שייך לאיחוד‪ x ,‬אינו שייך לאף‬
‫אחת מהשפות ובפרט אינו שייך ל‪ ,L1-‬לכן‪ p ,‬מחזירה ‪ F‬כנדרש‪ .‬אם ‪ x‬שייך לאיחוד אך‬
‫לא שייך לחיתוך‪ ,‬אז ‪ x‬שייך בדיוק לאחת השפות‪ .‬התוכנית ‪ g‬קובעת לאיזה מהשפות‬
‫הוא שייך ע"י הרצת סטפר‪ .‬כיוון ש‪ L1‬ו‪ L2-‬הן שפות כריעות למחצה‪ ,‬הפרדיקט המכריע‬
‫את השפה אליה שייך ‪ x‬בטוח יעצור ויחזיר ‪) T‬והוא היחיד שיחזיר ‪ T‬עבור ‪ x‬מהשתיים(‪.‬‬
‫לכן‪ ,‬אם ‪ x‬שייך ל‪ ,L1-‬הפרדיקט של ‪ L1‬בטוח יעצור ויחזיר ‪ T‬ולכן גם ‪ g‬תחזיר ‪ T‬כנדרש‬
‫ואם ‪ x‬אינו שייך ל‪ ,L1-‬הפרדיקט של ‪ L2‬בטוח יעצור ויחזיר ‪ T‬ולכן ‪ g‬תחזיר ‪ F‬כנדרש‪.‬‬
‫סה"כ הראנו שניתן להכריע את ‪ L1‬בסתירה לנתון ש ‪∈ RE / R‬‬
‫‪ . L1‬לכן‪ ,‬ההנחה‬
‫בשלילה אינה מתקיימת והמצב אינו אפשרי‪.‬‬
‫‪10‬‬
‫‪u.multinet.co.il‬‬