Beweisen Sie, dass REGULAR_TM unentscheidbar ist

Ich studiere den Beweis des folgenden Satzes:

Angesichts der Sprache

$\mathit{REGULAR}_\mathit{TM} = \{\langle M \rangle | M$ ist eine Turingmaschine und ist regulär$\mathit{Accept}(M)$$\}$

$\mathit{REGULAR}_\mathit{TM}$ ist unentscheidbar.

Der in Sipser gegebene Beweis zeigt, dass wir, wenn wir bereits eine Maschine , die entscheidet , eine Maschine können, die das entscheidet:$R$$\mathit{REGULAR}_\mathit{TM}$$S$

Ich habe Probleme, den Beweis zu verstehen. So verstehe ich es:

Wenn (eine beliebige Turingmaschine) und (eine beliebige Zeichenfolge) der Maschine zugeführt werden , konstruieren wir eine Maschine , die eine Zeichenfolge als Eingabe verwendet, aber zuerst Maschine auf . Erster Fall, wenn , dann akzeptiert einfach x. Das ist in diesem Fall - dh eine reguläre Sprache. Andernfalls lehnt zweiten Fall , dann prüft , ob die Eingabe die Form , und akzeptiert, ob dies der Fall ist - dh$M$$w$$S$$M_2$$x$$M$$w$$w$ $\in$$\mathit{Accept}(M)$$M_2$$\mathit{Accept}(M_2) = \sum^*$$M$$w$$M_2$$x$$0^n1^n$$\mathit{Accept}(M_2)$ ist keine reguläre Sprache. In gibt in beiden Fällen, wenn wir auf ausführen, das entsprechende Ergebnis zurück, das direkt zurückgeben kann.$S$$R$$M_2$$S$

Der Fall, über den ich verwirrt bin, der dritte Fall ist, wenn nicht auf bleibt . Dann ist , was eine reguläre Sprache ist, und gibt daher ACCEPT zurück , was nicht direkt als . Aber die Beschreibung der Lösung klingt für mich wie kehrt ACCEPT auch in diesem Fall (Pseudo - Code unten). Also, was mache ich falsch? Es gibt wahrscheinlich eine sehr grundlegende Idee, die mir fehlt. Hier ist der Pseudo-Code für die Maschine , und im Innern , wie Sie sehen können, gibt es die Maschine dass$M$$w$$\mathit{Accept}(M_2) = \{\}$$R$$S$$w \notin \mathit{Accept}(M)$$S$$S$$S$$M_2$$S$ schafft.

machine S(M, w):
    // Construct an instance of machine M2 which uses M and w
    machine M2(x):
        r := M(w)  // Might hang here
        if r == ACCEPT:
            return ACCEPT
        else:
            if x is of form 0^n.1^n:
                return ACCEPT
            else:
                return REJECT

    // Run R on M2 (always returns, never hangs)
    r1 = R(M2)
    if r1 == ACCEPT:
        return ACCEPT
    else:
        return REJECT

Schauen Sie sich Rices Teorem an. Sein Beweis ist ziemlich kurz und süß. Es heißt, dass jede nicht triviale Eigenschaft einer TM-Sprache (dh eine, die nicht alle TM-Sprachen gemeinsam haben) in dem Sinne unentscheidbar ist, dass nicht durch Betrachten des TM entschieden werden kann, ob die von ihr akzeptierte Sprache die Eigenschaft hat.

Die Eigenschaft, regulär zu sein (oder eine kontextfreie Sprache oder die leere Sprache oder die Sprache aller Zeichenfolgen oder ...), ist nicht trivial. Wenn also ein bestimmtes TM eine Sprache mit der Eigenschaft akzeptiert, ist es für Rice unentscheidbar Satz.

Ihr Pseudocode ist falsch, der folgende ist der richtige:

machine S(M, w):
    // Construct an instance of machine M2 which uses M and w
    machine M2(x):
        if x is of form 0^n.1^n:
            return ACCEPT
        else:
            r := M(w) // If LOOP, M2 accept 0^n.1^n
            if r == ACCEPT: 
                return ACCEPT // M2 accept Sigma* (Only this case make M2 accept regular language if only if M(w) accept)
            else if r == REJECT: 
                return REJECT // M2 accept 0^n.1^n

    // Run R on M2 (always returns, never hangs)
    r1 = R(M2)
    if r1 == ACCEPT:
        return ACCEPT
    else:
        return REJECT

@ David Richerby Hier ist eine weitere Erklärung:

1. vonbrand hat recht
   Er benutzte Rices Teorem, es heißt, dass jede nicht triviale Eigenschaft einer TM-Sprache unentscheidbar ist. Das ist in Ordnung, aber ... in Sipsers Buch soll dieses Beispiel die Reduzierbarkeit der Zuordnung demonstrieren.
   Wir sollten also Reduktion verwenden, um dieses Problem zu lösen, anstatt Rices Teorem.

2. Was ist falsch an der vorgeschlagenen Antwort?
   Das Falsche ist:
   Wenn M (w) LOOP in M2 ist, gibt R (M2) ACCEPT zurück. Warum? Weil in diesem Fall L (M2) {} ist, was eine reguläre Sprache ist. Wenn jedoch M (w) LOOP ist, darf R (M2) ACCEPT nicht zurückgeben.
   Stellen Sie sich vor:
   Wenn R (M2) ACCEPT zurückgibt, was passiert dann?
   Es gibt zwei Möglichkeiten für M2, R (M2) akzeptieren zu lassen.
   (1) M (w) gibt ACCEPT zurück.
   (2) M (w) LOOP.
   Offensichtlich entsprechen "zwei Möglichkeiten" nicht der Definition von Reduktion.
   Was ist die Definition von Reduktion?

   Bitte beachten Sie, dass <=> "wenn nur wenn" ist.

3. Was macht meine Antwort, um es zu korrigieren?
   Der Schlüssel ist: Es gibt nur eine Möglichkeit für M2, R (M2) zu akzeptieren, nämlich M (w) ACCEPT zurückzugeben! Das entspricht der Definition von Reduktion.

4. Eine andere Lösung für dieses Problem:

   machine S(M, w):
       // Construct an instance of machine M2 which uses M and w
       machine M2(x):
           r := M(w)
           if r == ACCEPT:
               if x is of form 0^n.1^n:
                   return ACCEPT
               else:
                   return REJECT
           else if r == REJECT:
               return REJECT
   
       // Run R on M2 (always returns, never hangs)
       r1 = ComplementOfR(M2) // use Complement Of R
       if r1 == ACCEPT:
           return REJECT
       else:
           return ACCEPT
   

   In dieser Lösung verwende ich ComplementOfR anstelle von R.
   Die Vorteile davon sind:
   Jetzt können wir in M2 zuerst M auf w ausführen.
   Warum können wir ComplementOfR verwenden?
   Wenn R entscheidbar ist, ist auch ComplementOfR entscheidbar. Somit können wir ComplementOfR verwenden.