Come dimostrare che una lingua normale "invertita" è regolare


19

Sono bloccato sulla seguente domanda:

"Le lingue regolari sono precisamente quelle accettate dagli automi finiti. Dato questo fatto, mostrano che se la lingua L è accettata da un automa finito, allora anche LR è accettata da alcuni finiti; LR costituito da tutte le parole di L invertite."


1
Bene, hai provato a costruire un automa che avrebbe accettato LR ? Può essere utile fare un esempio.
Gilles 'SO- smetti di essere malvagio' il

Grazie per la risposta. Non sono sicuro di come farlo. Sono sicuro che qualsiasi L ^ R sarebbe accettato da qualche lingua perché è costruito con lo stesso "alfabeto" e quindi sarà anche una lingua normale. Non sono sicuro di come dimostrarlo, o di come fare un esempio.
Gatto

2
Benvenuto! Per tali domande basilari che incombono di compiti a casa, ci piace se la domanda contiene un lavoro precedente (significativo) dell'interrogante. Hai sicuramente provato qualcosa che puoi condividere (che possiamo quindi usare per guidarti nella direzione corretta). In caso contrario, ti suggerisco di ricontrollare le tue definizioni e di seguire il consiglio di Gilles.
Raffaello

3
@Victoria "è costruito con lo stesso 'alfabeto' e quindi sarà anche un linguaggio regolare" - oh, nonono. {anbmaon,m,oN} , {anbmann,mN} e {anbnannN} sono tutti definiti sullo stesso alfabeto, ma rientrano in classi linguistiche molto diverse.
Raffaello

1
L'altra domanda alla fine del capitolo mi chiede di dimostrare che nessun automa finito può accettare tutti i palindromi su un dato alfabeto. Penso che la prova di ciò dipenda dal fatto che ci sono un numero infinito di stati se stiamo considerando tutti i possibili palindromi (nessun limite di lunghezza), mentre la macchina è una macchina a stati finiti.
Gatto

Risposte:


26

Quindi, dato un linguaggio regolare , sappiamo (essenzialmente per definizione) che è accettato da alcuni automi finiti, quindi c'è un insieme finito di stati con transizioni appropriate che ci portano dallo stato iniziale allo stato accettante se e solo se l'input è una stringa in L . Possiamo persino insistere sul fatto che esiste un solo stato accettante, per semplificare le cose. Per accettare la lingua inversa, tutto ciò che dobbiamo fare è invertire la direzione delle transizioni, cambiare lo stato iniziale in uno stato accettato e lo stato accetta nello stato iniziale. Poi abbiamo una macchina che è "indietro" rispetto all'originale, e accetta il linguaggio L R .LLLR


Grazie mille Luke - Penso di aver capito cosa hai detto. Sei perfetto - Non ho assolutamente alcuna esperienza pratica con automi finiti! Vorrei "votarti" ma a quanto pare non ho abbastanza punti. Mi dispiace per quello!
Gatto

Va bene, dovresti essere in grado di "accettare" le risposte che ti piacciono (dovrebbe essere presente un segno di spunta sotto i pulsanti di voto). Anche la risposta più formale di Saadtaame è un eccellente passo dopo il mio.
Luke Mathieson,

5
Per assumere v'è un solo stato accettante ci sia dobbiamo permettere -transitions, o hanno ε L . Entrambi non sono vere restrizioni, lo so, quindi la risposta è OK. ϵϵL
Hendrik Jan

1
Sì, l'idea mi sembra ovvia. La parte difficile è verificare che sia giusto.
Nessuno il

24

Devi dimostrare che puoi sempre costruire un automa finito che accetta le stringhe in LR dato un automa a stati finiti che accetta le stringhe in L . Ecco una procedura per farlo.

  1. Invertire tutti i collegamenti nell'automa
  2. Aggiungi un nuovo stato (chiamalo qs )
  3. Disegna un collegamento etichettato con ϵ dallo stato qs ad ogni stato finale
  4. Trasforma tutti gli stati finali in stati normali
  5. Trasforma lo stato iniziale in uno stato finale
  6. Rendere qs come stato iniziale

Formalizziamo tutto questo; iniziamo affermando il teorema.

Teorema. Se L è una lingua normale, lo è anche LR .

Sia A=(QA,ΣA,δA,qA,FA) essere un NFA e sia L=L(A) . Il ϵ -NFA AR definito di seguito accetta il linguaggio LR .

  1. AR=(QA{qs},ΣA,δAR,qs,{qA}) eqsQA
  2. pδA(q,a)qδAR(p,a) , doveaΣA eq,pQA
  3. ϵclosure(qs)=FA

Prova. Innanzitutto, dimostriamo la seguente affermazione: un percorso da q a p in A etichettato con w se e solo se un percorso da p a q in AR etichettato con wR (il contrario di w ) per q,pQA . La prova è per induzione sulla lunghezza diw .

  1. Caso di base: |w|=1
    Mantiene per definizione di δAR
  2. Induzione: supponiamo che l'istruzione sia valida per le parole di lunghezza <n e lascia |w|=n e w=xa
    Sia pδA(q,w)=δA(q,xa)
    Sappiamo che δA(q,xa)=pδA(p,a) pδA(q,x)
    x ea sono parole con meno din simboli. Dall'ipotesi di induzione,pδAR(p,a) eqδAR(p,xR) . Ciò implica cheqδAR(p,axR)pδA(q,xa) .

