Prova semplice per le lingue senza contesto chiuse in turni ciclici

Lo spostamento ciclico (chiamato anche rotazione o coniugazione ) di una lingua è definito come . Secondo Wikipedia (e qui ) le lingue senza contesto sono chiuse sotto questa operazione, con riferimenti a documenti di Oshiba e di Maslov. C'è una facile prova di questo fatto? $L$ $\{ yx \mid xy \in L \}$

Per le lingue normali la chiusura è discussa in questo modulo come " Dimostrare che le lingue regolari sono chiuse sotto l'operatore del ciclo ".

formal-languages context-free closure-properties

— Hendrik Jan
fonte

Puoi provare a utilizzare gli automi pushdown. Dato un automa pushdown per la lingua originale, ne costruiamo uno per il turno ciclico. Il nuovo automa funziona in due fasi, corrispondenti alla e parte della parola (dove è nella lingua originale). Nel primo stadio, ogni volta che l'automa vorrebbe far scoppiare un non terminale , può invece spingere un non terminale ; l'idea è che alla fine del primo stadio, lo stack contenga, in ordine inverso, i simboli che si trovano nello stack dopo aver letto dall'automa originale. Nel secondo stadio (l'interruttore non è deterministico), invece di spingere un non terminale $y$ $x$ $yx$ $xy$ $A$ $A'$ $x$ $A$ , C'è permesso di pop un non terminale . Se l'automa originale può effettivamente generare lo stack dopo aver letto , allora quello nuovo sarebbe in grado di far apparire esattamente l'intero stack. $A'$ $x$

