Chứng minh REGULAR_TM là không thể giải quyết được

Tôi đang nghiên cứu bằng chứng của định lý sau:

Đưa ra ngôn ngữ

$\mathit{REGULAR}_\mathit{TM} = \{\langle M \rangle | M$ là một máy turing và là thường xuyên$\mathit{Accept}(M)$$\}$

$\mathit{REGULAR}_\mathit{TM}$ là không thể giải quyết được.

Bằng chứng được đưa ra trong Sipser cho thấy rằng nếu chúng ta đã có máy quyết định thì chúng ta có thể tạo một máy quyết định vấn đề tạm dừng:$R$$\mathit{REGULAR}_\mathit{TM}$$S$

Tôi đang gặp khó khăn để hiểu bằng chứng. Đây là cách tôi hiểu nó:

Khi (bất kỳ máy turing nào) và (bất kỳ chuỗi nào) được đưa vào máy , chúng tôi sẽ tạo một máy lấy chuỗi làm đầu vào, nhưng trước tiên chạy máy trên . Trường hợp đầu tiên, nếu , thì chỉ cần chấp nhận x. Đó là trong trường hợp này - tức là một ngôn ngữ thông thường. khác, trường hợp thứ hai, từ chối , sau đó kiểm tra xem đầu vào có dạng hay không và chấp nhận nếu nó là như vậy - tức là$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)$ không phải là ngôn ngữ thông thường. Bên trong , cho cả hai trường hợp này nếu chúng tôi chạy trên sẽ trả về kết quả phù hợp mà có thể trực tiếp trả về.$S$$R$$M_2$$S$

Trường hợp tôi bối rối, trường hợp thứ ba, là khi không dừng lại trên . Sau đó , là ngôn ngữ thông thường và do đó sẽ trả về ACCEPT , không thể trả lại trực tiếp dưới dạng . Nhưng mô tả của giải pháp nghe có vẻ như trả về ACCEPT ngay cả trong trường hợp này (mã giả bên dưới). Vậy tôi đang làm gì sai? Có lẽ có một ý tưởng rất cơ bản mà tôi đang thiếu. Đây là mã giả cho máy và bên trong , như bạn có thể thấy, có máy đó$M$$w$$\mathit{Accept}(M_2) = \{\}$$R$$S$$w \notin \mathit{Accept}(M)$$S$$S$$S$$M_2$$S$ tạo ra.

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

Nhìn lên thiên thạch của Rice. Bằng chứng của nó là khá ngắn và ngọt ngào. Nó nói rằng bất kỳ thuộc tính không tầm thường nào của ngôn ngữ TM (nghĩa là không phải tất cả các ngôn ngữ TM chia sẻ) là không thể quyết định, theo nghĩa là không thể quyết định bằng cách xem TM nếu ngôn ngữ mà nó chấp nhận có thuộc tính.

Thuộc tính thông thường (hoặc ngôn ngữ không ngữ cảnh hoặc ngôn ngữ trống hoặc ngôn ngữ của tất cả các chuỗi hoặc ...) là không tầm thường, do đó, nếu một TM cụ thể chấp nhận một ngôn ngữ với thuộc tính là không thể xác định được, bởi Rice định lý.

Mã giả của bạn sai, sau đây là mã chính xác:

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 Đây là lời giải thích thêm:

1. vonbrand đúng
   Ông đã sử dụng thiên thạch của Rice, nó nói rằng bất kỳ tài sản không tầm thường nào của ngôn ngữ TM là không thể giải quyết được. Điều đó ổn, nhưng ... trong cuốn sách của Sipser, ví dụ này là để chứng minh khả năng lập bản đồ.
   Vì vậy, chúng ta nên sử dụng giảm để khắc phục vấn đề này thay vì thiên thạch của Rice.

2. Điều gì là sai với câu trả lời đề xuất?
   Sai là:
   Khi M (w) LOOP ở M2, R (M2) sẽ trả lại ACCEPT. Tại sao? Bởi vì trong trường hợp này L (M2) là {}, là ngôn ngữ thông thường. Nhưng khi M (w) LOOP, R (M2) không được trả lại ACCEPT.
   Hãy tưởng tượng:
   Nếu R (M2) trả lại ACCEPT, điều gì sẽ xảy ra?
   Sẽ có hai khả năng để M2 chấp nhận R (M2).
   (1) M (w) trả lại CHẤP NHẬN.
   (2) M (w) LOOP.
   Rõ ràng, "hai khả năng" không đáp ứng định nghĩa về Giảm.
   Định nghĩa của Giảm là gì?

   Xin lưu ý <=>, đó là "nếu chỉ nếu".

3. Câu trả lời của tôi làm gì để sửa nó?
   Điều quan trọng là: Chỉ có một khả năng để M2 khiến R (M2) chấp nhận, đó là M (w) trả lại ACCEPT! Điều đó đáp ứng định nghĩa của Giảm.

4. Một giải pháp khác cho vấn đề này:

   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
   

   Trong giải pháp này, tôi sử dụng CompuityOfR thay vì R.
   Lợi ích của việc này là:
   Bây giờ, trong M2 chúng ta có thể chạy M trên w trước.
   Tại sao chúng ta có thể sử dụng CompuityOfR?
   Nếu R là quyết định, thì CompuityOfR cũng có thể quyết định. Vì vậy, chúng ta có thể sử dụng CompuityOfR.