Spiegare questa definizione formale di calcolo

Sto provando ad attaccare ancora una volta TAOCP, data la pesantezza letterale dei volumi che ho difficoltà a impegnarmi seriamente. In TAOCP 1 Knuth scrive, pagina 8, concetti di base:

Permettere $A$essere un insieme finito di lettere. Sia l'insieme di tutte le stringhe in (l'insieme di tutte le sequenze ordinate ... dove e è in per ). L'idea è di codificare gli stati del calcolo in modo che siano rappresentati da stringhe di . Ora sia un numero intero non negativo e Q (lo stato) sia l'insieme di tutti , dove è in e j è un numero intero ; lascia che$A^*$$A$$x_1$ $x_2$$x_n$$n \ge 0$$x_j$$A$$1 \le j \le n$$A^*$$N$$(\sigma, j)$$\sigma$$A^*$$0 \le j \le N$$I$(input) il sottoinsieme di Q con e lasciare (uscita) il sottoinsieme con . Se e sono stringhe in , diciamo che presenta in se ha la forma per le stringhe e . Per completare la nostra definizione, sia una funzione del seguente tipo, definita dalle stringhe , e dagli interi , per$j=0$$\Omega$$j = N$$\theta$$\sigma$$A^*$$\theta$$\sigma$$\sigma$$\alpha \theta \omega$$\alpha$$\omega$$f$$\theta_j$$\phi_j$$a_j$$b_j$$0 \le j \le N$ :

• $f((\sigma, j)) = (\sigma, a_j)$ se non si verifica in$\theta_j$$\sigma$
• $f((\sigma, j)) = (\alpha \psi_j \omega, b_j)$ se è la stringa più corta possibile per la quale$\alpha$$\sigma = \alpha \theta_j \omega$
• $f((\sigma,N)) = (\sigma, N)$

Non essendo un informatico, ho difficoltà a cogliere l'intero passaggio. Mi viene in mente l'idea che sta dietro un sistema di codici operativi, ma non ho progredito efficacemente nella comprensione. Penso che il problema principale sia che non so come leggerlo in modo efficace.

Sarebbe possibile spiegare il passaggio sopra in modo che io possa capirlo e darmi una strategia per entrare nella logica nell'interpretazione di queste affermazioni?

Ci manca un po 'di contesto, quindi non ho idea del punto che Knuth sta cercando di chiarire, ma ecco come interpretare una macchina di Turing in questo modo. Forse ti aiuterà a capire cosa sta succedendo. In generale, un buon modo per afferrare un concetto è giocarci. Nel caso dei paradigmi di programmazione, ciò significa scrivere un programma. In questo caso, mostrerò come scrivere qualsiasi programma.

Supponiamo che il nastro della macchina di Turing abbia dei simboli $\{0,1,\epsilon\}$ (dove $\epsilon$ sta per "vuoto") e aggiungi un altro simbolo che rappresenta la posizione della testa $H$. I tuoi stati saranno coppie della forma$(q,\alpha)$, dove $q$ è uno stato della macchina di Turing e $\alpha \in \{0,\ldots,14\}$. Ci identifichiamo anche$(F,0)$ con $N$ per qualsiasi stato finale.

Ingresso (non vuoto) $x$, sarà il tuo punto di partenza $(Hx,(s,0))$, dove $s$è lo stato iniziale. La parte difficile è codificare gli stati. Supponiamo che allo stato$q$, dopo aver letto l'input $x$, lo sostituisci con $a(q,x)$, muoviti in direzione $D(q,x) \in \{L,R\}$e passa allo stato $\sigma(q,x)$. Per il$\theta$s, abbiamo