Modifica: ecco alcuni dettagli. Supponiamo di avere un PDA con alfabeto , insieme di stati , insieme di stati accettanti , non terminali , stato iniziale e un insieme di transizioni consentite. Ogni transizione consentita ha la forma , il che significa che quando si trova nello stato , dopo aver letto (o , nel qual caso si tratta di una transizione libera), se la parte superiore dello stack è (o , il che significa che lo stack è vuoto), il PDA può (è un modello non deterministico) passare allo stato , sostituendo $\Sigma$ $Q$ $F$ $\Gamma$ $q_0$ $(q,a,A,q',\alpha)$ $q$ $a \in A$ $a = \epsilon$ $A \in \Gamma$ $A = \epsilon$ $q'$ $A$ con . $\alpha \in \Gamma^*$

Il nuovo PDA ha un nuovo non terminale per ogni . Per ogni due stati e , ci sono due stati . Gli stati iniziali (lo stato iniziale effettivo viene scelto in modo non deterministico tra loro tramite -transitions) sono . Per ogni transizione ci sono transizioni corrispondenti e . Ci sono anche altre transizioni. $A'$ $A \in \Gamma$ $q,q' \in Q$ $A \in \Gamma \cup \{\epsilon\}$ $(q,q',1),(q,q',2,A)$ $\epsilon$ $(q,q,1)$ $(q,a,A,q',\alpha)$ $((q,q'',1),a,A,(q',q'',1),\alpha)$ $((q,q'',2,B),a,A,(q',q'',2,B),\alpha)$

Per ogni transizione , ci sono transizioni , dove e . Per ogni stato finale , ci sono transizioni , dove . $(q,a,A,q',\alpha)$ $((q,q'',1),a,B',(q',q'',1),B'A'\alpha)$ $B \in \Gamma \cup \{\epsilon\}$ $\epsilon' = \epsilon$ $q \in F$ $((q,q'',1),\epsilon,A,(q_0,q'',2,\epsilon),A)$ $A \in \Gamma \cup \{\epsilon\}$

Per ogni transizione , ci sono transizioni , dove . Per ogni transizione , ci sono transizioni , dove . Per ogni transizione , esistono "transizioni generalizzate" ; questi sono implementati come una sequenza di due transizioni attraverso un nuovo stato intermedio. Transizioni\ alpha) con $(q,a,\epsilon,q',\alpha)$ $((q,q'',2,A),a,B',(q',q'',2,A),B'\alpha)$ $A \in \Gamma \cup \{\epsilon\}$ $(q,a,\epsilon,q',A)$ $((q,q'',2,B),a,A',(q',q'',2,A),\epsilon)$ $B \in \Gamma \cup \{\epsilon\}$ $(q,a,A,q',B)$ $((q,q'',2,C),a,B'A,(q,q'',2,C),\epsilon)$ $(q,a,\epsilon,q',\alpha)$ $|\alpha| \geq 2$ sono gestiti in modo simile. Per ogni transizione , ci sono transizioni , dove . Le transizioni sono gestite in modo simile. Infine, esiste un unico stato finale e transizioni . $(q,a,A,q',A)$ $((q,q'',2,A),a,B,(q',q'',2,A),B)$ $B \in \Gamma' \cup \{\epsilon\}$ $(q,a,A,q',A\alpha)$ $f$ $((q,q,2,A),\epsilon,\epsilon,f,\epsilon)$

(Potrebbero esserci alcune transizioni che ho perso, e alcuni dei dettagli che sto omettendo sono in qualche modo disordinati.)

Ricordiamo che stiamo cercando di accettare una parola , dove è accettato dal PDA originale. Uno stato significa che siamo allo stadio 1, allo stato , e il PDA originale è allo stato dopo aver letto . Uno stato è simile, dove corrisponde all'ultima che è stata spuntata. Nella fase 1, siamo autorizzati a spingere invece di popping . Lo facciamo per ogni non terminale che viene prodotto durante l'elaborazione di , ma viene visualizzato solo durante l'elaborazione di . Nella fase 2, siamo autorizzati a far scoppiare $yx$ $xy$ $(q,q',1)$ $q$ $q'$ $x$ $(q,q',2,A)$ $A$ $A'$ $A'$ $A$ $x$ $y$ $A'$ invece di spingere . Se lo facciamo, dobbiamo ricordare che la parte superiore del magazzino è davvero ; questo vale solo quando non ci sono cose "temporanee" nello stack, che nel PDA simulato è lo stesso del top-of-stack che è o del modulo . $A$ $A$ $\epsilon$ $B'$

Qui c'è un semplice esempio. Considera un automa per che spinge per ogni e fa apparire per ogni . Il nuovo automa accetta parole di due forme: e . Per parole del primo modulo, fase 1 consiste nello spingere volte'fase 2 consiste di popping volte , spingendo volte , e iniziano volte . Per le parole della seconda forma, per prima cosa premiamo volte $x^n y^n$ $A$ $x$ $A$ $y$ $y^k x^n y^{n-k}$ $x^k y^n x^{n-k}$ $k$ $A'$ $k$ $A'$ $n-k$ $A$ $n-k$ $A$ $k$ $A$ , quindi pop volte , push volte , passaggio allo stadio 2 e pop volte . $k$ $A$ $n-k$ $A'$ $n-k$ $A'$

Ecco un esempio più complicato, per il linguaggio delle parentesi bilanciate di vari tipi ("()", "[]", "<>") in modo tale che i discendenti immediati di ciascun tipo di parentesi debbano appartenere a un tipo diverso. Ad esempio, "([] <>)" è OK ma "()" è errato. Per ogni "(", spingiamo se lo stack top-of-non è , per ogni ")", abbiamo pop . Allo stesso modo , sono associati a "[]" e "<>". Ecco come accettiamo la parola ">) ([()] <". ">)", spingendo e alla fase 2. "(", saltandoe ricordando la parte superiore dello stack . Consumiamo "[()]", spingendo e facendo scoppiare ; quando si spinge $A$ $A$ $A$ $B$ $C$ $C'A'$ $A'$ $A$ $BA$ $B$ , siamo consapevoli che il "vero" top-of-stack è , e quindi le parentesi quadre sono consentite (non saremmo ingannati da ">) (() <"); quando si preme , poiché il top-of-stack è (che non è o del modulo ), allora sappiamo che è anche il "vero" top-of-stack, e quindi sono consentite parentesi tonde (anche se l'ombra top-of-stack è ). Infine, consumiamo "<" e pop . $A$ $A$ $B$ $\epsilon$ $X'$ $B$ $A$ $C'$

— Yuval Filmus
fonte

Mi dispiace, ho difficoltà a capire - puoi spiegare ulteriormente? Dove inizia l'automa e quali sono le sue transizioni? E il passaggio da verifica per ogni simbolo dello stack? Grazie!

