הפוסט שיודע להדפיס את עצמו

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

אם תנסו לכתוב תוכנית שכזו תגלו שזו משימה מעט טריקית. אתמקד בכתיבה בשפת התכנות רובי, שבה הכל יוצא "נקי" יחסית; פונקצית ההדפסה הסטנדרטית בשפה זו היא print. אם כן, נניח שאני רוצה לכתוב תוכנית שמדפיסה את עצמה ואני נוקט בגישה נאיבית, אז התוכנית שלי תהיה מהצורה "…" print, כאשר שלוש הנקודות בתוך המרכאות מייצגות את מה שאני רוצה להדפיס – במקרה זה, קוד התוכנית עצמה. הקוד של התוכנית מתחיל ב-print ולכן התוכנית תהיה חייבת להיות מהצורה ""…" print "print, אלא שכעת שיניתי את קוד התוכנית, ולכן מה שמקבלת פקודת ה-print חייב לגדול שוב, ושוב, ושוב – ולעולם לא אצא מזה. כלומר, הגישה הנאיבית נכשלת כשלון חרוץ. למי שעדיין לא הבין מה לעזאזל השתבש – פשוט נסו לכתוב את התוכנית בעצמם, זה ייתן מייד את התחושה (אין צורך לדעת לתכנת – מספיק להכיר את פקודת print ותו לא).

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

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

הרעיון הוא לבנות מכונה שמורכבת משתי "תת מכונות", $latex A,B$, כך ש-$latex A$ עושה משהו ואז עוצרת, והשליטה עוברת ל-$latex B$ שגם כן עושה משהו ועוצרת, ואחרי שהיא עוצרת על הסרט יהיה כתוב הקידוד של $latex A$ ולאחר מכן הקידוד של $latex B$, מה שאסמן בתור $latex \left\langle AB\right\rangle $. על פניו אני קצת מרמה כאן טכנית – בהגדרות מקובלות של קידודי מכונות טיורינג לא מרשים "פירוק" כזה של מכונה לשתי תת מכונות. אלא שאין בעיה עם הגדרה שכן מרשה "פירוק" שכזה; וכפי שנראה בהמשך, ההנחה אפילו לא הכרחית, רק מפשטת את ההבנה של הבניה.

אם כן, מה $latex A$ תעשה? פשוט מאוד – תכתוב את הקידוד של $latex B$ (כלומר, $latex \left\langle B\right\rangle $) על הסרט ואז תעצור. אבל רגע, מאיפה $latex A$ יודעת מה הקידוד של $latex B$? עדיין לא אמרנו מהי $latex B$ בכלל! אם כן, עלינו להגדיר את $latex B$ במדוייק, אבל להיות מאוד זהירים כשנעשה זאת; אם $latex B$ תהיה תלויה באופן כלשהו ב-$latex A$, תהיה לנו כאן תלות מעגלית (הקוד של $latex B$ תלוי ב-$latex A$, אבל מכיוון ש-$latex A$ מדפיסה את הקוד של $latex B$, בוודאי שהקוד של $latex A$ תלוי ב-$latex B$!). לכן נגדיר את $latex B$ בלי לדבר בכלל על $latex A$.

כש-$latex B$ "מתעוררת" כתוב קלט כלשהו על הסרט. נקרא לו $latex w$. מה שב-$latex B$ תעשה יהיה לבנות קידוד של מכונה שכל ייעודה בחיים הוא לכתוב את $latex w$ על הסרט ולעצור. זה רעיון מעט מחוכם, אבל לא קשה במיוחד. נסו לחשוב האם אתם יכולים, בהינתן קלט $latex w$ כלשהו, לכתוב תוכנית מחשב שכל מה שהיא עושה הוא לכתוב $latex w$ ולעצור; ואם כן, האם אתם מסוגלים לכתוב פונקציה שמקבלת $latex w$ כקלט ומוציאה כפלט קוד של תוכנית מחשב שמדפיסה את $latex w$?

אם כן, נסמן ב-$latex M_{w}$ מכונת טיורינג שמה שהיא עושה הוא לכתוב $latex w$ על הסרט ולעצור. אז מה ש-$latex B$ עושה הוא לבנות את $latex \left\langle M_{w}\right\rangle $ ולכתוב אותו ליד הקלט $latex w$ הקיים, כלומר בסופה של ריצת $latex B$ יהיה כתוב על הסרט $latex \left\langle M_{w}\right\rangle w$. כדי להיות עוד יותר מדוייקים נדבר ממש על פונקציה, $latex q$, שמקבלת כקלט $latex w$ ומוציאה כפלט קידוד של $latex M_{w}$ ספציפית (שהרי יש הרבה מכונות שונות שכותבות $latex w$ על הסרט ועוצרות).