Lasciando q=qA e p=s per qualche sFA e sostituendo wR per axR garantisce che qδAR(s,wR) sFA . Poiché esiste un percorso etichettato con ϵ da qs ad ogni stato in FA (3. nella definizione di AR) E un percorso da ogni stato FA allo stato qA marcata con wR , allora v'è un percorso marcato con ϵwR=wR da qs a qA . Questo dimostra il teorema.

Si noti che ciò dimostra che (LR)R=L pure.

Modifica se ci sono errori di formattazione o difetti nella mia prova ....


1
What do you mean by ϵclosure(qs)=FA?
user124384

But you can't have ϵ transition in deterministic regular languages can you!?
yukashima huksay

@yukashimahuksay True, but you can also always take a non-deterministic finite automaton and turn it into a deterministic finite automaton. They are equivalent.
Pro Q

12

To add to the automata-based transformations described above, you can also prove that regular languages are closed under reversal by showing how to convert a regular expression for L into a regular expression for LR. To do so, we'll define a function REV on regular expressions that accepts as input a regular expression R for some language L, then produces a regular expression R for the language LR. This is defined inductively on the structure of regular expressions:

  1. REV(ϵ)=ϵ
  2. REV()=
  3. REV(a)=a for any aΣ
  4. REV(R1R2)=REV(R2)REV(R1)
  5. REV(R1|R2)=REV(R1)|REV(R2)
  6. REV(R)=REV(R)
  7. REV((R))=(REV(R))

You can formally prove this construction correct as an exercise.

Hope this helps!


Hi! I landed here because I was thinking about the idea of reversed regular expressions, as a way of optimizing a right-anchored match against a string: feed the characters to the reverse automaton, in reverse order. One pass. I wrote down the algebraic properties of regex reversal, and it matches your table almost exactly, even using the rev() notation. :) I also put down REV(R1&R2) = REV(R1)&REV(R2); I have a regex implementation which has intersection. Yes; I'm thinking of adding an operator for reversal perhaps R\r (reverse preceding regex element).
Kaz

Here is a tricky one: what is the algebraic rule for REV(~R): regex negation? REV(~R) is the reverse of the set of all strings outside of R. Is that the same as ~REV(R): the set of all strings outside of the reverse of the set denoted by R? This is not clear at all because any palindromes in R are also in REV(R).
Kaz

1

Using regular expressions, prove that if L is a regular language then the \emph{reversal} of L, LR={wR:wL}, is also regular. In particular, given a regular expression that describes L, show by induction how to convert it into a regular expression that describes LR. Your proof should not make recourse to NFAs.

We will assume that we are given a regular expression that describes L. Let us first look at the concatination operator (), and then we can move onto more advanced operators. So our cases of concatenation deal with the length of what is being concatenated. So first we will break all concatenations from ab to ab. When dealing with these break the components up as much as possible: (aba)b(aba)b, but you cannot break associative order between different comprehensions of course.

When R

When s=ϵ, we have the empty string which is already reversed thus the mechanism does not change

When s is just a letter, as in sΣ, the reversal is just that letter, s

When s=σ, we have a single constituent so we just reverse that constituent and thus σR

When s=(σ0σ1...σk1σk) where k is odd, we have a regular expression which can be written as (σ0σ1...σk1σk). The reversal of these even length strings is simple. Merely switch the 0 index with the k index. Then Switch the 1 index with k-1 index. Continue till the each element was switched once. Thus the last element is now the first in the reg ex, and the first is the last. The second to last is the second and the second is the second to last. Thus we have a reversed reg ex which will accept the reversed string (first letter is the last etc.) And of course we reverse each constituent. Thus we would get (σkRσk1R...σ1Rσ0R)

When s=(σ0σ1...σk/2...σk1σk) where k is even, we have a regular expression generally which can be written as (σ0σ1...σk1σk). The reversal of these even length strings is simple. Merely switch the 0 index with the k index. Then Switch the 1 index with k-1 index. Continue till the each element was switched once, but the k/2 element (an integer because k is even). Thus the last element is now the first in the reg ex, and the first is the last. The second to last is the second and the second is the second to last. Thus we have a reversed reg ex which will accept the reversed string (first letter is the last etc.). And that middle letter. And of course we reverse each constituent. Thus we would get (σkRσk1R...σk/2R...σ1Rσ0R)

Okay the hard part is done. Let us look to the operator. This is merely a union of sets. So given two strings, s1,s2, the reverse of s1s2 is only s1Rs2R. The union will not change. And this makes sense. This will only add strings to a set. It does not matter which order they are added to the set, all that matters is that they are.

The kleene star operator is the same. It is merely adding strings to a set, not telling us how we should construt the string persay. So to reverse a kleene star of a string s, is only ((sR)). Reversal can just move through them.

Thus to reverse this (((ab)(a))((ab)(b)))R we simply follow the rules. To reverse the outer union we simply reverse its two components. To reverse this: ((ab)(a)) kleene star, we simply reverse what is inside it (((ab)(a))R). Then to reverse a concatenation, we index and then switch greatest with least. So we start with ((ab)(a))R and get ((a)R(ab)R). To reverse that single letter, we reach our base case and get (a)R(a). This process outlined above describes an inductive description of this change.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.