A \to A^{'}

$A \to A^{\prime}$

— usul

Suggerimento molto interessante. Grazie. Lo masticherò un po 'per lasciarlo affondare.

— Hendrik

@usul, dovrai compilare tu stesso i dettagli. Il passaggio (nella prima fase) dovrebbe avvenire quando l'automa "vuole" far scoppiare ma non può, e invece spinge . Puoi pensarlo come una mossa non deterministica.

A \to A^{'}

$A \rightarrow A'$

A

$A$

A^{'}

$A'$

— Yuval Filmus,

@Yuval: scusa ma non posso farlo accadere. Quando capisco la tua idea, il nuovo automa inizia simulando la parte , cambiando pop e push. Quindi genera nello stack, dove l'automa originale inizia con quando legge . Qual è l'originale inizia spingendo? Quindi l'automa nuovo deve spuntare dallo stack vuoto. Continuo a pensare che la tua intuizione sia utile, ma sembra necessaria una cura in più.

y

$y$

α

$\alpha$

α

$\alpha$

y

$y$

— Hendrik Jan

@Hendrik, mi dispiace, ma non riesco a seguire il tuo controesempio. A che punto pensi che il nuovo automa debba saltar fuori dallo stack vuoto?

— Yuval Filmus,

Considera Greibach in forma normale . Per costruire una lingua spostata devi solo cambiare le produzioni da a e aggiungere una nuova non terminale che si comporta come , nel caso in cui alcune produzione riferimento . $S \to \alpha A_1 \dots A_n$ $S \to A_1\dots A_n \alpha$ $S'$ $S$ $S$

— Karolis Juodelė
fonte

Grazie, ma questo è spostato da una sola lettera. Sono interessato alla rotazione generale, con un numero arbitrario di lettere.

— Hendrik Jan

@HendrikJan, Beh, se è privo di contesto, quindi sarà sicuramente privo di contesto. Puoi costruire una grammatica per questo applicando il metodo che ho suggerito volte. Puoi anche costruire direttamente la grammatica , "appiattendo" la grammatica data Ad esempio, se e la grammatica ha produzioni da e da , aggiungerei una produzione e ruotarla. Naturalmente, la dimensione di la tua grammatica potrebbe crescere molto rapidamente

{shift}_{1} (L)

$\text{shift}_1(L)$

{shift}_{n} (L) = {shift}_{1} ({shift}_{1} (\dots (L) \dots)

$\text{shift}_n(L) = \text{shift}_1(\text{shift}_1(\dots (L) \dots)$

n

$n$

{shift}_{n} (L)

$\text{shift}_n(L)$

n = 2

$n = 2$

S \to α A B

$S \to \alpha AB$

A \to β C

$A \to \beta C$

S \to α β C B

$S \to \alpha \beta CB$

— Karolis Juodelė

Per fisso hai ragione. Ma qui è fisso o limitato. Ad esempio se allora otteniamo .

n

$n$

n

$n$

L = {a^{n} b^{n} ∣ n \geq 0}

$L = \{ a^nb^n \mid n\ge 0 \}$

{a^{k} b^{n} a^{ℓ} ∣ k + ℓ = n} \cup {b^{k} a^{n} b^{ℓ} ∣ k + ℓ = n}

$\{ a^kb^na^{\ell} \mid k+\ell = n \} \cup \{ b^ka^nb^{\ell} \mid k+\ell = n \}$

— Hendrik Jan

@HendrikJan, capisco. Ho erroneamente supposto che la domanda riguardasse un cambiamento finito. Riconsidererò la mia risposta ...

— Karolis Juodelė

Si è rivelata una buona idea controllare il vecchio classico di Hopcroft e Ullman Introduction to Automata Theory (1979). La chiusura sotto ciclo è Esercizio 6.4c ed è contrassegnata con S **. Le doppie stelle indicano che è uno dei problemi più difficili (nel libro). Fortunatamente la S indica che è uno dei problemi selezionati con una soluzione.

La soluzione è la seguente. Prendi un CFG in forma normale di Chomsky. Considera qualsiasi albero di derivazione e sostanzialmente capovolgilo. Considera un percorso nella struttura originale. A sinistra l'albero ha contributi a destra , il che significa che la stringa derivata è uguale a . (In realtà poiché la grammatica è CNF quando il percorso continua a sinistra, il contributo sarà a destra e il corrispondente è vuoto, ecc.) $S=X_1, X_2, \dots , X_n$ $x_1, x_2, \dots, x_n$ $y_1, y_2, \dots, y_n$ $x_1 x_2 \dots x_n y_n \dots y_2 y_1$ $x_i$

L'albero sottosopra ha un percorso con contributi a sinistra e a destra, quindi il risultato è una derivazione per . Come richiesto. $S', \hat X_n, \dots \hat X_2, \hat X_1$ $y_n, \dots, y_2 y_1$ $x_n, \dots, x_2 x_1$ $y_n \dots y_2 y_1 x_1 x_2 \dots x_n$

I dettagli completi della costruzione sono riportati nel libro.

Nota come questo ricorda la soluzione (accettata) di Yuval. I non terminali che vengono spinti anziché spuntati sono nell'ordine opposto nella pila. Abbastanza simile a capovolto nell'albero.

— Hendrik Jan
fonte