Formalne metode

u softverskom inženjerstvu

04 Minimizacija automata

ETFBL
Dunja Vrbaški
21-22/L

Teorija automata i formalnih jezika

Konačni automat

A = (S, Σ, 𝜎, s0, F)

- S - skup stanja
- Σ - alfabet
- 𝜎 - funkcija prelaza, 𝜎: S x Σ → S
- s0 - inicijalno stanje
- F - skup ciljnih stanja

A = (S, Σ, 𝜎, s0, F)

- S = {q0, q1, q2}

- Σ = {0, 1}
- s0 = q 0 1 0

- F = {q1} → q0 q0 q2

- 𝜎: q2 q1 q2

𝜎(q0, 1) = q0 𝜎(q0, 0) = q2 * q1 q1 q1

𝜎(q2, 1) = q1 𝜎(q2, 0) = q2
𝜎(q1, 1) = q1 𝜎(q1, 0) = q1
Proširena funkcija prelaza 𝜎*

𝜎: S x Σ → S
𝜎*: S x Σ* → S

𝜎*(s, ε) = s
𝜎*(s, wa) = 𝜎(𝜎*(s, w), a)

Automat A = (S, Σ, 𝜎, s0, F) prihvata ulaznu reč w ∊ Σ* ako 𝜎*(q0, w) ∊ F.

Jezik L(A) = {w ∊ Σ* | 𝜎*(q0, w) ∊ F}

Konačni automati prihvataju regularne jezike

Automat je deterministički

Jednoznačno je određena promena stanja za svaki ulazni simbol

Funkcija prelaza - program

Da li možemo da kombinujemo programe, odnosno automate?

Da li možda za neki automat postoji ekvivalentan, ali jednostavniji?
 ?

Automat je nedeterministički

Iz stanja q0 se na osnovu simbola 0 može preći i u stanje q0 i u stanje q1

Ne precizira se u koje stanje se prelazi!

𝜎 - kod DKA vraća jedno stanje

𝜎 - kod NKA vraća podskup stanja
Regularni jezici

Zatvorenost jezika nad operacijama: unija, presek, razlika

Zatvorenost: klasa jezika - operacija - ista klasa jezika

Zatvorenost za:
- konkatenaciju
- *
- komplement
- obrnutost {0, 01, 100} i {0, 10, 001}
- homomorfizam
- inverzni homomorfizam
- …
?
Minimizacija automata

Da li za zadati automat postoji ekvivalentan, ali jednostavniji?

Šta znači ekvivalentan?

Šta znači jednostavniji?

Minimizacija automata

Da li za zadati automat postoji ekvivalentan, ali jednostavniji?

Šta znači ekvivalentan? L(A1) = L(A2)

Šta znači jednostavniji? manje stanja
Za svaki regularan jezik postoji jedinstven minimalni deterministički konačni automat.

Otkriti sva “suvišna” stanja:

- nedostižna
- ekvivalentna

Nedostižno stanje

Stanje p je nedostižno ako ne postoji riječ w ∊ Σ* za koju važi p = δ*(q0,w),

Automat je dostižan ako su sva njegova stanja dostižna.

Ako krećemo iz inicijalnog stanja ono je dostižno i dalje prelazimo samo u dostižna stanja

Nedostižna stanja nikako ne utiču na rad automata i možemo ih izbaciti

Ekvivalentna stanja

Stanja koja “se svode na isto”.

Relacija ekvivalencije

Binarna relacija R na skupu S je skup uređenih parova elemenata iz S.

(a, b) ∊ R
aRb

Relacija “manje od”, “<”: {(a,b) | a je manje od b }

Relacija R je relacija ekvivalencije ako je:

- refleksivna: aRa
- simetrična: aRb → bRa
- tranzitivna: aRb, bRc → aRc

= relacija ekvivalencije
< relacija poretka (nije ekvivalencije, asimetrična je)

Relacija ekvivalencije deli skup na disjunktne podskupove koje zovemo klase

ekvivalencije:
aRb akko su a i b u istoj klasi ekvivalencije.

