Abstraktās mašīnas un automāti

Formālās specifikācijas

Kas ir dators?

Dažādi uztveres/matemātiskie modeļi. Varam uz datoru skatīties dažādos veidos.

(a) Dators kā lietotāja tekstu un tabulu apstrādes līdzeklis, uz datora iespējams izpildīt lietojamas programmas (Word, Excel, u.c.) (b) Dators kā vide programmēšanai (valodā C++, PASCAL, PROLOG, u.c.) (c) Dators kā bināras simbolu virknes apstrādājoša iekārta (viss sastāv no 0 un 1, baits – 8 biti, Kbaits – 1024 baiti, u.tml.) (d) Dators kā fizikāli realizētu mikroshēmu sistēma , sastāv no diodēm, tranzistoriem, u.c. elementiem.

Starp (b) un (c) vēl 3 līmeņi: (b1) asemblera valoda (instrukcijas darbam ar reģistriem, atmiņas šūnām) (b2) operētājsistēmas kodols (vada uzdevumu plūsmu datorā) (b3) mikroprogrammas (procesora instrukciju realizācija loģisko operāciju līmenī).

Zemāks līmenis realizē operācijas , kas pieejamas (izmantojamas) augstākā līmenī .

Lai strādātu augstākā līmenī, nav jāzina visas zemākā līmeņa detaļas (lai brauktu ar trolejbusu, nav jāzina tā dzinēja uzbūve).

Vienai un tai pašai sistēmai varam veidot dažādus matemātiskos modeļus.

Abstraktās mašīnas

Diskrētais process : tas, kas notiek datora programmas izpildes laikā.

tas, kas notiek datora darbības laikā (0 un 1, vai citā līmenī).

Dažādi abstrakcijas līmeņi vienam un tam pašam diskrētajam procesam.

Šajā kursā: būtiska koncentrēšanās uz diskrētā procesa matemātisko modeļu veidošanu un analīzi.

Abstraktā mašīna – diskrētā procesa matemātiskais modelis (viens iespējams veids) Abstraktā mašīna: vadības bloks + datu bloks Abstraktās mašīnas stāvoklis : norāde uz kārtējo instrukciju vadības blokā, datu bloka saturs Abstraktās mašīnas komandas izpilde : izpilda kārtējo instrukciju no vadības bloka (iespējams, izmaina datu bloka saturu; var būt arī ievada un izvada operācijas) uzstāda nākamo kārtējo vadības bloka instrukciju.

Vienkārša abstraktā mašīna: galīgs automāts (tukša datu telpa).

Galīgie automāti nozīmīgi gan no programmēšanas valodu sintakses, gan arī semantikas apraksta viedokļa.

Abstraktās mašīnas kā semantikas modelis

while  (x=y) do if x  y then y:=y-x else x:=x-y fi od A:  (x=y) + + B: x  y E: beigas C: y:=y-x D: x:=x-y Piemērs: vienkārša programma un atbilstoša blokshēma.

Abstrakta mašīna – vadības bloks + datu bloks, komandas izpilde maina norādi uz kārtējo instrukciju vadības blokā, maina datu informāciju.

Blokshēma – “pusceļš” uz atbilstošās abstraktās mašīnas definīciju.

Vadības stāvokļu kopa: Datu stāvokļu kopa: { A, B, C, D, E } StVar = {x,y}  Z (vai Fun({x,y}, Z), vai Z  Z) Lai abstrakto mašīnu definētu precīzi, vajadzīgi vēl pāreju nosacījumi pA+, pA-, pB+, pB- (kā predikāti kopā StVar) un pāreju funkcijas fA+, fA-, fB+, fB-, fC, fD (kā funkcijas StVar  StVar).

Galīgs automāts kā abstrakta mašīna

Abstrakta mašīna – vadības bloks + datu bloks, komandas izpilde maina norādi uz kārtējo instrukciju vadības blokā, maina datu informāciju.

Galīgais automāts – vienkāršākā abstraktā mašīna, tikai vadības bloks.

Galīgs skaits dažādu stāvokļu un pārejas starp tiem. “Kafijas automāts”: Katrā brīdī atrodas vienā no 2 “stāvokļiem”: m k Var pieņemt monētu, vai var izdot kafiju.

Stāvokli nosaka iepriekšējā darbību secība .

Galīgs dažādu stāvokļu skaits, galīgs skaits variantu, kā automāts var reaģēt pašreizējā situācijā.

Ir sistēmas, ko var adekvāti aprakstīt ar galīgu automātu.