תיארנו את $latex B$ בלי להזדקק ל-$latex A$, ולכן אין בעיה לכתוב מכונה $latex A$ שכל מה שהיא עושה בחיים הוא לכתוב $latex \left\langle B\right\rangle $ על הסרט ולעצור. כאן מגיע הפאנץ': אפשר בתור $latex A$ לבחור את המכונה שהקידוד שלה הוא $latex q\left(\left\langle B\right\rangle \right)=\left\langle M_{\left\langle B\right\rangle }\right\rangle$! כלומר, את המכונה שאת הקידוד שלה הפונקציה $latex q$ מחזירה. האם אתם כבר רואים לאן הולכים מכאן?

אז מה ש-$latex A$ עושה הוא לכתוב $latex \left\langle B\right\rangle $ על הסרט ולעצור. אז $latex B$ "מתעוררת", רואה קלט $latex w=\left\langle B\right\rangle $ ($latex w$ הוא הקידוד של $latex B$, אך $latex B$ לא "יודעת" זאת), ומחשבת את $latex q\left(\left\langle B\right\rangle \right)=M_{\left\langle B\right\rangle }=\left\langle A\right\rangle $. לסיום היא כותבת את הפלט הזה משמאל ל-$latex w$ שהיא קיבלה, כלומר בסיום ריצת $latex B$ כתוב על הסרט $latex \left\langle AB\right\rangle $, בדיוק כפי שרצינו. תעלול פשוט, אך מבריק.

