Comment montrer qu'une langue régulière «inversée» est régulière


19

Je suis coincé sur la question suivante:

"Les langages réguliers sont précisément ceux acceptés par les automates finis. Étant donné ce fait, montrez que si le langage est accepté par un automate fini, alors est également accepté par un certain fini; compose de tous les mots de inversé. "LLRLRL


1
Eh bien, avez-vous essayé de construire un automate qui accepterait LR ? Il peut être utile de dessiner un exemple.
Gilles 'SO- arrête d'être méchant'

Merci pour votre réponse. Je ne sais pas comment faire ça. Je suis sûr que tout L ^ R serait accepté par une langue car il est construit à partir du même «alphabet» et sera donc également une langue régulière. Je ne sais pas comment procéder pour le prouver ou comment dessiner un exemple.
Cat

2
Bienvenue! Pour ces questions de base qui sentent les devoirs, nous aimons si la question contient un travail antérieur (significatif) de l'interrogateur. Vous avez certainement essayé quelque chose que vous pouvez partager (que nous pouvons ensuite utiliser pour vous guider dans la bonne direction). Sinon, je vous suggère de revérifier vos définitions et d'écouter les conseils de Gilles.
Raphael

3
@Victoria "il est construit à partir du même 'alphabet' et sera donc aussi une langue régulière" - oh, nonono. {anbmaon,m,oN} , {anbmann,mN} et {anbnannN} sont tous définis de la même manière alphabet mais tombent dans des classes de langues très différentes.
Raphael

1
L'autre question à la fin du chapitre me demande de prouver qu'aucun automate fini ne peut accepter tous les palindromes sur un alphabet donné. Je pense que la preuve de cela repose sur le fait qu'il existe un nombre infini d'états si l'on considère tous les palindromes possibles (pas de limite de longueur), alors que la machine est une machine à états finis.
Cat

Réponses:


26

Donc, étant donné un langage régulier , nous savons (essentiellement par définition) qu'il est accepté par certains automates finis, il y a donc un ensemble fini d'états avec des transitions appropriées qui nous amènent de l'état de départ à l'état d'acceptation si et seulement si l'entrée est une chaîne en L . On peut même insister sur le fait qu'il n'y a qu'un seul État acceptant, pour simplifier les choses. Pour accepter le langage inverse, tout ce que nous devons faire est d'inverser le sens des transitions, de changer l'état de départ en état d'acceptation et l'état d'acceptation en état de départ. Ensuite , nous avons une machine qui est « en arrière » par rapport à l'original, et accepte la langue L R .LLLR


Merci beaucoup Luke - Je pense que je comprends ce que tu as dit. Vous êtes sur place - je n'ai absolument aucune expérience pratique avec les automates finis! Je vous «voterais», mais je n'ai pas assez de points, apparemment. Désolé pour ça!
Cat

C'est bien, vous devriez pouvoir "accepter" les réponses que vous aimez (il devrait y avoir une coche sous les boutons de vote). La réponse plus formelle de Saadtaame est également une excellente prochaine étape après la mienne.
Luke Mathieson

5
Pour supposer qu'il n'y a qu'un seul Etat d' accepter que nous devons soit permettre -Transitions, ou ont ε L . Les deux ne sont pas de vraies restrictions, je sais, donc la réponse est OK. ϵϵL
Hendrik Jan

1
Oui, l'idée me semble évidente. La partie la plus délicate consiste à vérifier qu'elle a raison.
Personne

24

Vous devez montrer que vous pouvez toujours construire un automate fini qui accepte des chaînes dans LR donné un automate fini qui accepte des chaînes en L . Voici une procédure pour le faire.

  1. Inversez tous les liens dans l'automate
  2. Ajouter un nouvel état (appelez-le qs )
  3. Dessinez un lien étiqueté avec ϵ de l'état qs à chaque état final
  4. Transformez tous les états finaux en états normaux
  5. Transformez l'état initial en un état final
  6. Faire de qs l'état initial

Formalisons tout cela; nous commençons par énoncer le théorème.

Théorème. Si L est une langue régulière, alors LR .

Soit A=(QA,ΣA,δA,qA,FA) un NFA et soit L=L(A) . Le ϵ -NFA AR défini ci - dessous accepte la langue LR .

  1. AR=(QA{qs},ΣA,δAR,qs,{qA}) etqsQA
  2. pδA(q,a)qδAR(p,a) , oùaΣA etq,pQA
  3. ϵclosure(qs)=FA

Preuve. Tout d'abord, nous prouvons l'énoncé suivant: un chemin de q à p dans A étiqueté avec w si et seulement si un chemin de p à q dans AR étiqueté avec wR (l'inverse de w ) pour q,pQA . La preuve est par induction sur la longueur de w .

  1. Cas de base: |w|=1
    Contient par définition de δAR
  2. Induction: supposons que l'instruction soit vraie pour les mots de longueur <n et let |w|=n et w=xa
    Soit pδA(q,w)=δA(q,xa)
    Nous savons que δA(q,xa)=pδA(p,a) pδA(q,x)
    x eta sont des mots de moins den symboles. Par l'hypothèse d'induction,pδAR(p,a) etqδAR(p,xR) . Cela implique queqδAR(p,axR)pδA(q,xa) .

Laisser q=qA et p=s pour certains sFA et en remplaçant wR pour axR garantit que qδAR(s,wR) sFA . Puisqu'il y a un chemin étiqueté avec ϵ de qs à chaque état dans FA (3. dans la définition de AR) Et un trajet à partir de chaque état FA à l'état qA marqué avec wR , alors il existe un chemin marqué avec ϵwR=wR de qs à qA . Cela prouve le théorème.

Notez que cela prouve que (LR)R=L également.

Veuillez modifier s'il y a des erreurs de formatage ou des défauts dans ma preuve ....


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

Pour ajouter aux transformations à base d' automates décrits ci - dessus, vous pouvez également prouver que les langues régulières sont fermées sous l' inversion en montrant comment convertir une expression régulière pour dans une expression régulière pour L R . Pour ce faire, nous allons définir une fonction R E V sur les expressions régulières qui accepte en entrée une expression régulière R pour un langage L , produit alors une expression régulière R ' pour la langue L R . Ceci est défini de manière inductive sur la structure des expressions régulières:LLRREVRLRLR

  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.

R

s=ϵ

ssΣs

s=σσR

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.