Cours 2 : Automate minimal

Automate minimal

Rappel : si 𝒜=Q,𝛴,𝛿,q0,F est déterministe complet, alors chaque lettre a𝛴 peut être vue comme une action sur Q :

aq=q si 𝛿(q,a)=q

Morphisme d’automates 𝒜i=Qi,𝛴i,𝛿i,q0,i,Fi pour i{1,2} :

𝜑:Q1Q2 est morphisme de 𝒜1 à 𝒜2 si

  1. 𝜑(q0,1)=q0,2
  2. a𝛴,𝜑(aq)=a𝜑(q)
  3. qF1𝜑(q)F2
Isomorphisme :

morphisme bijectif

Résiduel w1L à gauche de L par w :
w1L{v𝛴wvL}

NB :

  • 𝜀1L=L
  • (ua)1L=a1(u1L)
  • a𝛴,u𝛴

Si 𝒜 est dét. comp. :

a1L=L(𝒜a)

𝒜aQ,𝛴,𝛿,aq0,F et, en général :

w1L=L(𝒜w)

𝒜wQ,𝛴,𝛿,wq0,F


Si 𝒜 est un automate, on pose :

Lq(𝒜){v𝛴q𝒜vqfF}

NB :

qILq(𝒜)=L(𝒜)

LEMME : Si 𝒜 est déterministe complet, alors

w𝛴,w1L(𝒜)=Lwq0(𝒜)

D’où :

|{w1Lw𝛴}||Q|

Corollaire : Si L est régulier, alors l’ensemble des résiduels à gauche de L est fini.

Automate 𝒜L des résiduels de L :
𝒜LQL,𝛴,𝛿L,𝜀1L,F

QL{w1Lw𝛴} a𝛴,a(w1L)(wa)1L
%3 w1 w^{-1} L w2 (wa)^{-1} L w1->w2 a
FL{w1LwL}={w1L𝜀w1L}

Lemme : L(𝒜L)=L

Preuve :


NB :

  • w𝛴,Lw1L(𝒜L)=w1L

  • L(wa)1L


Preuve (laborieuse) : par double inclusion :

  • Si wL :

    • si w=𝜀 : alors w1L=L état initial de 𝒜L, donc wL(𝒜L)
    • sinon si w=av : va1L donc vLv1L(𝒜L) (hypothèse d’induction), et donc avL(av)1L(𝒜L)
  • Si wL(𝒜L) :

    • Si w=𝜀, L état initial de 𝒜L est final, donc 𝜀=wL
    • sinon, si w=av : vLa(v1L)(𝒜L) donc va1L, et avL

MIEUX :

Lemme : w(L)=w1L

Par induction sur w.

  • Si wL alors 𝜀w1L et donc wL(𝒜L)
  • Si wL(𝒜L) alors 𝜀w1L, et donc wL

Ex :

%7 aL a^+ L' aEtL a^* L' aL->aEtL a aL->∅ b aEtL->aL b aEtL->aEtL a L L L->aL b L->∅ a

L=(ba+)+, L=(ba+)


Lemme : Soit 𝒜 dét. comp.

Alors 𝜑:qLq est un morphisme surjectif d’automates.

Preuve :

  1. Lq0(𝒜)=L
  2. Laq=a1Lq=a(Lq)
  3. 𝜀LqqF

Donc l’automate des résiduels est l’unique automate dét. comp. minimal à isomorphisme près.

NB : par contre, le problème de l’égalité entre deux langages réguliers (en l’occurrence, ici : les résiduels) est PSPACE-complet : l’algo n’est pas du tout efficace !

Algorithme de minimisation

Soit une relation d’équivalence sur Q.

Automate quotient 𝒜 de 𝒜 par :
𝒜Q,𝛴,𝛿,q,F

où :

  • $𝛿_≡ ≝ \lbrace ([q]≡, a, [q’]≡) \mid (q, a, q’)∈𝛿\rbrace$
  • F{[q]qF}

alors

L(𝒜)L(𝒜)
  • En effet : Soit wL(𝒜) : w=a1an

    Iq0𝒜a1q1𝒜a2𝒜anqnF

    on a donc :

    I[q0]𝒜a1[q1]𝒜a2𝒜an[qn]F

    et wL(𝒜)


Congruence sur 𝒜 dét. comp. :

une rel. d’éq. tq :

  • qqaqaq
  • qq(qFqF)

Lemme : Si est une congruence, alors L(𝒜)=L(𝒜/)

Preuve :

La seule chose à montrer est L(𝒜/)L(𝒜)

Soit w=a1anL(𝒜/).

I[q0]a1[q1]𝒜a2an[qn]F

On montre que : i1,n, il existe

qi[qi] tq

q0a1anqi
  • Pour i=0 : q0=q0 convient

  • Induction :

    [qi]ai[qi+1]

    et par HR :

    q0a1aiqiqi

    donc

    aiqiaiqiqi+1

    donc qi+1aiqi convient.

    Enfin : qnF ssi qnF

    et donc l’exécution q0wqn est acceptante.


Congruence de Nérode :

qq ssi Lq(𝒜)=Lq(𝒜)

NB :

  • on vérifie aisément que c’est une congruence

  • A/ est isomorphe à l’automate minimal : 𝜑:qLq devient injective

Algorithme de Moore

On définit une famille (i)i d’équivalences sur 𝒜 dét. comp. :

  • q0q ssi (qFqF)
  • i,qi+1q ssi qiq et a𝛴,aqiaq

Lemme :

k;i,k=i+k et k est la congruence de Nérode

  1. La décroissance de la suite est claire

  2. Si $≡i \, = \, ≡{i+1}$, alors j,i=i+j

Donc k|Q|;

j,k=k+j
  1. On note l’équivalence de Nérode : montrons que ∼⊆ii

Si Lq=Lq, alors :

  • pour i=0 : qFqF donc le résultat s’ensuit.

  • pour i>0 : ∼⊆i par HR, donc

    qiq

    et

    aqaqa

    implique

    aqiaq

    donc

    ∼⊆i+1
  1. i⊆∼

Soit qk+|w|q

et donc

wqkwq

et donc

wLq implique wqF implique wqF implique wLq

Ex :

𝒜n “circulaire” avec n états, d’état initial et final 0

Partitions :

  • 0={0}{1,,n1}

  • 1={0}{n1}{1,,n2}

  • 2={0}{n1}{n2}{1,,n3}

  • ∼={0}{n1}{n2}{1}


⟶ L’algorithme naïf en O(|Q|3|𝛴|)

Pi déjà construite,

Pi=B1,,Bk

Concrètement, on associe à chaque qQ un entier

bloc(q)max

tq qiq ssi bloc(q)=bloc(q)

Pour tout a∈𝛴:
  Pour tout q∈Q:
    bloc(q) = max × bloc(q) + bloc(a \cdot q)
  max = 2max +1

algo en O(|Q|2|𝛴|)

NB :

  • alogrithme d’Hopcroft en O(nlogn)

  • union find : pas très bon ici

  • En TD : un algorithme en 2O(n) dit de “double renversement” de BROZOZWSKI

fonctionne sur un automate non dét. !

NB :

  • mais en pratique : tous ces algos sont plutôt efficace (MOORE, BROZOZWSKI, HOPCROPFT)
  • très souvent : BROZOZWSKI est même plus efficace que MOORE et HOPCROPFT ! (car les opérations de renversement sont très faciles à faire en pratique)

  • En espérance : MOORE est en 𝛳(nlogn) : donc en moyenne, MOORE est aussi bon qu’HOPCROPFT.

Leave a comment