$$\begin{align*} \theta_{q,0} &= 0H0, & \theta_{q,1} &= 0H1, & \theta_{q,2} &= 0H\epsilon, \\ \theta_{q,3} &= 1H0, & \theta_{q,4} &= 1H1, & \theta_{q,5} &= 1H\epsilon, \\ \theta_{q,6} &= \epsilon H0 & \theta_{q,7} &= \epsilon H1, & \theta_{q,8} &= \epsilon H\epsilon, \\ \theta_{q,9} &= H0, & \theta_{q,10} &= H1, & \theta_{q,11} &= H\epsilon, \\ \theta_{q,12} &= 0H, & \theta_{q,13} &= 1H, & \theta_{q,14} &= \epsilon H. \end{align*}$$ Per il $a$s, abbiamo $a_{q,i} = (q,i+1)$ per $i < 14$, e $a_{q,14} = (q,14)$, anche se non dovremmo mai arrivare così lontano. Per il$b$s, abbiamo $$\begin{align*} &b_{q,0} = b_{q,3} = b_{q,6} = b_{q,9} = (\sigma(q,0),0), \\ &b_{q,1} = b_{q,4} = b_{q,7} = b_{q,10} = (\sigma(q,1),0), \\ &b_{q,2} = b_{q,5} = b_{q,8} = b_{q,11} = b_{q,12} = b_{q,13} = b_{q,14} = (\sigma(q,\epsilon),0). \end{align*}$$ Ora resta da determinare il $\psi$S. Permettere$a_0 = a(q,0)$. Se$D(q,0) = L$ poi $$\begin{align*} \psi_{q,0} &= H0a_0, & \psi_{q,3} &= H1a_0, & \psi_{q,6} &= \psi_{q,9} = H\epsilon a_0. \end{align*}$$ Se $D(q,0) = R$ poi $$\begin{align*} \psi_{q,0} &= 0a_0H, & \psi_{q,3} &= 1a_0H, & \psi_{q,6} &= \epsilon a_0 H, & \psi_{q,9} &= a_0H\epsilon. \end{align*}$$ Quindi, lascia $a_1 = a(q,1)$. Se$D(q,1) = L$ poi $$\begin{align*} \psi_{q,1} &= H0a_1, & \psi_{q,4} &= H1a_1, & \psi_{q,7} &= \psi_{q,10} = H\epsilon a_1. \end{align*}$$ Se $D(q,1) = R$ poi $$\begin{align*} \psi_{q,1} &= 0a_1H, & \psi_{q,4} &= 1a_1H, & \psi_{q,7} &= \epsilon a_1 H, & \psi_{q,10} &= a_1 H\epsilon. \end{align*}$$ Infine, lascia $a_\epsilon = a(q,\epsilon)$. Se$D(q,\epsilon) = L$ poi $$\begin{align*} \psi_{q,2} &= H0a_\epsilon, & \psi_{q,5} &= H1a_\epsilon, & \psi_{q,8} &= \psi_{q,11} = H\epsilon a_\epsilon, \\ \psi_{q,12} &= H0a_\epsilon, & \psi_{q,13} &= H1a_\epsilon, &\psi_{q,14} &= H\epsilon a_\epsilon. \end{align*}$$ Se $D(q,\epsilon) = R$ poi $$\begin{align*} \psi_{q,2} &= 0a_\epsilon H, & \psi_{q,5} &= 1a_\epsilon H, & \psi_{q,8} &= \epsilon a_\epsilon H, & \psi_{q,11} &= a_\epsilon H\epsilon, \\ \psi_{q,12} &= 0a_\epsilon H, & \psi_{q,13} &= 1a_\epsilon H, & \psi_{q,14} &= \epsilon a_\epsilon H. \end{align*}$$

Ora applica $f$ripetutamente fino a quando non rimani bloccato. Se segui la costruzione, vedrai che abbiamo simulato il funzionamento della macchina di Turing.

Proviamo a scomporlo poco a poco. Prima di tutto, ricorda cosa ha scritto Knuth a pagina 7:

Definiamo formalmente un metodo computazionale come quadruplo$(Q,I,\Omega,f)$, in quale $Q$ è un set contenente sottoinsiemi $I$ e $\Omega$, e $f$ è una funzione di $Q$in se stesso. [...] Le quattro quantità$Q$, $I$, $\Omega$, $f$ hanno lo scopo di rappresentare ripetutamente lo stato del calcolo, l'input, l'output e la regola computazionale.

Questo è il contorno. Devi leggere "rappresentare" come "contenere";$Q$ conterrà stati (alcuni dei quali sono in $I$, alcuni sono dentro $\Omega$) e $f$sarà una funzione di transizione tra stati; pensalo come un programma.

Permettere $A$essere un insieme finito di lettere. Permettere$A^*$ essere l'insieme di tutte le stringhe in $A$ (l'insieme di tutte le sequenze ordinate $x_1$ $x_2$ ... $x_n$ dove $n \ge 0$ e $x_j$ è dentro $A$ per $1 \le j \le n$).

Questa è solo una reiterazione di cosa $A^*$è. Vedi anche qui .

L'idea è di codificare gli stati del calcolo in modo che siano rappresentati da stringhe di $A^*$.