Unija svih klasa ekvivalencije je sam skup S.

 S=Z
=
a i b imaju istu apsolutnu vrednost
isti ostatak pri deljenju
a+b je parno

S = studenti
a i b imaju isti rođendan
a i b su istog uzrasata
a i b idu na isti fakultet?

Relacija ne mora imati “pravilo”

Relacija je jedan najobičniji skup uređenih parova.

{ (1, 2), (3, 7), (3, 3) }

Testiranje softvera

Podeliti sve ulaze, test podatke, relacijom ekvivalencije na klase

Testirati samo za predstavnike klasa

safe_add(x, y)
Formalni mehanizam za podelu skupa

Umesto celog skupa - može se posmatrati predstavnik jedne homogene grupe, jedne
grupe gde elementi imaju neko zajedničko svojstvo

faktor skup

bookofproofs.org

Od klasa ekvivalencije dobijamo faktor skup čiji su elementi predstavnici

Važno je da taj faktor skup S/R sačuva svojstva polaznog skupa S

R - osim što je relacija ekvivalencije treba i da bude saglasna sa operacijama nad S

Nekako treba da na prirodan način da prenese operacije iz S

Algebra: skupovi; pojmovi: kongruencija, homomorfizam

Ideja za minimizaciju automata:

Da li postoje stanja koja se “svode na isto”?

Da li postoji relacija ekvivalencije koja deli stanja automata na klase ekvivalencije?

Umesto cele klase mogli bismo uzeti jednog predstavnika - faktor automat.

Relacija ekvivalencije bi trebala nekako i prirodno da preslika i operacije iz polaznog automata.

Šta nam je važno? Da bude isti jezik.
Nova funkcija prelaza (operacija) bi trebalo to da očuva.

Smanjili bismo broj stanja.

Razlikovanje reči

Tvrđenje
Definišemo relaciju IL za jezik L⊆ Σ*:

(x, y) ∈ IL akko se x i y ne razlikuju u odnosu na L.

IL je relacija ekvivalencije
Definišemo relaciju IL za jezik L⊆ Σ*:

(x, y) ∈ IL akko se x i y ne razlikuju u odnosu na L.

IL je relacija ekvivalencije

SL je faktor skup, skup klasa ekvivalencije

Automat AL koji odgovara automatu A je

AL = (SL, Σ, 𝜎, s0, F)

SL - stanja koja odgovaraju klasama ekvivalencije; oznaka za elemente: [x]

Σ - isto kao kod A

𝜎*([x], a) = [xa]

s0 = [ε]

F = { [x] ∈ SL| x ∈ L }

AL
- prihvata jezik L
- minimalni broj stanja
- broj stanja je jednak broju klasa ekvivalencije
𝜎*([x], a) = [xa]

Ako je [x] = [y]

𝜎*([x], a) = [xa]
𝜎*([y], a) = [ya]
→
[xa] = [ya]

Sve reči iz klase prelaze u isto stanje.

Očuvana su svojstva.

Koja stanja su ekvivalentna u A?

Ako sa Sp označimo skup reči takvih da 𝜎*(p, a) ∈ F

Stanja p i q su ekvivalentna (p ≡ q) ako se ne mogu razlikovati reči iz skupa Sp i Sq

(𝜎*(p, a) ∈ F i 𝜎*(q, a) ∈ F)

Dva stanja su ekvivalentna ako su Sp i Sq podskupovi iste klase ekvivalencije IL

 𝜎*(p, a) ∈ F i 𝜎*(q, a) ∈ F

ε - nam daje razlikovanje između završnih i nezavršnih stanja

p≡q
ili su oba finalna ili nisu oba nisu finalna

𝜎*(p, a) ∈ F i 𝜎*(q, a) ∈ F

ε - nam daje razlikovanje između završnih i

nezavršnih stanja

p≡q
ili su oba finalna ili nisu oba nisu finalna

C i G nisu ekvivalentna stanja

ε ih razlikuje