Cita veida sistēmām galīgs automāts var būt “abstrakcija”, kas var atspoguļot vairākas (lai arī ne visas) būtiskas sistēmas īpašības.

Galīgi automāti būtiski gan valodu sintakses, gan semantikas uzdošanā (redzēsim arī atšķirības starp šiem 2 lietojumiem).

Galīgs automāts (akceptors)

Galīgu automātu (akceptoru) raksturo: Galīga stāvokļu kopa Q (kādos stāvokļos automāts var atrasties).

Galīgs ieejas simbolu alfabēts I (kādus ieejas simbolus automāts var saņemt / kādos notikumos automāts var piedalīties).

Pāreju attiecība   Q  I  Q.  q,a,q’    apzīmējam arī kā q -a  q’, pieraksts tam, ka no stāvokļa q, saņemot ieejā simbolu a, automāts var pāriet uz stāvokli q’.

Sākuma stāvokļu kopa S  Q, beigu stāvokļu kopa F  Q.

Definējam, ka automāts “ir” kortežs: A =  Q, I,  , S, F  (minētie 5 elementi automātu raksturo viennozīmīgi).

Automāts “akceptē vārdu”.

I* galīgo vārdu kopa alfabētā I. (x  I* )   k: x = a 1 a 2 …a k ,  i  k a i  I.

Rakstam q -x  q’, ja q -a 1  q 1 –a 2  q 2 … –a k  q k =q’ – pāreja ar vārdu x no stāvokļa q uz stāvokli q’.

Definīcija.

Automāts A akceptē vārdu x  I* , ja  q  S,  q’  F: q -x  q’.

Definīcija.

Automāta A valoda L(A) = {x  I* | A akceptē x}.

Determinēti automāti

Galīgs automāts: A =  Q, I,  , S, F  , kur   Q  I  Q, S  Q, F  Q .

Definīcija.

Automāts A ir determinēts, ja (1)  ! q  S (automātam ir tieši viens sākuma stāvoklis) un (2)  q  Q,  a  I: q –a  q’  q –a  q’’  q’ = q’’ (ne vairāk kā 1 pārejas iespēja no katra stāvokļa ar katru ieejas alfabēta simbolu). Automāts ir “nedeterminēts”, ja tam neizpildās kāda no prasībām (1) vai (2).

Kādreiz lieto vārdus “nedeterminēts automāts”, lai uzsvērtu, ka nav zināms tas, ka automāts ir determinēts (bet tas nav arī izslēgts, ka automāts var izrādīties determinēts). Varam rakstīt Det  Aut , kur Det – determinēto automātu kopa, bet Aut – visu (vispār sakot, iespējams, ka nedeterminētu) automātu kopa.

Definīcija.

Automāts A ir pilns, ja  q  Q,  a  I eksistē tāds q’, kam q –a  q’ .

Piezīme.

Atsevišķos avotos par determinētiem var tikt saukti automāti, kas ir vienlaikus gan determinēti (šeit dotās definīcijas nozīmē), gan pilni.

Galīgi automāti, turpināts

Galīgs automāts A =  Q, I,  , S, F  , kur   Q  I  Q, S  Q, F  Q .

Automāts definē diskrēto procesu : katrā brīdī automāts atrodas noteiktā stāvoklī. Ienākošie simboli maina automāta stāvokli. Katrs no stāvokļiem parāda, kādas ir tālākās iespējamās automāta darbības (sk. kafijas automāts).

Katram automātam tā darbības laikā iespējams galīgs “iekšējo situāciju” skaits .

Iekšējā situācija – raksturo, kas ar automātu noticis pagātnē, un kas ar to var notikt nākotnē. Galīgam automātam: galīga, ierobežota atmiņa par to, kas ir noticis pagātnē.

C++, PASCAL programma: vadības informācija + dati, mainīgo vērtības, var izdarīt vairāk, nekā ar galīgo automātu.

Galīgi automāti: piemēri

Galīgs automāts A =  Q, I,  , S, F  , kur   Q  I  Q, S  Q, F  Q .

1) I = {a,b}, L = { x  I* | #(b,x) ir nepāra skaitlis } (#(b,x) – burta b ieiešanas reižu skaits vārdā x ).

b a a b Katrs no stāvokļiem raksturo saņemto b burtu skaitu – pāra skaits, vai nepāra skaits. Automāts nevar atšķirt, vai saņemti 5 vai 9 b burti.

2) I = {a,b,c}, L = { x  I* |  y,z  I*, x = y a b b z } (akceptē tos un tikai tos vārdus, kas satur fragmentu abb ).