כעת אפשר להסביר מדוע ההנחה שהקידוד של המכונה מורכב קודם כל מהקידוד של $latex A$ ולאחר מכן מהקידוד של $latex B$ היא לגיטימית – כי מה שקורה ל-$latex B$ בסופו של דבר היא שהיא מחזיקה אצלה הן את הקידוד של $latex A$ (בתור ה-$latex q\left(w\right)$ והן את הקידוד של $latex B$ (בתור ה-$latex w$) והיא יכולה לעשות איתם מה שמתחשק לה. אנחנו ביקשנו ממנה לרשום אותם האחד אחרי השני, אבל אם היה צורך להשתמש בהם באופן מחוכם יותר, $latex B$ הייתה יכולה לעשות גם את זה. בעצם כל מה שאנחנו מניחים הוא שאם יש לנו מכונה שמורכבת משתי תת-מכונות $latex A,B$ ויש לנו את הקוד של אותן שתי תתי-מכונות, אז אפשר לבנות את הקוד של המכונה ה"מורכבת" – וזה דבר שאני מניח שתסכימו איתי שהוא אפשרי.

עכשיו אפשר לקחת את הבניה הזו צעד אחד קדימה ולבנות מכונה שיודעת להשתמש בקוד של עצמה כמה שתרצה. לצורך העניין, נחשוב על מכונה $latex T$ שמקבלת שני פרמטרים, $latex \left\langle M\right\rangle ,w$, כאשר $latex w$ הוא הקלט ה"רגיל" של המכונה ואילו $latex \left\langle M\right\rangle $ הוא קידוד של מכונה כלשהי, ו-$latex T$ פועלת כפונקציה של שני הקלטים הללו. מה שאנחנו רוצים להראות הוא קיום של מכונה $latex R$ כך ש-$latex R\left(w\right)=T\left(\left\langle R\right\rangle ,w\right)$. כלומר, $latex R$ מתנהגת כמו $latex T$ בכל הנוגע לקלט $latex w$, ועבור הקוד $latex \left\langle M\right\rangle $ שלה עצמה. מבלבל? אז חשבו על תוכנית מחשב שמקבלת קלט מהמשתמש ועוד משתנה של "הקוד שלי"; אנחנו רוצים לגרום לתוכנית לרוץ כך שהמשתנה "הקוד שלי" יכיל את הערך הנכון.

אין כאן שום גאונות חדשה, אלא רק הרחבה פשוטה של הבניה שכבר ראינו. נוסיף את הקוד של המכונה $latex T$ למשחק, כך שהיא תתחיל לפעול אחרי $latex B$, ולכן הקוד של המכונה ה"משולשת" יהיה $latex \left\langle ABT\right\rangle $. מה ש-$latex A$ יעשה הפעם יהיה לכתוב $latex \left\langle BT\right\rangle $ על הסרט, ואילו $latex B$ יעשה בדיוק את אותו הדבר כמו קודם ויחשב את $latex \left\langle A\right\rangle $. כש-$latex B$ יסיים את ריצתו על הסרט יהיה כתוב $latex \left\langle ABT\right\rangle $ וזה בדיוק מה ש-$latex T$ תראה כאשר היא תתחיל את ריצתה (ואיפה הקלט של $latex T$ נמצא? אפשר להניח שכבר $latex A$ שמרה אותו בצד – זה לא גורר שינוי משמעותי בהגדרות שלנו).

ועכשיו – לקוד בפועל, בשפת רובי, שמשתמש בדיוק ברעיונות שתיארתי כאן:

b = "\n\ndef q(w)\n\t\"b = \#{w.inspect}\"\nend\n\nprint q(b) + b"

def q(w)
    "b = #{w.inspect}"
end

print q(b) + b

לא צריך לדעת יותר מדי רובי כדי להבין מה קורה כאן. הדבר המחוכם ביותר הוא האופן שבו אני מתאר מחרוזת: בתוך מחרוזת אני יכול לכתוב ביטויים כמו n\ ו-t\ שמתפרשים בתור התווים המתאימים לירידת שורה או לטאבים. מה שכתוב בתוך השורה הראשונה בקובץ הוא פשוט כל יתר השורות בקובץ. כל זה מושם בתוך המשתנה b; חשבו על זה בתור הריצה של $latex A$, שכותבת את המחרוזת שמתארת את $latex B$ לא על ה"סרט" (כי אין סרט) אלא לתוך המשתנה b.

החל מהשורה השניה מגיע התיאור של $latex B$. ראשית, הפונקציה $latex q$ שמקבלת $latex w$ ופולטת תוכנית שמה שהיא עושה בחיים הוא להדפיס את $latex w$. האופן שבו היא עושה את זה הוא המקום העיקרי שבו צריך להבין טיפה רובי. ראשית, ברובי לא חייבים לכתוב במפורש return כדי להחזיר ערך מפונקציה; הערך האחרון שמחושב בתוך פונקציה הוא אוטומטית ערך ההחזרה שלה. לכן הפונקציה בת השורה הבודדת הזו כוללת רק מחרוזת, והמחרוזת הזו אוטומטית תהיה הפלט של הפונקציה.

שנית, כשאני כותב מחרוזת בשפת רובי אני יכול "להשתיל" בתוך המחרוזת ערכים של ביטויים. התחביר עבור "השתלה" כזו הוא כתיבה של סולמית (#) ואז את הביטוי שאני רוצה להשתיל במחרוזת כשהוא בתוך סוגריים מסולסלים. במקרה שלנו אני משתיל את הערך של w, אבל לא לפני שאני מבצע שינוי כלשהו לערך הזה באמצעות הפעלת הפונקציה inspect עליו. הפונקציה הזו, כשהיא מופעלת על מחרוזת, מחזירה גרסה חדשה של המחרוזת שכתובה בצורה יותר מפורשת. למשל, אם במחרוזת המקורית היה תו של ירידת שורה (ולכן כשהמחרוזת הייתה מודפסת על המסך הייתה מופיעה ירידת שורה) הרי ש-inspect החליפה את התו הזה בזוג תווים, n\; זה מתאים לאופן שבו תיארתי את ירידת השורה בתוך המחרוזת b מלכתחילה. במהלך ריצת התוכנית מה שקורה הוא שראשית המשתנה b מאותחל על ידי לקיחת המחרוזת ששמים לתוכו וביצוע כל מני המרות בה שהופכות זוג רצוף של תווים כמו n\ לתו ירידת שורה; inspect פשוט מבצעת את התהליך הזה בכיוון ההפוך.

לאחר הגדרת $latex q$ מגיע יתר הקוד של $latex B$; ראשית היא מחשבת את $latex q$ על "תוכן הסרט" הנוכחי (כלומר, על המשתנה b) ומקבלת תוצאה שהיא $latex \left\langle A\right\rangle $; וכעת היא פולטת את השרשור של הפלט הזה עם התוכן של b, בדיוק כמו ש-$latex B$ התיאורטית שלי עבדה.

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

10 תגובות בנושא “הפוסט שיודע להדפיס את עצמו”

  1. תיקון קטן – המדפסת המדוברת לא באמת מסוגלת לייצר העתק של עצמה. לכל היותר להדפיס חלקים נכבדים. עדיין צריך לקנות חיישנים ואלקטרוניקה, כמו גם להרכיב את כל העסק.

    חוץ מזה, אחלה פוסט.

  2. היי גדי,

    אם בא לך להילחם קצת עם תפיסות מתימטיות שגויות, ראה:
    http://n2b.org/archives/1477
    ובנושא אחר:
    http://hahem.co.il/false/archives/434
    ומודי כבר ענה לו כאן:
    http://moddy.blogli.co.il/archives/129

    אגב, במהלך גיגוליי נתקלתי בוריאנט מרענן (ומורבידי) של שיטת-הימור-המרטינגל ("הכפל את ההימור עד שאתה מנצח"):
    http://www.philosophyetc.net/2006/05/shooting-room-paradox.html

  3. אלעד-וו: כמו שכבר עניתי למודי – הפוסט המקורי שלי מכיל את ההסתייגת הברורה מאוד מהנחת היסוד הבעייתית שלו, ובכל מקרה היא שימשה רק כנקודת מוצא לכל מיני דיונים אחרים. הדינמיקה שנוצרה בתגובות, ושבמידה רבה יכולתי לנחשה מראש היתה משעשעת ומשועשעת, וראוי לציין שמודי היה מבכירי המשתתפים בה למרות ההסתייגות שלו.

  4. ניסיתי לכתוב תוכנית כזאת בשפה C:
    אחרי הרבה עבודה, יצא משהו מגעיל כזה:
    #include

    char *p;

    void B();

    int main(VOID) /* This is A */
    {
    static char A_String[] = "void B()n{n int i = 0;n printf("#include \n\n");n printf("char *p;\n\nvoid B();\n\nint main(VOID) /* This is A */\n{\n");n printf(" static char A_String[] = \"");n while (p[i] != 0)n {n if (p[i] == '\n')n printf("\\n");n elsen printf("%c",p[i]);n i++;n }n printf{"\";\n p = A_String;\n B();\n return 0;\n}\n\n"};n printf("%s",p};n}n";
    p = A_String;
    B();
    return 0;
    }

    void B()
    {
    int i = 0;
    printf("#include nn");
    printf("char *p;nnvoid B();nnint main(VOID) /* This is A */n{n");
    printf(" static char A_String[] = "");
    while (p[i] != 0)
    {
    if (p[i] == 'n')
    printf("\n");
    else
    printf("%c",p[i]);
    i++;
    }
    printf("";n p = A_String;n B();n return 0;n}nn");
    printf("%s",p);
    }

    זה יצא בערך על פי התיאור של A ו-B פרט לכך ש-B היתה צריכה לדפיס גם את התוכנית שמדפיסה את w וגם את w עצמה.

  5. כתוב את השורות הבאות עד השורה "סוף"
    אחסן בזכרון את מה שנכתב עד כה
    מחק את מה שנכתב עד כה
    כתוב את השורות הבאות עד השורה "סוף 2"
    כתוב את השורות הבאות עד השורה "סוף"
    סוף 2
    כתוב את תוכן הזכרון
    כתוב את הטקסט "סוף"
    כתוב את תוכן הזכרון
    סוף
    אחסן בזכרון את מה שנכתב עד כה
    מחק את מה שנכתב עד כה
    כתוב את השורות הבאות עד השורה "סוף 2"
    כתוב את השורות הבאות עד השורה "סוף"
    סוף 2
    כתוב את תוכן הזכרון
    כתוב את הטקסט "סוף"
    כתוב את תוכן הזכרון

  6. כרגע גרמת לי לבזבז שעתיים מהחיים שלי בניסיון כושל לכתוב את זה בג'אווה.
    ניסיון לעשות את זה בלי פרוצדורות נכשל בגלל שאי אפשר לשים " בתוך " ". אז ניסיתי לחלק את זה לשלוש פרוצדורות – אחת שמחזירה את כל השאר כמחרוזת, אחת שמחזירה אותה כמחרוזת, ואחת שמצרפת את שתיהן למחרוזת אחת. זה לא פתר את הבעיה. אז עשיתי שa לא תחזיר את השאר כמחרוזת אלא כמערך מחרוזות שמתאר רק את הקטעים של שאר התכנית מגרשיים עד גרשיים – הייתי צריך במערך עשרה אברים, והייתי צריך להוסיף פונקציה שתתרגם את המערך למחרוזת אחת. עשיתי את כל זה, ובסוף גיליתי את הבעיה הבאה: בכל מקום באברי המערך a בו היה כתוב n, הפונקציה שנועדה לכתוב את aבאמת דילגה שורה במקום לכתוב n – כך שהפלט לא היה תקין. כמובן שאפשר לפתור את זה, אבל כבר אין לי כוח.

    בקיצור – אוף@!!!!

כתיבת תגובה

האימייל לא יוצג באתר. שדות החובה מסומנים *