Questa è probabilmente la frase chiave. Stiamo parlando di calcoli , ovvero sequenze di esecuzione di alcune istruzioni (linguaggio di programmazione) che manipolano alcuni stati , che possono essere considerati valori nelle celle di memoria o valutazioni di variabili. Knuth dice qui che vuole codificare questi stati in modo astratto, vale a dire come parola su un certo alfabeto.

Esempio: considera un programma che utilizza (al massimo)$k$variabili, ognuna delle quali memorizza un numero intero. Cioè, uno stato è dato dalla tupla di valori$(x_1, \dots, x_k)$ dove $x_k$ è il valore (attuale) di $k$-th variabile. Per codificare gli stati di questo modulo in un linguaggio formale, possiamo scegliere$A = \{0,1,\#\}$ con $\#$un separatore. Ora modella un tale stato di$\#\overline{x_1}\#\cdots\#\overline{x_k}\#$ dove $\overline{x_i}$ è la codifica binaria di $x_i$.

In particolare, $(3,5,0)$ sarebbe $\#11\#101\#0\#$.

Adesso molla $N$ essere un numero intero non negativo e Q essere l'insieme di tutti $(\sigma, j)$, dove $\sigma$ è dentro $A^*$ e j è un numero intero $0 \le j \le N$; permettere$I$ essere il sottoinsieme di Q con $j=0$ e lascia $\Omega$ essere il sottoinsieme con $j = N$.

Hai citato male (cattivo Stefano!); le parentesi non sono nel testo originale ed erano fuorvianti (vedi sopra). Knuth definisce$Q$qui come l'insieme di tutti gli stati possibili ($\sigma \in A^*$) in tutti i punti possibili nel calcolo ($j$può essere inteso come contatore di programmi). Perciò,$Q$ contiene tutti gli stati indicizzati da istruzioni qualsiasi calcolo dell'algoritmo fornito da $f$posso presumere. Per definizione, iniziamo con il contatore dei programmi$0$ e finire in $N$, quindi dichiara indicizzato $0$ sono stati di input e quelli indicizzati $N$ sono stati di uscita.

Se $\theta$ e $\sigma$ sono stringhe dentro $A^*$, lo diciamo $\theta$ Si verifica $\sigma$ Se $\sigma$ ha la forma $\alpha \theta \omega$ per archi $\alpha$ e $\omega$.

Spero che questo sia chiaro; è solo una (ri) definizione di sottostringhe.

Per completare la nostra definizione, lascia $f$ essere una funzione del seguente tipo, definita dalle stringhe $\theta_j$, $\phi_j$ e gli interi $a_j$, $b_j$ per $0 \le j \le N$:

• $f((\sigma, j)) = (\sigma, a_j)$ Se $\theta_j$ non si verifica in $\sigma$
• $f((\sigma, j)) = (\alpha \psi_j \omega, b_j)$ Se $\alpha$ è la stringa più corta possibile per la quale $\sigma = \alpha \theta_j \omega$
• $f((\sigma,N)) = (\sigma, N)$

Questo è un piccolo linguaggio di programmazione; se aggiusti$\theta_j, \psi_j, a_j, b_j$, hai un programma. Sul contatore programmi$j$, $f$ sostituisce l'occorrenza più a sinistra $\theta_j$ nello stato con $\psi_j$ e va alla dichiarazione $b_j$. Se non c'è$\theta_j$ nello stato attuale, va a dichiarazione $a_j$. Il programma esegue un'istruzione if$N$ viene raggiunto, terminando la modellazione.

Nella metà superiore della pagina 8, c'è un esempio più concreto di un "programma" $f$. Tieni presente che Knuth utilizzerà il linguaggio assembly in seguito; questo informa come guarda i programmi (dichiarazioni atomiche collegate da salti).

Quel testo descrive il seguente pseudocodice (Python):

subs = a list of string pairs  
As = a list of integers  
Bs = a list of integers

def f(state, pc):  
  if pc == N: return (state, pc)  
  if state.find(subs[pc][0]) != -1:  
    return (state.replace(subs[pc][0],subs[pc][1],1), Bs[pc])  
  else:  
    return (state,As[pc])  

Presumibilmente la funzione f verrà applicata ripetutamente.

Gli ultimi tre punti elenco sono tutto ciò di cui hai veramente bisogno una volta comprese le notazioni. Tutto ciò che viene prima è un po 'analogo a spiegare come funziona Python prima di dare il codice Python.