𝜎*(C, ε) ∈ F i 𝜎*(G, ε) ∉ F
 𝜎*(p, a) ∈ F i 𝜎*(q, a) ∈ F

A i G nisu ekvivalentna stanja

ε, 0 i 1 ih ne razlikuju
01 ih razlikuje

𝜎*(A, 01) = C ∈ F
𝜎*(G, 01) = E ∉ F

𝜎*(p, a) ∈ F i 𝜎*(q, a) ∈ F

A i E su ekvivalentna stanja

𝜎*(A, 1) = F 𝜎*(A, 0) = B
𝜎*(E, 1) = F 𝜎*(E, 0) = H
→
𝜎*(A, 1x) = 𝜎*(E, 1x) 𝜎*(B, 0) = G 𝜎*(B, 1) = C
𝜎*(H, 0) = G 𝜎*(H, 1) = C

→
𝜎*(A, 0x) = 𝜎*(E, 0x)
 𝜎*(p, a) ∈ F i 𝜎*(q, a) ∈ F

A i E su ekvivalentna stanja

𝜎*(A, 1) = F 𝜎*(A, 0) = B
𝜎*(E, 1) = F 𝜎*(E, 0) = H
→
𝜎*(A, 1x) = 𝜎*(E, 1x) 𝜎*(B, 0) = G 𝜎*(B, 1) = C
𝜎*(H, 0) = G 𝜎*(H, 1) = C

→
𝜎*(A, 0x) = 𝜎*(E, 0x)

Definišemo skup SM kao skup parova različitih stanja (p, q) p ≢ q

Postupak:
- početak: poskup sadrži parove u kojima je jedno stanje završno
- iterativno: ako postoji a ∈ Σ za koje (𝜎(p, a), 𝜎(q, a)) ∈ SM onda i (p, q) ∈ SM

Posmatraju se svi parovi koji nisu u skupu SM

Ako postoji bar jedan ulazni simbol za koji je rezultujući par stanja već u skupu SM
onda se i taj par dodaje u skup SM

Završavamo kad više nema promena, nema više proširenja

Da li će ostati neki parovi?

Implikaciona tabela

Dodajemo parove kod kojih je

jedno stanje završno
ako postoji a ∈ Σ za koje
(𝜎(p, a), 𝜎(q, a)) ∈ SM onda i (p, q) ∈ SM
* u tabeli je SM označen sa P
ako postoji a ∈ Σ za koje
(𝜎(p, a), 𝜎(q, a)) ∈ SM onda i (p, q) ∈ SM
* u tabeli je SM označen sa P

ako postoji a ∈ Σ za koje

(𝜎(p, a), 𝜎(q, a)) ∈ SM onda i (p, q) ∈ SM
* u tabeli je SM označen sa P

Nema dalje!

Ostali su neraspoređeni parovi

{(q1 ,q2 ),(q1 ,q3 ),(q2 ,q3 )}
grupisaće se u jedno stanje
(pripadaju istoj klasi ekvivalencije)
Zašto?

q0, q4, q5
nisu ekvivalentna
(pripadaju različitim klasama
ekvivalencije)
Izbaciti nedostižna stanja
Sažeti ekvivalentna stanja
Upotpunjavanje automata

Automat je potpun ako u svakom stanju, za svaki simbol postoji najmanje jedno stanje u koje se
može preći.

Potpuni deterministički automat

Automat u kom za svako stanje i svaki simbol postoji tačno jedno stanje u koje se prelazi.

Kako upotpuniti automat i zašto bismo to radili?

Kako bismo mi implementirali prepoznavanje da li zadata reč pripada jeziku definisanim ovim
automatom?

ili

Kako bismo implementirali proces opisan ovim automatom?

uz pp da ne znamo ništa o automatima, pp da nam je neko samo dao ovakvu šemu

 if a
next
while a and not eof
next
if b
next
if EOF
OK
else
ERROR
else
ERROR
else
ERROR

if a
next
while a and not eof
next
if b
next
if EOF
OK
else
ERROR
else
ERROR
else
ERROR

if ERROR
while not eof
next

dead states - često izostavljena