Een eindige toestandsautomaat is een model van berekenbaarheid in de wiskunde en informatica. Eindige toestandsautomaten zijn gebaseerd op grafen en beschrijven een klasse van formele talen die de reguliere talen heten.

Binnen de eindige toestandsautomaten onderscheiden we twee soorten van automaten, de deterministische eindige automaten (en: Deterministic Finite Automaton – DFA) en de non-deterministische eindige automaten (en: Non-deterministic Finite Automaton – NFA). Deze automaten zijn aan verschillende regels onderworpen, maar beschrijven precies dezelfde klasse van talen.

Eindige automaten en reguliere talen

Herkenning

Zoals bij ieder model van berekenbaarheid (zoals de Turingmachine) wordt de werking van een automaat uitgelegd in termen van het herkennen van een bepaalde, formele taal. Een formele taal T is een verzameling rijen van karakters (woorden), waarbij de karakters uit een strikt gedefinieerde verzameling komen. Een herkenner voor een dergelijke taal is een machine die een rij karakters in kan lezen en dan de "ja/nee-vraag" kan beantwoorden of die rij karakters een woord is uit T of niet. "Ja" staat hierbij voor herkenning, "nee" voor geen herkenning, weigering, of welke terminologie men hiervoor ook wenst te gebruiken.

Reguliere talen

Eindige automaten herkennen een klasse van talen die bekend staat als de klasse der reguliere talen. Dit zijn talen die vrij simpel zijn qua structuur. Dat wil overigens niet zeggen dat het kleine of simpele talen zijn – een reguliere taal kan best oneindig veel woorden bevatten. Maar voor al die woorden geldt wel dat ze aan relatief simpele vormregels voldoen. Bijvoorbeeld:

Zij T een reguliere taal, met als alfabet (= verzameling toegestane karakters) de verzameling $\backslash \{a,\; b,\; c\backslash \}$.

Dan is de taal T die verzameling van woorden die gevormd worden door:

eerst 0 of meer keer een a

dan tenminste één c

vervolgens drie keer een a of een b

dan 0 of meer keer een c

en tenslotte de tekenrij abc

Voorbeelden van woorden uit de taal T zijn dan aaaaaccabacabc, aacaaaabc, cbbbabc, aaccccccccccccccbabccabc en acaaacabc.

Daarentegen hoort de rij bcbaa niet in T thuis. Evenmin als aaaacaaaccab, ccde of aaaaaaabc.

Eindige automaten en grafen

Eindige automaten worden vrijwel altijd gemodelleerd als grafen. De reden hiervoor is dat een graaf zo mooi past bij de manier waarop een reguliere taal werkt.

Een reguliere taal bestaat eigenlijk simpelweg uit een opsomming van vormregeltjes die afgewerkt moeten worden. Kan een woord verwerkt worden met behulp van die regeltjes (of gevormd worden met behulp van die regeltjes), dan behoort het woord tot de taal. Anders niet.

Een eindige automaat die dit moet modelleren, moet dus het idee modelleren dat je op een gegeven moment bezig bent met een gegeven regel; dat je in die toestand een karakter in kunt lezen; dat dat karakter bij die regel past, aangeeft dat je overgaat naar de volgende regel, of vastloopt. Dit idee valt zeer goed te vangen in een simpele graaf:

1. Voor iedere toestand van de automaat, bevat de graaf een punt.
2. Ieder inlezen van een karakter past bij een kant van de graaf.
   1. Een kant tussen punten, is een overgang van toestand naar toestand – van de ene regel naar de volgende.
   2. Een kant die een lus is, komt overeen met het soort regel dat zegt "nul of meer keer een X inlezen"

Voer daarnaast afspraken in dat je altijd in een vast punt (een vaste toestand) begint, dat niet verder kunnen in bepaalde toestanden in orde is ("accepterende toestanden") en in andere toestanden niet (de automaat "loopt vast") en je hebt een eindige automaat.

Daarnaast heeft een graafmodel het voordeel dat je zeer veel, bekende graafalgoritmen kunt gebruiken om je taal te analyseren. Minimale modellen opstellen, bepalen of iedere toestand in je model wel bereikbaar is, al dat soort dingen behoren tot het "standaardarsenaal" van de grafentheorie. En bovendien, voor kleinere automaten kun je ook makkelijk illustreren – door een graaf uit te tekenen.

Nemen we als voorbeeld de taal van hierboven en splitsen we de regels iets uit:

Ieder woord in de taal