a a b,c c c b a a,b,c b Katrs no stāvokļiem raksturo to sākuma fragmentu no vārda “abb”, kas jau ir nolasīts. Šis sākuma fragments raksturo, kādas darbības ar ieejas simboliem veicamas turpmāk.

Galīgie automāti: iespējas

Galīgs automāts var atpazīt valodas: L = { x1, x2, …, xn } – jebkura galīga valoda.

I = {a,b}, L = { x  I* | #(b,x) ir nepāra skaitlis } . Var būt arī burta ieiešanas reižu skaita dalīšanās ar citu skaitli, noteikts minimāli nepieciešamais burtu skaits, u.taml.

I = {a,b,c}, L = { x  I* |  y,z  I*, x = y a b b z } (akceptē tos un tikai tos vārdus, kas satur fragmentu abb). Var būt jebkurš cits fragments. Var būt gan apakšvārds, gan apakšvirkne, u.c. Piemērus var turpināt.

Valodas, ko galīgs automāts var atpazīt – t.s. regulārās valodas (sk. automātu teorija).

Teorēma.

Ja valodām L1 un L2 eksistē galīgi automāti, kas tās atpazīst, tad galīgi atpazīstoši automāti eksistē arī valodām: - L1  L2, L1  L2, I* \ L1, - L1 L2 = { x y | x  L1, y  L1* = { x1 x2 … xn | n  0 L2 }   i  n xi  L1 } Teorēmu var pielietot arī vairākkārtīgi, lai no vienkāršākām valodām uzkonstruētu sarežģītākas valodas (pierādījumā pieejamas konstrukcijas, kas pēc vienkāršākas valodas atpazīstošajiem automātiem uzkonstruē automātus sarežģītākām valodām).

Regulārās valodas (definīcija)

Regulāras izteiksmes alfabētā I, kopa R(I): Ja a  I, r 0 ,r 1  R(I), tad kopa R(I) sastāv no šādiem elementiem r: r ::=  |  | a | (r 0 )|(r 1 ) | (r 0 )(r 1 ) | (r 0 )* | (r 0 ) Katrai regulārai izteiksmei r atbilst valoda L(r)  I*.

L(  ) =  L(  ) =  L(a) = { a } L(X|Y) = L(X)  L(Y) L(XY) = L(X) L(Y) = { xy | x  L(X)  y  L(Y) } L(X*) =  i  N L(X i ), kur L(X 0 ) =  un L(X i+1 ) = L(XX i ) L((X)) = L(X)

Galīgie automāti: ierobežojumi

Valodas, ko neviens galīgs automāts nevar atpazīt (piemēri): L = { a n b n I n  N }, vārdi, kas sastāv no noteikta skaita a burtiem, kam seko tikpat daudz b burti.

Automātam, kas šādu valodu atpazītu, būtu jāakceptē katru no tajā ietvertajiem vārdiem, un tas nedrīkstētu akceptēt nevienu citu vārdu. Var pierādīt, ka šāds galīgs automāts nav iespējams (“pa ceļam” jāatceras potenciāli neierobežots informācijas daudzums – cik tad a burtu līdz šim bija?).

Pieņemsim, ka ir kaut kāds automāts A, kas atpazīst valodu L. Automātam A ir noteikts skaits stāvokļu – n.

Apskatām ceļu (vienu no ceļiem), kādu automāts A iziet no sākuma stāvokļa līdz akceptējošam stāvoklim ar vārdu a n b n , šajā ceļā stāvokli pēc fragmenta a i apstrādes apzīmējam ar s i . Aplūkojam stāvokļus s 0 , s 1 , s n . Tā kā šo stāvokļu ir n+1, bet automātā ir tikai n dažādi stāvokļi, tad s i = s j , kaut kādiem i, j, kam i < j. Redzam, ka automāts akceptē arī vārdu a n-j+i b n , ko tam nevajadzētu akceptēt. Pretruna.

a a i a s i = s j a a a a n-j b n a

Galīgie automāti: ierobežojumi (2)

Valoda, ko neviens galīgs automāts nevar atpazīt: L = { x  I* | x ir simetrisks } (ja I sastāv no vismaz 2 simboliem).

Pierādījums: analoģisks valodas { a n b n I n  N } gadījumam.

Pieņemam pretējo, ka eksistē kāds automāts A, kas var atpazīt valodu L, šim automātam ir noteikts stāvokļu skaits, n.

Aplūkojam vārdu a n b a n , tas ir simetrisks, tādēļ A šo vārdu atpazīst, eksistē ceļš automātā no sākuma stāvokļa uz beigu stāvokli, gar kuru var tikt nolasīts šis vārds. Fiksējam vienu no šādiem ceļiem, šajā ceļā stāvokli pēc fragmenta a i apstrādes apzīmējam ar s i . Analoģiski kā iepriekšējā gadījumā pierādām, ka šis automāts akceptēs arī vārdu a n-j+i b a n , kur i < j  n, kurš nav simetrisks.

Pretruna.

Nedeterminēti automāti: valodas

Teorēma.

Katram nedeterminētam automātam A eksistē atbilstošs determinēts automāts A’, kuram L(A’) = L(A).

Automāts A’ akceptē tos un tikai tos vārdus, kurus akceptē automāts A . Ja automātam A ir n stāvokļi, tad automātam A’ stāvokļu skaits nepārsniegs 2 n .

Konstrukcijas ideja (no A iegūt A’ ): Ja A =  Q, I,  , S, F  , tad A’ =  2 Q , I,  ’, {S}, F’  , kur jaunās stāvokļu kopas 2 Q elementi ir visas kopas Q apakškopas ; Q1 -a  ’ Q2, ja Q2 = { q |  q’  Q1: q’ -a  q }; Q1  F’, ja  q  Q1: q  F.

Daudzos gadījumos konstrukcijas var būt vienkāršākas (mazāk stāvokļus prasošas).

Novērojums: dažādas abstrakto mašīnu klases ( Det un Aut ), tomēr viena un tā pati izteiksmes spēja (spēja akceptēt vienas un tās pašas valodas).

Piemērs: uzkonstruēt atbilstošu determinētu automātu.

a,b a a,b a,b a,b … a,b

Nedeterminēti automāti: diskrētas iekārtas

Ja mēģinām nedeterminētu automātu “izpildīt”, ar kādu diskrēto procesu sastopamies?

Kas notiek tad, ja vienā brīdī dažādas iespējas izpildīt pāreju , kas atbilst saņemtajam ieejas simbolam a?

Klasiskā pieeja (kā iepriekšējā slaidā): automāts atceras visas iespējas , kādas bija izdarīt šo pāreju ( atceras visus stāvokļus , līdz kuram ar līdz šim saņemto vārdu bija iespējams aiziet) un procesa (ieejas vārda) beigās apskatās, vai starp visām iespējām bija kāda, kas ir “laba” (noved līdz akceptējošam stāvoklim).

Reālā laika pieeja: automāta iekšienē notiek nedeterminēta “izvēle” katra simbola saņemšanas brīdī .

Vai šādi 2 automāti ir ekvivalenti (uzskatām, ka visi automātu stāvokļi ir akceptējoši)?

Abi automāti akceptē vienu un to pašu valodu: a* ( {a n | n  N } ).

a a a Reālā laika izpratne: labās puses automātā iespējams strupceļš – stāvoklis, no kura nav iespējama neviena tālāka pāreja.

Reālā laika sistēmām tas ir slikti.

Divas pieejas automātu nedeterminitātei

A. Valodu pieeja – automāts akceptē vārdu, ja eksistē ceļš cauri tam, pa kuru var šo vārdu nolasīt.

Automāti ir ekvivalenti, ja tiem valodas sakrīt.

B. Reālā laika pieeja: automāts katrā savas izpildes reizē izpilda vienu no nedeterminētas izvēles scenārijiem.

Lai pierādītu kādu automāta īpašību, to jāpierāda visiem automāta ceļiem.

A – sintakses analīzē izmantotā pieeja.

B – semantiskajā modelēšanā tipiski izmantotais variants (izmanto arī valodu pieeju) Tālākajā galīgo automātu analīzē – skatīsimies valodu pieeju (A).

Labā ziņa – determinētiem automātiem dažādi semantiskie modeļi ir savā starpā līdzvērtīgi.

Nedeterminēti modeļi paralēlām sistēmām – mazliet vēlāk šajā kursā.

Tēma: galīgu automātu analīze

Abstraktās mašīnas un automāti

Galīgu automātu analīze

Ja dots galīga automāta apraksts (automāta diagramma, automāta pāreju uzskaitījums teksta formā, vai kā citādi), vai mēs varam kaut ko pateikt par to diskrēto procesu, ko šis automāts realizē? Par valodu, ko šis automāts apraksta?

Automātu analīzes problēmas (piemēri): Pēc dota automāta A noskaidrot, vai L(A) =  ?

Pēc dota automāta A un dota a  vismaz viens (vai tieši viens) a I noskaidrot, vai L(A) burts?

satur kādu vārdu x , kurā ir Pēc dota automāta A un dota q  Q noskaidrot, vai automātā eksistē ceļš no kāda sākuma stāvokļa līdz stāvoklim q ?

Pēc 2 dotiem automātiem A un B noskaidrot, vai L(A) = L(B) ?

Fakts.

Visas šeit minētās (un daudzas citas radniecīgas) galīgo automātu analīzes problēmas ir algoritmiski atrisināmas (katrai no šīm problēmām eksistē algoritms, kas to risina).

Motivācija: automātam ir galīgs skaits stāvokļu, visus tos ir iespējams “pārlasīt”.

Jautājums : vai mēs negribētu algoritmus līdzīgu problēmu risināšanai attiecībā uz C++ vai PASCAL programmām, kuras mēs rakstām?

Galīgu automātu analīze: definīcijas

Aplūkojam X  Q. Definējam: Step(X,a) = { q  Q |  q’  X: q’ -a  q } no X ar a vienā solī sasniedzamo stāvokļu kopa Step(X) = { q  Q |  q’  X:  b  I: q’ -b  q } no X vienā solī sasniedzamo stāvokļu kopa Reach(X,i) – no X ar ne vairāk kā i soļiem sasniedzamo stāvokļu kopa Reach(X,0) = X Reach(X,i+1) = Reach(X,i)  Step(Reach(X,i)) Ieviešam Next(X) = X  Step(X), tad Reach(X,i+1) = Next(Reach(X,i)) Next: 2 Q  2 Q (2 Q stāvokļu kopas Q apakškopu kopa) Teorēma.

Funkcija Next ir monotona, t.i. ja A  B, tad Next(A)  Next(B) Reach(X) =  { Reach(X,s) | s  N } visu no X sasniedzamo stāvokļu kopa.

Galīgu automātu analīze: piemērs

Pēc dota automāta A =  Q, I,  , S, F  noskaidrot, vai L(A)   vienu vārdu)?

