Prova dell'indecidibilità del problema dell'arresto

Ho difficoltà a comprendere la prova dell'indecidibilità del problema di Halting.

Se restituisce se il programma o meno un soste in ingresso b , perché dobbiamo far passare il codice di P sia un e $H(a,b)$$a$$b$$P$$a$$b$ ?

Perché non possiamo alimentare con P e qualche input arbitrario, diciamo, x ?$H()$$P$$x$

La prova mira a trovare una contraddizione. Devi capire qual è la contraddizione derivata, per capire perché è usato come input per se stesso. La contraddizione è informale: se abbiamo una macchina H (a, b) che decide "a accetta b", allora possiamo costruire una macchina che accetta macchine che non si accettano. (Leggi che un paio di volte fino a quando lo si ottiene.) La macchina mostrato nella foto - chiamiamolo M - M ( P ) = non P non accetta ⟨ P $P$$M$$M(P) =$$P$$\langle P \rangle$ ?

La contraddizione si verifica quando si chiede: non accetta ⟨ M ⟩ ? Prova a elaborare le due opzioni per vedere come c'è una contraddizione.$M$$\langle M \rangle$

accetta ⟨ M ⟩ se e solo se M non accetta ⟨ M ⟩ ; questa è chiaramente una contraddizione.$M$$\langle M \rangle$$M$$\langle M \rangle$

Questo è il motivo per cui è essenziale che la dimostrazione esegua su se stesso non un input arbitrario. Questo è un tema comune nelle prove di impossibilità note come argomenti diagonali.$P$

Ignora l'immagine per un momento; ci arriveremo tra poco. Il programma dovrebbe essere un tester di arresto: quando diamo a H un input di un programma a (pensiamo a a come l'elenco di un programma) e qualsiasi cosa per b , H ( a , b ) agisce come segue$H(a, b)$$H$$a$$a$$b$$H(a, b)$

1. Se il programma rappresentato da ferma quando viene dato b come input, H ( a , b ) risponderà "sì". D'altra parte, se il programma descritto da a viene eseguito per sempre quando viene fornito l'ingresso b, quindi H ( a , b $a$$b$$H(a, b)$$a$$b$$H(a, b)$ risponderà "no".
2. È importante sottolineare che il programma fermerà sempre e darà la risposta corretta per qualsiasi coppia ( a , b ) .$H$$(a, b)$

L'argomento secondo cui è impossibile da costruire si basa sull'azione di un particolare programma "perverso", P , che utilizza H come subroutine. P prende come input un elenco di qualsiasi programma, x , e fa quanto segue:$H$$P$$H$$P$$x$

P(x) =
  run H(x, x)
  if H(x, x) answers "yes"
      loop forever
  else
      halt

Non è difficile vederlo

si interromperà se e solo se il programma x verrà eseguito per sempre quando viene fornita la propria descrizione come input.$P(x)$$x$

Fin qui tutto bene: sarà sicuramente un programma fintanto che la sua subroutine H è un programma.$P$$H$

Ora torna all'immagine. Cosa succede se riceve la propria descrizione come input? L'immagine descrive proprio quello scenario: Sia p la descrizione del programma P , quindi, sostituendo la parte evidenziata sopra, avremo$P$$p$$P$

si arresterà se e solo se il programma P ( p ) funzionerà per sempre.$P(p)$$P(p)$

Chiaramente, questo comportamento paradossale è impossibile, quindi siamo costretti a concludere che la subroutine non può essere un tester di arresto, dal momento che fallisce in un caso, dove viene dato ( p , p ) come input. Potrebbero esserci altri casi in cui H funziona come dovrebbe, ma poiché H non riesce in almeno una situazione, non può essere un tester di arresto completo, come richiesto.$H$$(p, p)$$H$$H$

Prova una prova più bella con le animazioni. E poiché ansewrs dovrebbe contenere più di un semplice collegamento a un sito, ecco la risposta alla tua domanda.

Innanzitutto, ricordiamo come funziona la prova della non esistenza dell'oracolo di Halting. Dimostriamo che, dato a qualsiasi candidato Hper un oracolo di Halting, esiste un programma Pe un input aper i quali Hnon è possibile prevedere correttamente cosa P(a)fa.

Teorema: Sia Hqualsiasi programma che accetta due input e restituisce sempre halto loop. Quindi esiste un programma Qe un input atale che si Q(a)ferma se, e solo se, H(Q,a)ritorna loop.

Prova. Considera il programma

program P(y):
  if H(y,y) = halt then
    loop forever
  else:
    return

Let Q = Pand a = P. O H(Q,a) = halto H(Q,a) = loop:

• if H(Q,a) = haltthen Q(a)(che è giusto P(P)) viene eseguito per sempre dalla definizione diP .
• se H(Q,a) = looppoi Q(a)fermato dal definitoin di P.

QED

Hai chiesto perché abbiamo preso in considerazione H(P,P)invece che H(P,X)per qualcun altro X. La risposta ovvia è "perché H(P,P)è ciò che fa funzionare la prova"! Se lo usassi H(P,X)per qualche arbitrario X, rimarrai bloccato. In effetti, la prova dovrebbe apparire così:

Prova rotta. Considera il programma

program P(y):
  if H(y,y) = halt then
    loop forever
  else:
    return

Let Q = Pe a = Xper alcuni arbitrari X. O H(Q,X) = halto H(Q,X) = loop:

• supponiamo H(Q,X) = haltquindi che non possiamo dire cosa P(X)fa, perché se le P(X)soste dipendono da ciò che H(X,X)ritorna. Siamo bloccati. Tuttavia, se lo sapessimo P(X)e X(X)siamo gli stessi, potremmo fare progressi. (Quindi, dovremmo davvero prendereX = P ).
• se H(Q,a) = looppoi fossimo di nuovo bloccati e non saremmo bloccati se X = P.

Nessun QED.

Spero che ciò dimostri che dobbiamo considerare H(P,P)per far funzionare la nostra idea.

Il risultato della dimostrazione è questa analogia:

$P$$_{(P)}$$P^{\prime}$$_{(P^{\prime})}$$P$$_{(P)}$$_{(P)}$$_{(P)}$

$_{(P)}$$_{(P^{\prime})}$