1. begint met 0 of meer keer een a;
2. dan volgt een c;
3. dan volgen 0 of meer c's;
4. dan volgt een a of een b;
5. dan volgt een a of een b;
6. dan volgt een a of een b;
7. dan volgen 0 of meer c's;
8. dan volgt een a;
9. dan volgt een b;
10. dan volgt een c;
11. dan volgt niets meer.

We kunnen nu de taal vangen in en illustreren met de volgende graaf:

Graaf_reguliere_taal_aster_cplus_aofb3_cster_abc.png

In de bovenstaande graaf zijn de kanten gedecoreerd met de tekens die horen bij die toestandsovergangen. Merk de lussen op die voor "0 of meer keer ..." gebruikt worden. Met een "losse toestandsovergang" (een kant die nergens vandaan komt) is aan de linkerkant aangegeven wat de begintoestand van de automaat is. Met een extra punt is aangegeven wat de accepterende toestand is – komt de automaat bij het lezen van de invoer in deze toestand en is de invoer dan op, dan accepteert de automaat en behoorde de invoer tot onze voorbeeldtaal. Volgt er daarna nog invoer, dan volgt een overgang naar een niet-accepterende toestand waarvandaan geen transities meer zijn; de automaat loopt dan vast in die niet-accepterende toestand en de invoer kan dan niet herkend worden als een woord uit de voorbeeldtaal. Deze regel geldt overigens ook algemeen: als er vanuit een bepaalde toestand geen kant is gedecoreerd met het volgende invoerkarakter, dan zit de automaat vast.

Deterministische eindige automaten

Formeel is een deterministische eindige automaat (DFA) een automaat $M$ met

$M\; =\; (Q,\; \backslash Sigma,\; \backslash delta,\; q\_0,\; F)$

$Q$ een eindige verzameling toestanden

$\backslash Sigma$ een eindige verzameling symbolen, het alfabet van de automaat (of taal) geheten

$\backslash delta$ een totale functie $Q\; \backslash times\; \backslash Sigma\; \backslash rightarrow\; Q$, de transitiefunctie

$q\_0\; \backslash in\; Q$ de begintoestand

$F\; \backslash subseteq\; Q$ de verzameling accepterende toestanden

Van deze automaat $M$ zeggen we dat hij een taal $L(M)$ accepteert. Deze taal is de verzameling van woorden – rijen symbolen uit het alfabet – waarvoor geldt dat M in een accepterende toestand eindigt bij verwerking van die woorden.

De bovenstaande definitie geeft een machine M die overeenkomt met simpele grafen zoals hierboven geïllustreerd; de toestanden komen overeen met knopen in de graaf, elementen van de transitiefunctie met kanten, het alfabet zijn de symbolen die verwerkt worden, de eindige toestanden uit de verzameling toestanden zijn aangegeven en ook de begintoestand.

De "werking" van de machine wordt beschreven door de transitiefunctie $\backslash delta$. Deze functie definieert voor iedere toestand en voor iedere mogelijke volgende invoer wat de toestand is waarnaar de automaat overgaat. Voor ieder paar (toestand, symbool) is maar één volgende toestand gedefinieerd – de automaat is deterministisch.

Merk op dat volgens deze definitie, de transitiefunctie een definitie moet geven voor ieder paar (toestand, symbool). Zelfs als vanuit de gegeven toestand een bepaald symbool niet "ingelezen mag worden". Dit is handig bij het modelleren en ook makkelijk bij de wiskunde, maar bij het uittekenen van de graaf van een machine betekent het dat je vaak en veel nutteloze toestanden krijgt – toestanden die er alleen maar zijn om de machine in vast te laten lopen. Daarom worden dit soort loze transities en toestanden bij een illustratie meestal weggelaten (zoals hierboven ook gebeurd is, in het vorige hoofdstuk).

Ieder automaat heeft maar één begintoestand. Er mogen echter meerdere accepterende toestanden zijn – sterker nog, het is goed mogelijk een automaat te hebben waarin iedere toestand accepterend is. In het bijzonder komt het regelmatig voor dat de begintoestand accepterend is; in dat geval zit het lege woord in de taal.

Non-deterministische eindige automaten

Formeel is een non-deterministische eindige automaat (NFA) een automaat $M$ met

$M\; =\; (Q,\; \backslash Sigma,\; \backslash delta,\; q\_0,\; F)$

$Q$ een eindige verzameling toestanden

$\backslash Sigma$ een eindige verzameling symbolen, het alfabet van de automaat (of taal) geheten

$\backslash delta$ een functie $Q\; \backslash times\; (\backslash Sigma\; \backslash cup\; \backslash \{\backslash epsilon\backslash \})\; \backslash rightarrow\; \backslash wp(Q)$, de transitiefunctie

$q\_0\; \backslash in\; Q$ de begintoestand

