Come mostrare due modelli di calcolo sono equivalenti?

21

Sto cercando una spiegazione su come si possa dimostrare che due modelli di calcolo sono equivalenti. Ho letto libri sull'argomento, tranne per il fatto che le prove di equivalenza sono state omesse. Ho un'idea di base su cosa significhi che due modelli di calcolo siano equivalenti (la vista degli automi: se accettano le stesse lingue). Esistono altri modi di pensare all'equivalenza? Se tu potessi aiutarmi a capire come dimostrare che il modello della macchina di Turing è equivalente al calcolo lambda, sarebbe sufficiente.

proof-techniques computation-models simulation

— saadtaame
fonte

Immagino tu abbia scelto i libri sbagliati.

— Raffaello

@Raphael Che cos'è un buon libro sull'argomento?

— Saadtaame

Vorrei dire "qualsiasi libro sugli automi", ma a quanto pare ora è vero. Sfortunatamente, non ho libri inglesi adatti a portata di mano, scusa.

— Raffaello

1

Un libro sui soli automi non sarà sufficiente.

— reinierpost,

Che libri stai usando?

— Saadtaame,

20

Si mostra che uno dei due modelli può simulare l'altro, a cui viene data una macchina nel modello A, si mostra che esiste una macchina nel modello B che calcola la stessa funzione. Si noti che questa simulazione non deve essere calcolabile (ma di solito lo è).

Si consideri, ad esempio, automi pushdown con due stack (2-PDA). In un'altra domanda , vengono descritte le simulazioni in entrambe le direzioni. Se lo facessi formalmente, prenderesti una macchina Turing generale (una tupla) e costruiresti esplicitamente quale sarebbe il corrispondente 2-PDA, e viceversa.

Formalmente, una simile simulazione può assomigliare a questa. Permettere

$\qquad \displaystyle M = (Q,\Sigma_I,\Sigma_O,\delta,q_0,Q_F)$

essere una macchina di Turing (con un nastro). Poi,

$\qquad \displaystyle A_M = (Q \cup \{q^*_1,q^*_2\},\Sigma_I,\Sigma_O', \delta', q^*_1, Q_F)$

con e dati da $\Sigma_O' = \Sigma_O \overset{.}{\cup} \{\$\}$ $\delta'$

$\quad \displaystyle (q^*_1,a,h_l,h_r) \to_{\delta'} (q^*_1,ah_l,h_r)$ per tutti e , per tutti , per tutti con , per tutti , $a \in \Sigma_I$ $h_r,h_l \in \Sigma_O$
$\quad \displaystyle (q^*_1,\varepsilon,h_l,h_r) \to_{\delta'} (q^*_2,h_l,h_r)$ $h_r,h_l \in \Sigma_O$
$\quad \displaystyle (q^*_2,\varepsilon,h_l,h_r) \to_{\delta'} (q^*_2,\varepsilon,h_lh_r)$ $h_r,h_l \in \Sigma_O$ $h_l \neq \$$
$\quad \displaystyle (q^*_2,\varepsilon,\$,h_r) \to_{\delta'} (q_0,\$,h_r)$ $h_r \in \Sigma_O$
$\quad \displaystyle (q,\varepsilon,h_l,h_r) \to_{\delta'} (q',\varepsilon,h_la) \iff (q,h_r) \to_\delta (q',a,L)$ per tutti e , per tutto , $q \in Q$ $h_l \in \Sigma_O$
$\quad \displaystyle (q,\varepsilon,\$,h_r) \to_{\delta'} (q',\$,\square a) \iff (q,h_r) \to_\delta (q',a,L)$ $q \in Q$
$\quad \displaystyle (q,\varepsilon,h_l,h_r) \to_{\delta'} (q',ah_l,\varepsilon) \iff (q,h_r) \to_\delta (q',a,R)$ per tutto $q \in Q, h_l \in \Sigma_O'$ ,
$\quad \displaystyle (q,\varepsilon,h_l,\$) \to_{\delta'} (q,h_l,\square\$)$ per tutti $q \in Q$ eeper tutti $h_l \in \Sigma_O'$
$\quad \displaystyle (q,\varepsilon,h_l,h_r) \to_{\delta'} (q',h_l,a) \iff (q,h_r) \to_\delta (q',a,N)$ $q \in Q,h_l\in\Sigma_O'$

è un equivalente 2-PDA. Qui, supponiamo che la macchina di Turing usi come simbolo vuoto, entrambe le pile iniziano con un marcatore (che non viene mai rimosso) e significa che consuma input , cambia gli stati da a e aggiorna le pile in questo modo: $\square \in \Sigma_O$ $\$\notin \Sigma_O$ $(q,a,h_l,h_r) \to_{\delta'} (q',l_1\dots l_i,r_1\dots r_j)$ $A_M$ $a$ $q$ $q'$

aggiornamento dello stack
^{[ fonte ]}

Resta da dimostrare che entra in uno stato finale su se e solo se fa. Questo è abbastanza chiaro dalla costruzione; formalmente, devi tradurre accettando le corse su in accettando le corse su e viceversa. $A_M$ $x \in \Sigma_I^*$ $M$ $M$ $A_M$

— Raffaello
fonte

@frabala Avevi ragione, avevo gli stati iniziali nel modo sbagliato. Risolto ora, grazie!

— Raffaello

4

All'inizio dei sistemi comunicanti e mobili: il Pi-Calculus di Robin Milner, c'è un'introduzione sugli automi e su come possono simularsi a vicenda in modo che non possano essere distinti: la bisimulazione . (cfr Bisimulazione su Wikipedia)

Non ricordo bene, dovrei rileggere il capitolo, ma c'era un problema con la simulazione e la bisimulazione che li rendeva non sufficienti per le equivalenze computazionali.

Così Robin Milner presenta il suo Pi-Calculus e lo espone per il resto del libro.

Alla fine, nel suo ultimo libro The Space and Motion of Communicating Agents , potresti dare un'occhiata ai Bigraphs di Robin Milner. Possono modellare Automata, reti di Petri, Pi-Calculus e altre metodologie computazionali.

— Stephane Rolland
fonte

2

Per quanto ne so, l'unico (o almeno il più comune) modo per farlo è confrontare le lingue accettate dalle macchine / dai modelli. Questo è il punto centrale della teoria degli automi: prende il vago concetto di problema o algoritmo e lo trasforma in un insieme matematico concreto (cioè un linguaggio) su cui possiamo ragionare.

Il modo più semplice per farlo è, data una macchina / funzione arbitraria da un modello, per costruire una macchina dal secondo modello che calcola la stessa lingua. Le probabilità sono che utilizzerai l'induzione nella lunghezza dell'espressione, negli stati nella macchina, nelle regole nella grammatica, ecc.

Non ho visto questo fatto con Lambda e TM (anche se sono sicuro al 99% è possibile), ma ho sicuramente visto questo tipo di cose per dimostrare l'equivalenza di NFA ed espressioni regolari. Prima mostri un NFA che può accettare qualsiasi atomo, quindi usando l'induzione, crei NFA che accettano l'unione / concatenazione / Kleene-star di qualsiasi NFA più piccolo.

Quindi fai il contrario, per trovare un RE per qualsiasi NFA.

— jmite
fonte