1) Nella dimostrazione del teorema di Cook-Levin, una finestra è un rettangolo 2x3 di celle.

Mostrare perché
la prova fallirebbe se si usassero finestre 2x2.

Nella dimostrazione del teorema di Cook-Levin si rappresentano le mosse di una computazione accettante di
una macchina di Turing su una stringa w appartenente a un linguaggio L in NP su un tableau, una tabella 𝑛𝑘 x
2𝑛𝑘 +3 dove n = |w| e 𝑛𝑘 è la lunghezza della computazione più lunga.

Qui ho disegnato il tableau come sulle slide

Ogni riga del tableau rappresenta una configurazione istantanea (id) della macchina di Turing su w. La prima
riga contiene la configurazione iniziale, la k-esima quella accettante, ove k ≤ 𝑛𝑘 .

Questa costruzione ha per obiettivo la produzione di una formula booleana ϕ(M,w) dove M è la macchina di
Turing e w la sua stringa in input tale che ϕ(M,w) = ϕ cell ^ ϕ start ^ ϕ accept ^ ϕ move.

ϕ move = ^ all i,j[la finestra (i,j) è legale]

In particolare, la componente ϕ move utilizza il concetto di finestra legale. Una finestra è una sottomatrice 2x3
nel tableau. Una finestra è legale se rispetta la funzione di transizione di M.

Se la prima riga del tableau rappresenta la configurazione iniziale di M, e tutte le finestre sono legali, allora ogni
riga segue la precedente coerentemente alla funzione di transizione delta.

Qui ho disegnato un esempio di finestra come sulle slide

È cruciale che le finestre siano 2x3 perché solo così si garantisce che se la cella centrale della prima riga di una
finestra non contiene # (non potrebbe perché "sconfinerebbe" fuori dal tableau) e non è adiacente a un
simbolo di stato q, allora essa rimarrà immutata nella riga sottostante. Se invece la cella centrale contiene un
simbolo di stato allora la riga sotto della medesima finestra sarà aggiornata conseguentemente alla funzione di
transizione.

Non funzionerebbe con finestre 2x2 in quanto, per come esse sono rappresentate (il simbolo alla destra del
simbolo di stato rappresenta la cella puntata dalla testina e, in seguito a una transizione, il simbolo di stato può
spostarsi a sx e a dx) non si riuscirebbe a tenere traccia delle transizioni tra due configurazioni istantanee
consecutive. Inoltre con finestre 2x2 non ci sarebbe una cella centrale.

3) Ricavare la grammatica dal seguente PDA

La procedura di conversione di un PDA M in una grammatice Context Free G prevede che G abbia:

- tanti non terminali quante sono le coppie di stati (p,q) di M (di cui Aq0qf è il simbolo iniziale, dove q0 èlo stato
iniziale e qf quello finale);

- le produzioni:

Apq ->AprArq per ogni tre stati p,q ed r;

Apq->aArsb per ogni transizioni da p a r leggendo a e pushando un certo t sullo stack e da s a q leggendo b e
estraendo t dallo stack;

App -> lambda per ogni NT App

Nell'esercizio:

Se il PDA accetta per pila vuota:

Nel PDA c'è un solo stato q, perciò abbiamo l'unico non terminale Aqq, inoltre ci sono le transizioni delta(q,
a,lambda) = {(q, a)} e delta(q, c,a) = {(q, lambda)} per cui abbiamo la produzione Aqq-> aAqqc oltre a Aqq->
lambda

Abbiamo G = (SIGMA, NT,S, R) con SIGMA = {a,c},NT = {Aqq}, S = Aqq e R contiene le produioni

Aqq->lambda|aAqqc

Rinominando Aqq in S abbiamo S->lambda|aSc

È facile osservare che L(G) = {𝑎𝑛 𝑏 𝑛 | 𝑛 ≥ 0}

Derivazioni di esempio: S->aSb->ab, S->aSb->aaSbb->aabb, ecc

In generale

Occorre modificare il PDA in modo che abbia un nuovo simbolo iniziale #, un solo stato finale (nel quale lo stack
deve contenere solo #) e che a ogni mossa faccia solo un push o un pop, mai entrambi.

Gli stati q1 e q2 servono a far sì che lo stack sia configurato come # @ $ <- top, dove $ è il vecchio simbolo
iniziale. Lo stato qe serve a svuotare lo stack per far sì che nello stato finale qf esso contenga solo #.

G ha i non terminali Aq1q2, Aq1q, Aq1qe, Aq2q1, ecc.

e le produzioni di tipo Apq->AprArq: Aq1q->Aq1q2Aq2q, ecc

quelle di tipo Apq->aArsb: Aq1qf->Aq2qe, ecc.