$F\; \backslash subseteq\; Q$ de verzameling accepterende toestanden

Van deze automaat $M$ zeggen we dat hij een taal $L(M)$ accepteert. Deze taal is de verzameling van woorden – rijen symbolen uit het alfabet – waarvoor geldt dat M in een accepterende toestand eindigt bij verwerking van die woorden.

Deze automaat lijkt heel erg op de DFA die hierboven beschreven is. Het enige verschil zit in de definitie van de transitiefunctie.

De transitiefunctie definieert bij een NFA voor ieder paar (toestand, symbool) een verzameling van vervolgtoestanden. Bij de verwerking van invoer wordt uit deze toestanden een willekeurige toestand gekozen als vervolgtoestand. Dat wil zeggen dat het verloop van de verwerking van invoer niet altijd voorspelbaar is – de machine is non-deterministisch.

Daarnaast kent de NFA nog een extra soort transitie. Vanuit iedere toestand kan de automaat een element van de invoer proberen te verwerken, maar er is bij een NFA ook de "lege transitie" (in de definitie hierboven weergegeven met als symbool $\backslash epsilon$, waarbij $\backslash epsilon\; \backslash not\backslash in\; \backslash Sigma$) – een soort van "gratis" transitie, waarbij geen element van de invoer verwerkt wordt. Een dergelijke transitie komt overeen met het idee dat een rij symbolen hetzelfde is als diezelfde rij symbolen met een aantal "lege karakters" tussengevoegd:

$abcabcabc\; =\; abc\; \backslash epsilon\; abc\; \backslash epsilon\; \backslash epsilon\; \backslash epsilon\; a\; \backslash epsilon\; bc$

Uiteraard maakt de aanwezigheid van lege karakters een automaat ook non-deterministisch, omdat in een toestand de keuze kan bestaan tussen het verwerken van een invoerkarakter over overgaan naar de volgende toestand via een $\backslash epsilon$-transitie.

Gelijkwaardigheid van DFA's en NFA's

Uiteraard doet zich nu de vraag voor welke soort automaat de meeste uitdrukkingskracht heeft. Welke automaat – DFA of NFA – accepteert de grootste verzameling talen?

Een DFA is deterministisch, makkelijker te besturen en plannen dan een NFA. Maar een NFA heeft meer soorten transities en kan zelfs meerdere vervolgtoestanden definiëren per toestand en invoerkarakter. Daar staat tegenover – een NFA kan misschien een keuze maken voor een vervolgtoestand die resulteert in een vastloper, zelfs als de invoer wel tot de taal van de automaat behoort.

Welke is nu sterker als model?

Het antwoord is: geen van beide. Voor iedere NFA bestaat een gelijkwaardige DFA, voor iedere DFA tenminste een gelijkwaardige NFA.

Om te beginnen met het laatste: voor iedere DFA bestaat tenminste een gelijkwaardige NFA. Het bewijs van deze stelling is triviaal: neem een DFA, knip hem in twee stukken. Voeg vervolgens een extra toestand toe. Verbind het eerste stuk van de DFA met de nieuwe toestand middels een $\backslash epsilon$-transitie. Verbind de nieuwe toestand met het tweede stuk van de DFA middels een $\backslash epsilon$-transitie. Nu heb je een NFA gelijkwaardig met de oorspronkelijke DFA.

De andere kant op is lastiger. Toch valt het aan te tonen:

Zij $M\_N\; =\; (Q\_N,\; \backslash Sigma\_N,\; \backslash delta\_N,\; q\_0,\; F\_N)$ een NFA. Dan bestaat er een DFA $M\_D\; =\; (Q\_D,\; \backslash Sigma\_D,\; \backslash delta\_D,\; \backslash \{q\_0\backslash \},\; F\_D)$ met $L(M\_D)\; =\; L(M\_N)$. Deze DFA valt te construeren uit $M\_N$ middels de volgende procedure:

1. Begin een nieuwe graaf met als enige knoop $\backslash \{q\_0\backslash \}$.
2. Herhaal de volgende stappen, totdat er voor iedere knoop van de graaf een uitgaande kant is voor ieder element van het alfabet:
   1. Neem een knoop $\backslash \{q\_i,\; q\_j,\; \backslash ldots,\; q\_k\backslash \}$ die voor één of andere $a\; \backslash in\; \backslash Sigma$ geen uitgaande kant heeft.
   2. Bereken voor $q\_i,\; q\_j,\; \backslash ldots,\; q\_k$ in de NFA de verzameling toestanden die te bereiken zijn middels transitie-overgangen met $a$ – dat zijn dus de directe overgangen, de $\backslash epsilon$-transities vanuit $q\_i,\; q\_j,\; \backslash ldots,\; q\_k$ en de $\backslash epsilon$-transities vanuit de eerder genoemde directe overgangen.
   3. Zij $q\_l,\; q\_m,\; \backslash ldots,\; q\_n$ de verzameling van alle toestanden die in de vorige stap gevonden zijn.
   4. Als de knoop $\backslash \{q\_l,\; q\_m,\; \backslash ldots,\; q\_n\backslash \}$ nog niet bestaat in de nieuwe graaf, voeg hem dan toe.
   5. Voeg een kant toe in de nieuwe graaf van $\backslash \{q\_i,\; q\_j,\; \backslash ldots,\; q\_k\backslash \}$ naar $\backslash \{q\_l,\; q\_m,\; \backslash ldots,\; q\_n\backslash \}$ gelabeld $a$.
3. Stel de verzameling $F\_D$ samen: dit is de verzameling knopen in de nieuwe graaf die een $q\_i$ bevatten uit de NFA met $q\_i\; \backslash in\; F\_N$.
4. Als $M\_N$ het lege woord accepteert ($q\_0$ is accepterend of een $\backslash epsilon$-transitie vanuit $q\_0$ leidt tot een accepterende toestand), maak dan $\backslash \{q\_0\backslash \}$ accepterend.

Bewijs van de stelling:

1. Als het algoritme klopt, dan bestaat er voor iedere NFA een equivalente DFA. We concentreren dus verder alleen op het algoritme.
2. Het algoritme is eindig; het kan nooit eeuwig doorlopen en dus geen antwoord geven. Dit valt als volgt in te zien:
   1. Stappen 1, 3 en 4 zijn triviaal eindig.
   2. Iedere herhaling van stap 2 voegt een kant toe aan de nieuwe kant toe aan de nieuwe graaf. Maar het aantal knopen van de NFA is eindig. En het aantal knopen van de DFA kan hoogstens de machtsverzameling zijn van de verzameling knopen van de NFA. En het maximaal aantal kanten van de DFA is dus $2^\{|Q\_N|\}\; |\backslash Sigma|$. Dat is eindig, dus het maximaal aantal herhalingen van stap 2 is ook eindig.
3. De correctheid van het algoritme volgt uit inductie naar de lengte van de invoer van de automaat:
   1. Basisgeval, invoerlengte = 0: Als de NFA het lege woord accepteert, dan is $q\_0$ accepterend (of een toestand bereikbaar uit $q\_0$ via $\backslash epsilon$-transities). Dan is in de DFA $\backslash \{q\_0\backslash \}$ accepterend en accepteert de DFA het lege woord. Accepteert de NFA het lege woord niet, dan is $\backslash \{q\_0\backslash \}$ niet accepterend en loopt de DFA vast op het lege woord.
   2. Hypothese, invoerlengte is n: Als een invoer v ter lengte n de NFA in een toestand $q\_i$ brengt, dan is er in de DFA een toestand $Q\_i\; =\; \backslash \{\backslash ldots,\; q\_i,\; \backslash ldots\backslash \}$ waarin de DFA terecht komt bij invoer v.
   3. Stap, invoer = va, invoerlengte = n + 1: Door verwerking van de eerste n karakters van de invoer (het gedeelte v) door de DFA, komen we in toestand $Q\_i$ vanuit toestand $\backslash \{q\_0\backslash \}$, zoals volgt uit de hypothese. In de NFA komen we in een toestand $q\_i$, vanuit $q\_0$. Komen we vervolgens door verwerking van a in de NFA in toestand $q\_j$ vanuit $q\_i$. Volgens de constructie van stap 2 van het algoritme, moet er in de DFA nu een transitie zijn vanuit toestand $Q\_i$ naar $Q\_j\; =\; \backslash \{\backslash ldots,\; q\_j,\; \backslash ldots\backslash \}$ met label a. En dus kan de DFA vanuit $\backslash \{q\_0\backslash \}$ in toestand $Q\_j$ komen. Bovendien geldt dat als $q\_j$ accepterend is in de NFA, dat $Q\_j$ accepterend is in de DFA.

Voor iedere, reguliere taal bestaat een DFA

Wordt behandeld in het lemma reguliere grammatica.

Wiskunde | Theoretische informatica

Краен автомат | Konečný automat | Endlicher Automat | Finite state machine | Autómata finito | Äärellinen automaatti | Automate fini | אוטומט סופי | Automa a stati finiti | 有限オートマトン | Máquina de estado finito | Automat finit | Конечный автомат | Ändlig automat | 有限状态自动机