(t.i., vai L(A) satur vismaz Būvējam kopas R i = Reach(S,i) – ne vairāk, kā i soļos no S sasniedzamo stāvokļu kopa.

R 0 = S - Visi sākuma stāvokļi, sasniedzami 0 soļos no R i+1 = R i  Step(R i ) = Next(R i ) - ne vairāk, kā i+1 soļos sasniedzamie stāvokļi Beidzam, kad R i+1 = R i . Apskatāmies, vai R i  F   .

S .

Kāpēc šāds brīdis būs?

Tāpēc, ka R 0  R 1  R 2  …  Q – galīga kopa. Kāpēc programma izdos pareizu atbildi?

Tā kā R i = R i+1 tad Next(R i ) = Next(R i+1 ), t.i. R i+1 = R i+2 , tātad, pēc indukcijas  k: R i = R i+k tātad R i =  { R s | s  . Secinām N } = Reach(S)  s  N: R s  R i – visu sasniedzamo stāvokļu kopa.

Tātad, L(A)   tad un tikai tad, ja R i  F   .

Programmas pseidokods: Kopai X  Q rakstām X(q) = 1 , ja q  X, citādi X(q) = 0.

Mainīgie (masīvi): R(q), q  Q – kārtējā kopa R i+1 , T(q), q  Q – “iepriekšējā” kopa R i

Galīgu automātu analīze: piemērs, programma

Pēc dota automāta A =  Q, I,  , S, F  kādu vārdu x ?

un dota a  I noskaidrot, vai L(A) satur Programmas pseidokods: Kopai X  Q rakstām X(q) = 1 , ja q  X , citādi X(q) = 0.

Mainīgie (masīvi): R(q), q  Q – kārtējā kopa R i+1 , T(q), q  Q – “iepriekšējā” kopa R i  q T(q) := 0;  q R(q) := S(q); /* sākuma inicializācija R 1 := S */ while  q: ( R(q)  T(q)) do  q T(q) := R(q); /* Nokopējam kārtējās vērtības uz “iepriekšējām” */ for all q  Q, T(q) = 1 if  b  I: q -b  q’ then R(q’) = 1; end for /* Ciklā veidojam jaunas “kārtējās” vērtības */ end while if  q: R(q) = 1  F(q) = 1 then print ‘Yes!’ else print ‘No ..’

Galīgu automātu analīze: piemērs (2)

Pēc dota automāta A =  Q, I,  , S, F  vārdu x , kurā ir vismaz viens a un dota burts?

a  I noskaidrot, vai L(A) satur kādu Kopas R i – ne vairāk, kā soļos no S i soļos no S sasniedzamo stāvokļu kopa, Ra i – ne vairāk, kā sasniedzamo stāvokļu kopa ar vārdu, kas satur vismaz vienu a simbolu.

i R 0 R i+1 = S, Ra 0 = R i  = { q   Q |  q’  R i  b  I: q’ -b  q } Ra i+1 = Ra i  Beidzam, kad { q R  i+1 Q | = R i  q’  R i un Ra i+1 : q’ -a = Ra i  q }  { q  Q |  q’ . Apskatāmies, vai  Ra i Ra i  :  b  I: q’ -b  q } F   .

Kāpēc šāds brīdis būs?

Tāpēc, ka R 0  R 1  R 2  …  Q un Ra Kāpēc programma izdos pareizu atbildi?

0  Ra 1  Ra 2  …  Q , Q – galīga kopa Definējam R =  {R s | s  N } , Ra =  {Ra s | s  N } Ra – to stāvokļu kopa, kas sasniedzami ar vārdu, kurš satur a .

Tā kā Tātad R i Ra = R i  i+1 , tad R F    i+1 = R i+2 un pēc indukcijas  k: R i = R i+k , tātad R i = R .

Tā kā R i = R i+1  Ra i = Ra i+1  k: R i = R i+k  Ra i = Ra i+k , tad R i+1 = R i+2  , tātad R i = R  Ra i+1 = Ra Ra i = Ra . i+2 un pēc indukcijas Ra  F   un algoritms izdos pareizu atbildi.

Galīgu automātu analīze: piemērs, programma (2)

Pēc dota automāta A =  Q, I,  , S, F  un dota a  vārdu x , kurā ir vismaz viens a burts?

I noskaidrot, vai L(A) satur kādu Programmas pseidokods: Kopai X  Q rakstām X(q) = 1 , ja q  X , citādi X(q) = 0.

Mainīgie (masīvi): R(q), q  Q Ra(q), q  Q – kārtējā kopa R i+1 , T(q), q  Q – “iepriekšējā” kopa R i – kārtējā kopa Ra i+1 , Ta(q), q  Q – “iepriekšējā” kopa Ra i .

 q T(q) := 0;  q R(q) := S(q); /* sākuma inicializācija R 1 := S */  q Ta(q) := 0;  q Ra(q) := 0; while  q: ( R(q)  T(q)  Ra(q)  Ta(q) ) do  q T(q) := R(q);  q Ta(q) := Ra(q); for all q  T(q) if  b  I: q -b  q’ then R(q’) = 1; if q -a  q’ then Ra(q’) = 1; end for for all q  Ta(q) if  b  I: q -b  q’ then Ra(q’) = 1; end for end while if  q: Ra(q) = 1  F(q) = 1 then print ‘Yes!’ else print ‘No ..’

Galīgu automātu ekvivalence

Definīcija . Galīgus automātus A un B sauksim par ekvivalentiem (klasiskajā nozīmē), ja L(A) = L(B).

Teorēma . Eksistē algoritms, kas pēc 2 dotiem galīgiem automātiem nosaka, vai tie ir ekvivalenti.

Pierādījums . Doti 2 automāti A =  Q 1 , I,  1 , S 1 , F 1  un B =  Q 2 , I,  2 , S 2 , F 2  .

Pieņemsim, ka A un B ir pilni, t.i. katrā no šiem automātiem no katra stāvokļa eksistē pāreja ar katru ieejas simbolu.

(Ja kāds no A vai B nebūtu pilns, tad to varētu pārveidot par ekvivalentu pilnu automātu, pievienojot papildus neakceptējošu stāvokli, uz kuru novirzīt visas pārejas, kas sākotnējā automātā nav definētas). Izveidojam automātu A  B =  Q 1  Q 2 , I,  , S 1  S 2 , F 1  (Q 2 \ F 2 )  (Q 1 \ F 1 )  F 2  , kur pāreju attiecība   s,t  -a   s’,t’  definēta kā tad un tikai tad, ja  s  -a  1  s’  un  t  -a  2  t’  .

A un B ir ekvivalenti tad un tikai tad, ja L(A  B) =  .