Dibutuhkan oleh mesin keadaan non-deterministik M = (Q, T, D, q 0 , F) membangun mesin keadaan terbatas deterministik M = (Q", T, D", q" 0 , F"). Keadaan awal untuk otomat yang sedang dibangun adalah -penutupan keadaan awal otomat awal. -penutupan - satu set negara bagian yang dapat dicapai dari yang diberikan dengan transisi sepanjang . Selanjutnya, sementara ada keadaan yang transisinya belum dibangun (transisi dibuat dengan simbol, transisi yang melaluinya ada dalam otomaton asli), untuk setiap simbol, -penutupan himpunan keadaan yang dapat dicapai dari keadaan yang dipertimbangkan dengan transisi melalui simbol yang dipertimbangkan dihitung. Jika keadaan yang sesuai dengan himpunan yang ditemukan sudah ada, maka transisi ditambahkan di sana. Jika tidak, status penerimaan baru ditambahkan.

Contoh

inisialisasi

Status yang sesuai dengan -penutupan status awal ditandai. Negara-negara ini akan sesuai dengan negara A DKA masa depan.

Iterasi pertama

Ada transisi dari penutupan ke status NCA 3 dan 10 (menurut sebuah dan c, masing-masing). Untuk keadaan 3, -penutupan adalah himpunan keadaan (3, 4, 6), untuk keadaan 10 - (10). Mari kita tentukan status DFA baru yang sesuai dengan set ini sebagai B dan C.

negara bagian DKA	Set status NFA
		sebuah	b	c
A	{1, 2, 9}	B	-	C
B	{3, 4, 6}	-	-	-
C	{10}	-	-	-

Iterasi kedua

Dari himpunan status NFA (3, 4, 6) yang sesuai dengan status DFA B ada dua transisi - untuk menyatakan 5 (oleh b) dan 7 (oleh c). Penutupan mereka berpotongan, tetapi himpunan itu sendiri berbeda, sehingga mereka diberi dua status DFA baru - D dan E. Dari status NFA yang sesuai dengan status DFA C, tidak ada transisi.

negara bagian DKA	Set status NFA	Karakter yang dapat dilompati
		sebuah	b	c
A	{1, 2, 9}	B	-	C
B	{3, 4, 6}	-	D	E
C	{10}	-	-	-
D	{2, 5, 8, 9}	-	-	-
E	{2, 7, 8, 9}	-	-	-

Iterasi ketiga

Dari set status NFA yang sesuai dengan status DFA D dan E transisi dibuat ke himpunan keadaan yang sesuai dengan keadaan yang ada (dari himpunan (2, 5, 8, 9) yang sesuai dengan keadaan D, pada sebuah transisi ke keadaan 3 milik himpunan (3, 4, 6) sesuai dengan keadaan DFA B, pada c- transisi ke keadaan 10 sesuai dengan keadaan C; sama untuk set yang sesuai dengan status DFA E). Proses pembuatan tabel status dan transisi DFA telah selesai.

negara bagian DKA	Set status NFA	Karakter yang dapat dilompati
		sebuah	b	c
A	{1, 2, 9}	B	-	C
B	{3, 4, 6}	-	D	E
C	{10}	-	-	-
D	{2, 5, 8, 9}	B	-	C
E	{2, 7, 8, 9}	B	-	C

Hasil:

Membangun tata bahasa linier kanan dari robot yang terbatas

Setiap state diasosiasikan dengan non-terminal. Jika ada transisi keadaan X menjadi negara kamu pada sebuah, tambahkan aturan X → ay. Untuk status akhir, tambahkan aturan X→ e. Untuk -transisi - X → kamu.

Contoh 1 (mesin keadaan deterministik)

• A → sebuah b | c C
• B → b D | c E
• C → e
• D → sebuah b | c C
• E → sebuah b | c C

Contoh 2 (mesin keadaan non-deterministik)

• 1 → 2 | 9
• 2 → sebuah 3
• 3 → 4 | 6
• 4 → b 5
• 5 → 8
• 6 → c 7
• 7 → 8
• 8 → 2 | 9
• 9 → c 10
• 10 →

Pembangunan DFA oleh RV

Mari kita memiliki ekspresi reguler r. Berdasarkan ekspresi reguler ini, perlu untuk membangun otomat hingga deterministik D seperti yang L(D) = L(r).

Modifikasi ekspresi reguler

Mari tambahkan simbol untuk itu, yang berarti akhir dari RV - "#". Hasilnya, kami mendapatkan ekspresi reguler ( r)#.

Membangun pohon

Mari kita bayangkan ekspresi reguler sebagai pohon, yang daunnya adalah karakter terminal, dan simpul internal adalah operasi penggabungan ".", union "∪" dan iterasi "*". Kami menetapkan nomor unik untuk setiap daun pohon (kecuali untuk daun ) dan menyebutnya, di satu sisi, sebagai posisi di pohon dan, di sisi lain, sebagai posisi simbol yang sesuai dengan daun.

Perhitungan fungsi nullable, firstpos, lastpos

Sekarang, melintasi pohon T dari bawah ke atas dari kiri ke kanan, kami menghitung tiga fungsi: tidak dapat dibatalkan, pos pertama, dan pos terakhir. Fungsi tidak dapat dibatalkan, pos pertama dan pos terakhir didefinisikan pada node pohon. Nilai semua fungsi kecuali tidak dapat dibatalkan, adalah himpunan posisi. Fungsi pos pertama(n) untuk setiap simpul n dari pohon sintaksis regex memberikan himpunan posisi yang cocok dengan karakter pertama dalam substring yang dihasilkan oleh subekspresi yang diakhiri dengan n. Juga, pos terakhir(n) memberikan set posisi yang sesuai dengan karakter terakhir dalam substring yang dihasilkan oleh subekspresi dengan top n. Untuk node n, yang subpohonnya (yaitu, pohon yang simpulnya n adalah root) dapat menghasilkan kata kosong, kami mendefinisikan tidak dapat dibatalkan(n) = BENAR, dan untuk node lainnya Salah. Tabel untuk menghitung tidak dapat dibatalkan, pos pertama, pos terakhir:

simpul n	tidak dapat dibatalkan(n)	pos pertama(n)	pos terakhir(n)
ε	BENAR	∅	∅
saya ≠ ε	Salah	{saya}	{saya}
kamu v	tidak dapat dibatalkan(kamu) atau tidak dapat dibatalkan(v)	pos pertama(kamu) ∪ pos pertama(v)	pos terakhir(kamu) ∪ pos terakhir(v)
kamu v	tidak dapat dibatalkan(kamu) dan tidak dapat dibatalkan(v)	jika tidak dapat dibatalkan(kamu) kemudian pos pertama(kamu) ∪ pos pertama(v) lain pos pertama(kamu)	jika tidak dapat dibatalkan(v) kemudian pos terakhir(kamu) ∪ pos terakhir(v) lain pos terakhir(v)
v*	BENAR	pos pertama(v)	pos terakhir(v)

Membangun tindak lanjut

Fungsi mengikuti dihitung melalui tidak dapat dibatalkan, pos pertama dan pos terakhir. Fungsi mengikuti ditentukan pada beberapa posisi. Berarti mengikuti adalah sekumpulan posisi. Jika sebuah saya- posisi, maka mengikuti(saya) ada banyak posisi j sehingga ada beberapa string ... CD... termasuk dalam bahasa yang dijelaskan oleh RW, sehingga saya cocok dengan entri ini c, sebuah j- masuk d. Fungsi mengikuti juga dapat dihitung dalam satu lintasan pohon menurut dua aturan berikut:

1. Biarlah n- simpul internal dengan "." (rangkaian); sebuah, b- keturunannya. Kemudian untuk setiap posisi saya termasuk dalam pos terakhir(sebuah mengikuti(saya) sekelompok pos pertama(b).
2. Biarlah n- simpul internal dengan operasi "*" (iterasi), sebuah- keturunannya. Kemudian untuk setiap posisi saya termasuk dalam pos terakhir(sebuah), tambahkan ke himpunan nilai mengikuti(saya) sekelompok pos pertama(sebuah).

Contoh

Hitung nilai fungsi mengikuti untuk ekspresi reguler ( sebuah(b|c))*c.

Posisi	Berarti mengikuti
1: (sebuah (b|c))*c	{2, 3}
2: (sebuah(b |c))*c	{1, 4}
3: (sebuah(b|c ))*c	{1, 4}
4: (sebuah(b|c))*c	{5}

Membangun DFA

DFA adalah satu set negara bagian dan satu set transisi di antara mereka. Status DFA adalah sekumpulan posisi. Konstruksi DFA terdiri dari penambahan bertahap status yang diperlukan dan konstruksi transisi untuknya. Awalnya, ada satu negara pos pertama(akar) (akar- akar pohon), yang tidak memiliki transisi. Transisi dilakukan oleh karakter dari ekspresi reguler. Setiap karakter sesuai dengan satu set posisi ( p saya). Menyatukan semua mengikuti(x) adalah keadaan yang harus dituju, di mana x adalah posisi yang ada baik di antara posisi keadaan maupun di antara posisi simbol dari RE, tempat transisi dibuat. Jika tidak ada negara seperti itu, maka itu harus ditambahkan. Proses harus diulang sampai semua transisi untuk semua status dibangun. Semua status yang berisi posisi simbol # yang ditambahkan ke akhir RE dinyatakan final.

DFA diperoleh dari RV ( sebuah(b|c))*c

Contoh

Bangun DFA dengan ekspresi reguler ( sebuah(b|c))*c.

negara bagian DKA	Simbol
	a(1)	b(2)	c(3, 4)
A(1, 4)	B(2, 3)	-	C(5)
B(2, 3)	-	A(1, 4)	A(1, 4)
C(5)	-	-	-

Membangun DFA dengan jumlah minimum negara bagian

DFA dengan jumlah status minimum dibangun untuk DFA yang ditentukan di mana-mana, mis. seperti yang . Untuk DFA apa pun, ada DFA yang ditentukan di mana-mana yang setara dengannya.

Konstruksi DFA yang ditentukan di mana-mana

Perkenalkan status baru dan definisikan set status baru .

Mari kita definisikan fungsi transisi baru seperti ini:

Membangun partisi (secara formal)

Mari kita buat partisi awal P set negara menjadi dua kelompok: negara akhir F dan lain-lain S/F, yaitu P = {F, T\F}.

Terapkan ke setiap grup G ∈ P prosedur berikut. menghancurkan G menjadi subkelompok sehingga negara bagian s dan t dari G berakhir di grup yang sama jika dan hanya jika untuk setiap simbol input sebuah menyatakan s dan t memiliki transisi sebuah ke negara bagian dari grup yang sama di P.

Subgrup yang dihasilkan ditambahkan ke partisi baru P baru.

Menerima P = P baru dan ulangi konstruksi partisi hingga stabilisasi, yaitu, hingga partisi berhenti berubah.

Membangun partisi (algoritma)

Untuk membangun partisi, ada algoritma berikut. Kami membangun tabel transisi untuk otomat asli, membangun partisi awal.

Kami menetapkan pengenal untuk setiap grup dari partisi (untuk partisi awal, misalnya, 0 dan 1).

Setiap negara bagian (setiap baris tabel) diberi string dalam bentuk "a.bcd...xyz", di mana pengidentifikasi grup tempat negara bagian itu berasal [kolom pertama (dari mana kita pergi), yang kedua kolom (di mana kita pergi dengan karakter pertama), ..., kolom terakhir (di mana kita pergi dengan karakter terakhir)].

Kami membangun grup baru sesuai dengan kebetulan string, yaitu, sehingga status dengan string yang sama masuk ke dalam satu grup.

Kemudian, iterasi baru. Kami menetapkan pengidentifikasi baru ke grup yang dihasilkan, misalnya (0, 1, ..., n). Dan kami ulangi konstruksi partisi hingga stabilisasi.

Perhatikan bahwa ketika hanya ada satu status yang tersisa di grup, pada tahap selanjutnya dari pembuatan partisi, Anda tidak dapat lagi menulis string pengidentifikasi untuk status ini, karena string ini akan menjadi unik dalam hal apa pun karena karakter pertama dari tali. Dengan kata lain, saat membelah, tidak akan terjadi apa-apa pada grup dari satu negara bagian - grup tersebut dipindahkan ke pemisahan baru apa adanya.

Konstruksi otomat yang dikurangi

Setiap grup yang dihasilkan menjadi status DFA baru. Jika grup berisi status awal (akhir) dari otomat asli, grup ini menjadi status awal (masing-masing final) dari DFA baru. Transisi dibangun dengan cara yang jelas: transisi ke keadaan dari grup dianggap sebagai transisi ke grup.

Kami membawa mesin. Kami pertama-tama menghapus non-generating (steril, "mati"), kemudian status yang tidak dapat dijangkau (definisi diberikan untuk simbol, tetapi dengan cara yang jelas mereka ditransfer ke status otomat).

Secara umum, menghapus keadaan mati mengubah DFA menjadi NFA, karena dalam DFA semua transisi harus didefinisikan. Namun, dalam Buku Naga, penyimpangan seperti itu dari definisi formal masih dianggap dapat diterima.

Contoh

Untuk membuat DFA dengan jumlah minimum status untuk DFA dengan bentuk berikut:

• Pemisahan awal: (C) ( keadaan akhir), (A, B, D, E) ( semua negara bagian lainnya).
• (C)( tanpa perubahan), (A, D, E), (B), ( karena kita lewat dari A, D, E masing-masing sepanjang a, c ke B dan C).
• Kita tidak bisa melakukan split lagi.

Misalkan grup (C) sesuai dengan state C, grup (A, D, E) untuk state A, dan grup (B) untuk state B. Kemudian kita memperoleh DFA dengan jumlah state minimum:

Contoh (algoritma untuk membangun partisi)

Tabel transisi untuk DFA yang didefinisikan di mana saja (status Z ditambahkan) yang sesuai dengan RV (ab|ε)a*|abb|b*a. Dari soal-soal ujian 2012.

	sebuah	b	saya 0	saya 1
→A*	B	C	0.01	0.12
B*	D	E	0.00	1.01
C	F	C	1.01
D*	D	Z	0.01	0.04
E*	D	Z	0.00	1.03
F*	Z	Z	0.11
Z	Z	Z	1.11

Iterasi:

• Saya 0: ABCDEF(0), CZ(1).
• I 1: AD(0), BE(1), C(2), F(3), Z(4).
• I 2: A, B, C, D, E, F, Z.

Hasil: mesin sudah memiliki jumlah status minimum :-)

DFA yang memungkinkan penyelesaian bahasa

Algoritma untuk membangun DFA yang menerima komplemen dari bahasa L (L̅) terdiri dari dua langkah:

• Membangun DFA yang lengkap
• Konstruksi otomat yang diinginkan darinya

Faktanya, tidak ada DFA yang lengkap. Di bawah DKA penuh beberapa guru memahami otomat, di tabel transisi yang tidak ada sel kosong. Namun, menurut definisi DFA - : Q × → Q - tidak boleh ada sel kosong dalam hal apa pun. Namun, otomat "dengan sel kosong", memenuhi definisi NFA. Dalam proses penyelesaian, tidak jarang mendapatkan NFA seperti itu, yang hanya kekurangan transisi sebelum DFA.

Untuk mengisinya kembali, cukup dengan menambahkan status baru X, dan "alih-alih" transisi yang tidak ada menambahkan transisi ke status baru ini. Jangan lupa untuk menambahkan transisi dari X di X. Sangat mudah untuk melihat bahwa di mana otomat asli tidak menerima beberapa rantai karena tidak adanya transisi, otomat baru akan masuk ke status X dan terpaku padanya. Karena status baru bukanlah status penerimaan (final), otomat baru juga tidak akan menerima rantai ini.

Sekarang, untuk membangun otomat yang diinginkan, hanya perlu mengubah peran status penerima dan non-penerima. Dengan kata lain, F" = Q\F.

Membangun penganalisis LL(k)

Transformasi tata bahasa

Tidak setiap tata bahasa adalah LL(k)-parsable. Tata bahasa bebas konteks termasuk dalam kelas LL(1) jika tidak memiliki konflik FIRST-FIRST (rekursi kiri adalah kasus khusus dari konflik tersebut) dan FIRST-FOLLOW.

Terkadang dimungkinkan untuk mengubah tata bahasa non-LL(1) sehingga menjadi LL(1). Beberapa (lebih tepatnya, yang dipertimbangkan dalam kursus) transformasi diberikan di bawah ini.

Menghapus rekursi kiri

Misalkan kita memiliki aturan bentuk (selanjutnya di bagian ini, huruf kapital - simbol non-terminal, huruf kecil - rantai karakter apa pun):

• A→A sebuah| A b| … | A k | m | n | … | z

Itu tidak dapat diterima untuk analisis yang tidak ambigu, jadi itu harus dikonversi.

Sangat mudah untuk menunjukkan bahwa aturan ini setara dengan pasangan aturan berikut:

• A → m b | n b | … | z B
• B → sebuah b | b b | … | k b |

Faktorisasi kiri

Inti dari prosedur ini adalah menghilangkan ambiguitas dalam pemilihan aturan untuk karakter kiri. Untuk melakukan ini, awalan kiri yang sama ditemukan dan apa yang dapat mengikutinya diambil dalam aturan baru (huruf kecil - rantai karakter apa pun)

Contoh

• A → sebuah c | sebuah df | sebuah dg | b

Dikonversi ke

• A → sebuah b | b
• B → c | d f | d g

yang pada gilirannya menjadi

• A → sebuah b | b
• B → c | d Dengan
• C → f | g

Contoh Konversi Tata Bahasa

G= ((S, A, B), (a, b, c), P, S)

• S→SAbB | sebuah
• A→ab | aa |
• B → c |

Menghapus rekursi kiri untuk S:

• S → as 1
• S 1 → AbBS 1 |

Faktorisasi kiri untuk A:

• A → aA 1 |
• A 1 → b | sebuah

Tata bahasa akhir:

• S → as 1
• S 1 → AbBS 1 |
• A → aA 1 |
• A 1 → b | sebuah
• B → c |

Membangun PERTAMA dan IKUTI

PERTAMA(α), di mana (N T)* adalah himpunan terminal dari mana dapat dimulai. Jika , maka PERTAMA(α). Dengan demikian, nilai FOLLOW( A) untuk non-terminal A- banyak terminal yang dapat muncul segera setelahnya A dalam beberapa bentuk sentimental. Jika sebuah A mungkin karakter paling kanan dalam beberapa bentuk kalimat, maka $ token terakhir juga milik FOLLOW( A)

perhitungan PERTAMA

Untuk terminal

• Untuk terminal apa pun x, x ∈ T, PERTAMA( x) = {x}

Untuk non-terminal

• Jika sebuah X adalah non-terminal, maka kami menempatkan PERTAMA( X) = {∅}
• Jika tata bahasa memiliki aturan X→ , lalu tambahkan ke PERTAMA( X)
• Untuk setiap non-terminal X dan untuk setiap aturan inferensi X → kamu 1 …kamu k tambahkan ke PERTAMA( X) himpunan PERTAMA dari semua simbol di sisi kanan aturan hingga yang pertama dari mana tidak diturunkan, termasuk

Untuk rantai

• Untuk string karakter X 1 …X k FIRST adalah gabungan karakter FIRST yang termasuk dalam string hingga yang pertama, yang memiliki FIRST, termasuk di dalamnya.

Contoh

• S → as 1
• S 1 → AbBS 1 |
• A → aA 1 |
• A 1 → b | sebuah
• B → c |

Non-terminal PERTAMA dalam urutan resolusi ketergantungan:

• PERTAMA(S) = (a)
• PERTAMA(A) = (a, )
• PERTAMA(A 1) = (b, a)
• PERTAMA(B) = (c, )
• PERTAMA(S 1) = (a, b, )

PERTAMA untuk aturan inferensi:

• PERTAMA(aS 1) = (a)
• PERTAMA(AbBS 1) = (a, b)
• PERTAMA(ε) = (ε)
• PERTAMA(aA 1) = (a)
• PERTAMA(a) = (a)
• PERTAMA(b) = (b)
• PERTAMA(c) = (c)

IKUTI perhitungan

Menghitung fungsi FOLLOW untuk karakter X:

• Biarkan IKUTI(X) = (∅)
• Jika X adalah aksioma tata bahasa, tambahkan penanda $ ke FOLLOW
• Untuk semua aturan bentuk A → X tambahkan FIRST(β)\(ε) ke FOLLOW(X) (X dapat diikuti oleh karakter yang dimulai dengan )
• Untuk semua aturan bentuk A → X dan A → Xβ, FIRST(β), tambahkan FOLLOW(A) ke FOLLOW(X) (yaitu, X dapat diikuti oleh semua karakter yang dapat mengikuti A, jika dalam aturan inferensi, X mungkin berada di paling kanan)
• Ulangi dua paragraf sebelumnya selama mungkin untuk menambahkan karakter ke set

Contoh

• S → as 1
• S 1 → AbBS 1 |
• A → aA 1 |
• A 1 → b | sebuah
• B → c |

Hasil:

• IKUTI(S) = ($)
• FOLLOW(S 1) = ($) (S 1 adalah karakter paling kanan dalam aturan S → aS 1)
• IKUTI(A) = (b) (A dalam aturan S 1 → AbBS 1 diikuti oleh b)
• FOLLOW(A 1) = (b) (A 1 adalah karakter paling kanan dalam aturan A → aA 1 , maka tambahkan FOLLOW(A) ke FOLLOW(A 1))
• FOLLOW(B) = (a, b, $) (tambah FIRST(S 1)\(ε) (mengikuti aturan S 1 → AbBS 1), FOLLOW(S 1) (karena ada S 1 → ))

Menyusun tabel

Meja M untuk pasangan non-terminal-terminal (dalam sel M[A, sebuah]) menentukan aturan di mana kata input harus dikurangi. Tabel diisi sebagai berikut: untuk setiap aturan inferensi dari tata bahasa yang diberikan A → (di mana dipahami sebagai rantai di sisi kanan aturan), tindakan berikut dilakukan:

1. Untuk setiap terminal sebuah PERTAMA(α) tambahkan aturan A → α ke M[A, sebuah]
2. Jika PERTAMA(α), maka untuk setiap b IKUTI ( A) Menambahkan A → α ke M[A, b]
3. PERTAMA(α) dan $ IKUTI( A), Menambahkan A → α ke M[A, $]
4. Semua sel kosong adalah kesalahan dalam kata input

Contoh

Buat tabel untuk tata bahasa

• S → as 1
• S 1 → AbBS 1 |
• A → aA 1 |
• A 1 → b | sebuah
• B → c |

Hasil:

	sebuah	b	c	$
S	S → as 1 (Aturan pertama, inferensi S → aS 1 , a FIRST(aS 1))	kesalahan (Aturan keempat)	kesalahan (Aturan keempat)	kesalahan (Aturan keempat)
S1	S 1 → AbBS 1 (Aturan pertama, keluaran S 1 → AbBS 1 , a FIRST(AbBS 1))	S 1 → AbBS 1 (Aturan pertama, keluaran S 1 → AbBS 1 , b FIRST(AbBS 1))	kesalahan (Aturan keempat)	S 1 → (Aturan ketiga, inferensi S 1 → , FIRST(ε), $ FOLLOW(S 1))
A	A → aA 1 (Aturan pertama, keluaran A → aA 1 , a PERTAMA(aA 1))	A→ε (Aturan kedua, keluaran A 1 → , b FOLLOW(A 1))	kesalahan (Aturan keempat)	kesalahan (Aturan keempat)
1	A 1 → a (Aturan pertama, keluaran A 1 → a, a PERTAMA(a))	A 1 → b (Aturan pertama, keluaran A 1 → b, b PERTAMA(b))	kesalahan (Aturan keempat)	kesalahan (Aturan keempat)
B	B→e	B→e (Aturan kedua, inferensi B → , a FOLLOW(B))	B → c (Aturan pertama, keluaran B → c, c PERTAMA(c))	B→e (Aturan ketiga, inferensi B → , $ FOLLOW(B))

Penguraian string

Proses penguraian string cukup sederhana. Esensinya adalah sebagai berikut: pada setiap langkah, simbol teratas dibaca v c rantai masukan.

• Jika sebuah v- karakter terminal
  • Jika sebuah v bertepatan dengan dengan, lalu keduanya hancur, ada pergeseran
  • Jika sebuah v tidak cocok dengan dengan, maka kesalahan penguraian ditandai
• Jika sebuah v- simbol non-terminal, c kembali ke awal baris alih-alih v sisi kanan aturan, yang diambil dari sel tabel, dikembalikan ke tumpukan M[v, c]

Proses berakhir ketika string dan tumpukan telah mencapai penanda akhir (#).

Contoh

Mari kita urai string "aabbaabcb":

tumpukan	garis	tindakan
S#	sebuah abbaabcb$	S → as 1
sebuah S1#	sebuah abbaabcb$	menggeser
S1#	sebuah bababcb$	S 1 → AbBS 1
A bb 1#	sebuah bababcb$	A → aA 1
sebuah A 1 bBS 1 #	sebuah bababcb$	menggeser
1 bb 1#	b baabcb$	A 1 → b
b bb 1#	b baabcb$	menggeser
b BS 1#	b aabcb$	menggeser
B S1#	sebuah abcb$	B→e
S1#	sebuah abcb$	S 1 → AbBS 1
A bb 1#	sebuah abcb$	A → aA 1
A bb 1#	sebuah abcb$	A → aA 1
sebuah A 1 bBS 1 #	sebuah abcb$	menggeser
1 bb 1#	sebuah bcb$	A 1 → a
sebuah bb 1#	sebuah bcb$	menggeser
b BS 1#	b cb$	menggeser
B S1#	c b$	B → c
c S1#	c b$	menggeser
S1#	b$	S 1 → AbBS 1
A bb 1#	b$	A→ε
b BS 1#	b$	menggeser
B S1#	$	B→e
S1#	$	S 1 →
#	$	siap

Membangun penganalisis LR(k)

Menghitung k dalam LR(k)

Tidak ada algoritma yang memungkinkan, dalam kasus umum, untuk menghitung k untuk tata bahasa yang berubah-ubah. Biasanya ada baiknya mencoba membuat parser LR(1). Jika memiliki paling banyak satu operasi per set (Shift, Reduce, atau Accept), maka tata bahasanya adalah LR(0). Namun, jika konflik dan tabrakan terjadi saat membangun parser LR(1), maka tata bahasa ini bukan LR(1) dan patut dicoba untuk membangun LR(2). Jika gagal membangunnya, maka LR(3) dan seterusnya.

Tata bahasa selesai

Mari tambahkan aturan baru S" → S, dan jadikan S" sebagai aksioma tata bahasa. Aturan tambahan ini diperlukan untuk menentukan kapan penganalisis berakhir dan rantai input diizinkan. Penerimaan terjadi jika dan hanya jika dimungkinkan untuk melakukan konvolusi menurut aturan S → S".

Konstruksi sistem kanonik dari kumpulan situasi LR(1) yang dapat diterima

Pada awalnya, ada himpunan I 0 dengan konfigurasi analyzer S" → .S, $. Kemudian, operasi penutupan diterapkan pada konfigurasi ini hingga, sebagai hasil penerapannya, tidak ada konfigurasi baru yang ditambahkan. Selanjutnya , transisi ke set baru dibangun dengan menggeser titik satu karakter ke kanan (lompatan dilakukan oleh karakter yang berada setelah titik sebelum lompat dan sebelum setelah lompat), dan konfigurasi yang diperoleh dari yang sudah ada dengan cara ini ditambahkan ke set ini.Operasi penutupan juga diterapkan pada mereka, dan seluruh proses diulang sampai tidak ada lagi set baru yang muncul.

Contoh

Membangun sistem kanonik dari set LR(1)-situasi yang dapat diterima untuk tata bahasa yang ditentukan:

• S" → S
• S → ABA
• A → Aa |
• B → cBc | d

Keputusan:

• Kami membuat penutupan untuk konfigurasi S" → .S, $:
  • S → .ABA,$
• Untuk konfigurasi yang dihasilkan (S → .ABA, $) kami juga membuat penutupan:
  • A → .Aa, c
  • A → .Aa, d
  • A → .,c
  • A → ., d
• Untuk konfigurasi yang dihasilkan (A → .Aa, c; A → .Aa, d) kami juga membuat penutupan:
  • A → .Aa, a
  • A → ., a
• Tidak ada lagi konfigurasi dalam status I 0 yang dapat dibuat - penutupan dibuat

• Dari I 0, Anda dapat membuat transisi di sepanjang S dan A dan mendapatkan satu set konfigurasi I 1 dan I 2, yang terdiri dari elemen-elemen berikut:
  • I 1 = (S" → S., $)
  • I 2 = (S → A.BA, $; A → A.a, c; A → A.a, d; A → A.a, a)
• I 1 tidak memerlukan penutupan
• Mari kita buat penutupan I 2:
  • B → .cBc, a
  • B → .cBc, $
  • B → .d, a
  • B → .d, $
• Semua set lainnya dibangun dengan cara yang sama.

Membangun tabel parser

Langkah terakhir dalam membangun parser LR(1) adalah membuat tabel tindakan dan pergi ke. Meja tindakan dibangun untuk karakter string input, yaitu untuk terminal dan penanda akhir baris $, tabel pergi ke dibangun untuk simbol tata bahasa, yaitu untuk terminal dan non-terminal.

Membangun Meja Goto

Tabel Goto menunjukkan status mana yang harus dituju ketika simbol tata bahasa berikutnya ditemukan. Oleh karena itu, jika dalam sistem kanonik himpunan terdapat transisi dari saya saya di Aku j dengan simbol A, lalu di Goto( Saya saya, A) kami menempatkan negara Saya j. Setelah mengisi tabel, kami berasumsi bahwa di semua sel kosong Goto( Saya saya, A) = Kesalahan

Membangun tabel Tindakan

• Jika ada transisi pada terminal a dari state I i ke state I j , maka Action(I i , a) = Shift(I j)
• Jika A S" dan ada konfigurasi A → ., a, maka Aksi(I i , a) = Reduce(A → )
• Untuk state I i yang memiliki konfigurasi S" → S., $, Action(I i , $) = Accept
• Untuk semua sel kosong Action(I i , a) = Error

Contoh

Bangun tabel Action dan Goto untuk tata bahasa

• S" → S
• S → ABA
• A → Aa |
• B → cBc | d

Keputusan:

	tindakan				pergi ke
	sebuah	c	d	$	S	S"	A	B	sebuah	c	d
saya 0	Kurangi(A → )	Kurangi(A → )	Kurangi(A → )		saya 1		saya 2
saya 1				menerima
saya 2	Shift(I 6)	Shift(I 4)	Shift(I 5)					saya 3	saya 6	saya 4	saya 5
saya 3	Kurangi(A → )			Kurangi(A → )			saya 13
saya 4		Pergeseran (I 8)	Pergeseran (I 9)					saya 7		saya 8	saya 9
saya 5	Kurangi (B → d)			Kurangi (B → d)
saya 6	Kurangi (A → Aa)	Kurangi (A → Aa)	Kurangi (A → Aa)
saya 7		Shift(I 10)								saya 10
saya 8		Pergeseran (I 8)	Pergeseran (I 9)					saya 11		saya 8	saya 9
saya 9		Kurangi (B → d)
saya 10	Kurangi (B → cBc)			Kurangi (B → cBc)
saya 11		Shift(I 12)								saya 12
saya 12		Kurangi (B → cBc)
saya 13	Shift(I 14)			Kurangi(S → ABA)					saya 14
saya 14	Kurangi (A → Aa)			Kurangi (A → Aa)

Penguraian rantai

Pada setiap langkah, karakter teratas dibaca v dari tumpukan penganalisis dan ambil karakter terakhir c rantai masukan.

Jika dalam tabel aksi di persimpangan v dan c terletak:

• Menggeser( ik), lalu taruh di tumpukan dengan lalu ik. Di mana c dihapus dari tali.
• Mengurangi( A → kamu), maka semua simbol terminal dan non-terminal yang membentuk rantai dihapus dari bagian atas tumpukan kamu, setelah itu negara terlihat Aku tersisa di atas. Menurut tabel transisi di persimpangan Aku dan A temukan keadaan selanjutnya Adalah. Kemudian A didorong ke tumpukan, dan kemudian Adalah. Garis tetap tidak berubah.
• Terima, lalu penguraian selesai
• kekosongan adalah sebuah kesalahan

Contoh

Mari kita buat penguraian string aaaccdcc:

Tumpukan	Garis	Tindakan
saya 0	sebuah aaccdcc$	Kurangi(A → ), masuk ke I 2
saya 0 A saya 2	sebuah aaccdcc$	Shift(I 6)
Saya 0 A Saya 2 a saya 6	sebuah accdcc$	Kurangi(A → Aa), goto I 2
saya 0 A saya 2	sebuah accdcc$	Shift(I 6)
Saya 0 A Saya 2 a saya 6	sebuah ccdcc$	Kurangi(A → Aa), goto I 2
saya 0 A saya 2	sebuah ccdcc$	Shift(I 6)
Saya 0 A Saya 2 a saya 6	c cdcc$	Kurangi(A → Aa), goto I 2
saya 0 A saya 2	c cdcc$	Shift(I 4)
Saya 0 A Saya 2 s saya 4	c dcc$	Pergeseran (I 8)
I 0 A I 2 c I 4 c saya 8	d cc$	Pergeseran (I 9)
I 0 A I 2 c I 4 c I 8 d saya 9	c c$	Kurangi(B → d), lanjutkan ke I 11
I 0 A I 2 c I 4 c I 8 B saya 11	c c$	Shift(I 12)
I 0 A I 2 c I 4 c I 8 B I 11 c saya 12	c$	Kurangi(B → cBc), lanjutkan ke I 7
I 0 A I 2 c I 4 B saya 7	c$	Shift(I 10)
I 0 A I 2 c I 4 B I 7 c saya 10	$	Kurangi(B → cBc), lanjutkan ke I 3
Saya 0 A Saya 2 B saya 3	$	Kurangi(A → ), masuk ke I 13
I 0 A I 2 B I 3 A saya 13	$	Kurangi(S → ABA), lanjutkan ke I 1
saya 0 S saya 1	$	menerima

Terjemahan ekspresi aritmatika (algoritma Seti-Ullman)

Catatan. Kode dihasilkan oleh gaya doggy seperti Motorola, mis.

Op Arg1, Arg2

berdiri untuk

Arg2 = Arg1 Op Arg2

Membangun pohon

Pohon dibangun seperti biasa untuk ekspresi aritmatika: Pada akar, operasi dengan prioritas terendah, diikuti oleh operasi dengan prioritas sedikit lebih tinggi, dan seterusnya. Tanda kurung memiliki prioritas tertinggi. Jika ada beberapa operasi dengan prioritas yang sama - a op b op c, maka pohon dibangun untuk ekspresi (a op b) op c.

Contoh

Bangun pohon untuk ekspresi a + b / (d + a b × c / d e) + c × d

Keputusan: Kami menulis ekspresi dalam bentuk

((a) + ((b) / ((((d) + (a))) ((b) × (c)) / (d)) (e)))) + ((c) × ( d))

Kemudian pada akar setiap subpohon akan ada operasi, dan ekspresi dalam tanda kurung di sebelah kiri dan kanannya akan menjadi subpohonnya. Misalnya, untuk subekspresi ((b) × (c)) / (d), operasi “/” akan berada di akar subpohon yang sesuai, dan subekspresi ((b) × (c)) dan (d ) akan menjadi subpohonnya.

Tata letak pohon (perhitungan jumlah register)

• Jika simpulnya adalah daun kiri (yaitu variabel), maka kita menandainya dengan nol.
• Jika simpulnya adalah daun yang tepat, maka kami menandainya dengan satu
• Jika kita menandai kedua subpohonnya untuk beberapa titik, maka kita menandainya sebagai berikut:
  • Jika subpohon kiri dan kanan diberi label dengan angka yang berbeda, maka pilihlah yang terbesar dari mereka
  • Jika subpohon kiri dan kanan diberi label dengan angka yang sama, maka subpohon ini diberi nomor satu lebih besar dari yang memberi label pada subpohon

tanda daun	Tata letak pohon dengan subpohon yang identik	Subpohon kiri diberi label dengan angka besar	Subpohon kanan diberi label dengan angka besar

Baik - sama seperti nenek moyang.

Jika labelnya kiri keturunan lagi label Baik, kemudian Baik anak ditugaskan mendaftar satu lagi daripada leluhur, dan kiri - sama seperti nenek moyang.

Kode dibentuk dengan melintasi pohon dari bawah ke atas sebagai berikut:

1. Tidak ada kode yang dihasilkan untuk simpul dengan label 0

2. Jika bagian atas adalah lembar X dengan label 1 dan register R saya, lalu kode

PINDAHKAN X, Ri

3. Jika bagian atas adalah internal dengan register R saya dan anak kirinya adalah lembar X dengan label 0, maka sesuai dengan kode

<Код правого поддерева>OpX, Ri

4. Jika subpohon dari suatu simpul dengan register R saya- tidak meninggalkan dan label simpul kanan lebih besar atau sama dengan label simpul kiri (yang memiliki register Rj, j = i + 1), maka kode sesuai dengan simpul

<Код Baik subpohon><Код kiri subpohon > Op Rj, Ri

5. Jika subpohon dari simpul dengan register R saya- tidak meninggalkan dan label dari simpul kanan (yang register Rj, j = i + 1) lebih kecil dari label kiri, maka kode sesuai dengan simpul

Distribusi register ditunjukkan pada grafik di sebelah kanan. Kode yang dihasilkan:

PINDAHKAN d, R0 ;R0 = d PINDAH c, R1 ;R1 = c MUL b, R1 ;R1 = (b × c) DIV R1, R0 ;R0 = (b × c) / d PINDAH a, R1 ;R1 = a TAMBAHKAN d, R1 ;R1 = a + d SUB R1, R0 ;R0 = (a + d) ((b × c) / d) PINDAH e, R1 ;R1 = e SUB R0, R1 ;R1 = ((a + d) ((b × c) / d)) − e PINDAHKAN R1, R0;R0 = ((a + d) ((b × c) / d)) − e DIV b, R0 ;R0 = b / (((a + d) ((b × c) / d)) e) TAMBAHKAN a, R0 ;R0 = a + (b / (((a + d) ((b × c) / d )) e)) PINDAHKAN d, R1 ;R1 = d MUL c, R1 ;R1 = c × d TAMBAHKAN R0, R1 ;R1 = (a + (b / (((a + d) ((b × c) ) / d)) e))) + (c × d) PINDAHKAN R1, R0;R0 = (a + (b / (((a + d) ((b × c) / d)) e) )) + (c × d)

Terjemahan ekspresi logis

Bagian ini menunjukkan cara membuat kode untuk evaluasi lazy dari ekspresi boolean. Sebagai hasil dari algoritme, sepotong kode diperoleh, yang, menggunakan operasi TST, BNE, BEQ, menghitung ekspresi logis dengan beralih ke salah satu label: TRUELAB atau FALSELAB.

Membangun pohon

Pohon dari ekspresi logika mencerminkan urutan yang dievaluasi sesuai dengan prioritas operasi, yaitu, untuk mengevaluasi nilai dari simpul pohon (yang merupakan operasi pada dua operan yang merupakan subpohon dari simpul), kita harus hitung dulu nilai subpohonnya.

Prioritas Operasi: Operator NOT memiliki prioritas tertinggi, diikuti oleh AND dan kemudian OR. Jika operasi logis lain digunakan dalam ekspresi, maka mereka harus diekspresikan melalui ketiganya dengan cara tertentu (biasanya, tidak ada operasi lain dan konversi ekspresi tidak diperlukan). Asosiatifitas untuk operasi dengan prioritas yang sama adalah dari kiri ke kanan, yaitu A dan B dan C diperlakukan sebagai (A dan B) dan C

Contoh

Buatlah pohon untuk ekspresi logika bukan A atau B dan C dan (B atau bukan C).

Keputusan: lihat diagram di sebelah kanan.

Untuk setiap simpul pohon, 4 atribut dihitung:

• Nomor simpul
• Label untuk melompat jika ekspresi dalam simpul salah (label salah, fl)
• Label untuk melompat jika ekspresi dalam simpul benar (label benar, tl)
• Label-sign (tanda) (untuk lebih jelasnya lihat di bawah)

Simpul diberi nomor dalam urutan acak, satu-satunya syarat adalah keunikan nomor simpul.

Tata letak pohon dilakukan sebagai berikut:

• fl menentukan jumlah simpul tempat transisi dibuat atau falselab jika simpul ini salah
• tl menunjukkan jumlah simpul tempat transisi dibuat atau truelab jika simpul ini benar

Tanda menentukan dalam hal mana evaluasi subpohon saat ini dapat dihentikan.

Untuk akar pohon, fl=falselab, tl=truelab, sign=false.

Dengan demikian:

Contoh

Tandai pohon yang dibangun untuk ekspresi logis bukan A atau B dan C dan (B atau bukan C).

Pembuatan kode

Perintah mesin yang digunakan dalam kode yang dihasilkan:

• TST - memeriksa kebenaran argumen dan memasang bendera jika argumen salah
• BNE - lompat ke label jika bendera tidak disetel, yaitu kondisi diperiksa dengan TST BENAR
• BEQ - lompat pada label jika bendera diatur, yaitu kondisi diperiksa dengan TST Salah

Kode dibangun sebagai berikut:

• pohon dilintasi dari akarnya, untuk AND dan OR, subpohon kiri dilalui terlebih dahulu, lalu kanan
• untuk setiap simpul yang dilewati, nomornya (label) dicetak
• untuk lembar A(angka, tl, fl, tanda) TST A tercetak
  • jika tanda == benar, BNE tl dicetak
  • jika tanda == salah, BEQ fl dicetak

Contoh

Untuk ekspresi di atas, kode berikut akan dibuat:

1:2:4: TST A BEQ TRUELAB 3:5:7: TST B BEQ FALSELAB 8: TST C BEQ FALSELAB 6:9: TST B BNE TRUELAB 10:11: TST C BNE FALSELAB TRUELAB: FALSELAB:

Metode pencocokan sampel

Gagasan metode ini adalah bahwa untuk bagian program yang sama, kode dapat dibuat dengan cara yang berbeda, dan, sebagai hasilnya, pengoptimalan dapat dicapai untuk satu atau beberapa parameter lainnya.

Rumusan masalah

Ada banyak sampel, yang masing-masing ditentukan oleh bagian dari representasi perantara yang dapat diterapkan, bobot dan kode yang dihasilkan. Ada pohon representasi perantara, yang merupakan bagian dari program yang diperlukan untuk menghasilkan kode. Tujuannya adalah untuk membangun penutup pohon representasi perantara dengan sampel sehingga berat total sampel minimal.

Pola adalah instruksi perakitan dan pohon parsing yang sesuai dengannya. Untuk setiap sampel, waktu eksekusinya (dalam siklus) diketahui. Dengan bantuan mereka, kami akan menghasilkan kode yang optimal (dalam hal waktu eksekusi).

Contoh contoh

Membangun representasi perantara

Pertama, kita membangun pohon parse untuk seluruh ekspresi.

Membangun liputan

Sekarang untuk setiap simpul (kita menelusurinya secara berurutan dari daun ke akar), kita akan menghasilkan kode optimal untuk subpohonnya. Untuk melakukan ini, kita cukup menelusuri semua sampel yang berlaku pada titik tertentu. Waktu eksekusi saat menggunakan pola tertentu akan menjadi jumlah waktu yang diperlukan untuk mengevaluasi argumennya (dan kita sudah mengetahui kode optimal untuk menghitungnya berkat urutan traversal pohon) dan waktu eksekusi pola itu sendiri. Dari semua opsi yang diperoleh, kami memilih yang terbaik - ini akan menjadi kode optimal untuk subpohon dari simpul ini. Di akar pohon, kami mendapatkan kode optimal untuk seluruh ekspresi.

Pembuatan kode

Tidak perlu menuliskan kode untuk semua simpul - cukup menuliskan waktu minimum yang diperlukan dan sampel yang perlu Anda gunakan. Segala sesuatu yang lain dari ini mudah dipulihkan.

Kami memiliki jumlah register yang tak terbatas dalam masalah ini, jadi setiap kali Anda dapat menggunakan yang baru.

Konstruksi RV menurut DFA

Konstruksi NFA menurut tata bahasa linier kanan

Pengecoran Tata Bahasa

Untuk mengonversi tata bahasa COP arbitrer ke bentuk tereduksi, Anda harus melakukan langkah-langkah berikut:

• hapus semua karakter mandul;
• hapus semua karakter yang tidak terjangkau;

Menghapus karakter yang tidak berguna

Pintu masuk: COP-tata bahasa G = (T, N, P, S).

Keluaran: Tata bahasa COP G' = (T, N', P', S) tidak mengandung simbol mandul, di mana L(G) = L(G').

Metode:

Bangun set secara rekursif N 0 , N 1 , ...

1. N 0 = , i = 1.
2. N i = (A | (A → ) P dan (N i - 1 T)*) N i-1 .
3. Jika N i N i - 1, maka i = i + 1 dan lanjutkan ke langkah 2, jika tidak N’ = N i ; P' terdiri dari aturan himpunan P yang hanya berisi simbol dari N' T; G' = (T, N', P', S).

Definisi: simbol x (T N) dikatakan tidak terjangkau dalam tata bahasa G = (T, N, P, S) jika tidak muncul dalam bentuk kalimat apa pun dari tata bahasa ini.

Contoh

Hapus karakter yang tidak berguna dari tata bahasa G((A, B, C, D, E, F, S), (a, b, c, d, e, f, g), P, S)

• S → AcDe | CaDbCe | Saka | aCb | dFg
• A → SeAd | cSA
• B → CaBd | aDBc | BSC | bfg
• C→Ebd | Seb | aAc | cfF
• D→fCE | ac | dEdAS |
• E→ESacD | aec | eFF

Keputusan

• N 0 =
• N 1 = (B (B → bfg) , D (D → ac) , E (E → aec) )
• N 2 = (B, D, E, C (C → Ebd) )
• N 3 = (B, D, E, C, S (S → aCb) )
• N 4 \u003d (B, D, E, C, S) \u003d N 3

G"((B, C, D, E, S), (a, b, c, d, e, f, g), P", S)

• S → CaDbCe | Saka | aCb
• B → CaBd | aDBc | BSC | bfg
• C→Ebd | seb
• D→fCE | ac |
• E→ESacD | aec

Menghapus karakter yang tidak dapat dijangkau

Pintu masuk: Tata bahasa COP G = (T, N, P, S)

Keluaran: Tata bahasa COP G' = (T', N', P', S) tidak mengandung simbol yang tidak dapat dijangkau, dengan L(G) = L(G').

Metode:

1. V 0 = (S); saya = 1.
2. V i = (x | x (T N), (A → xβ) P dan A V i - 1 ) V i-1 .
3. Jika V i V i - 1 , maka i = i + 1 dan lanjutkan ke langkah 2, jika tidak N’ = V i N; T' = V i T; P' terdiri dari aturan-aturan himpunan P yang hanya berisi simbol-simbol dari V i ; G' = (T', N', P', S).

Definisi: Sebuah COP-tata bahasa G dikatakan tereduksi jika tidak mengandung simbol-simbol yang tidak dapat dicapai dan steril.

Contoh

Hapus karakter yang tidak dapat dijangkau dari tata bahasa G"((B, C, D, E, S), (a, b, c, d, e, f, g), P", S)

• S → CaDbCe | Saka | aCb
• B → CaBd | aDBc | BSC | bfg
• C→Ebd | seb
• D→fCE | ac |
• E→ESacD | aec

Keputusan

• V 0 = (S)
• V 1 = (S, C (S → CaDbCe) , D (S → CaDbCe) , a (S → CaDbCe) , b (S → CaDbCe) , e (S → CaDbCe) )
• V 2 = (S, C, D, a, b, e, E (C → Ebd) , d (C → Ebd) , f (D → fCE) )
• V 3 = (S, C, D, E, a, b, d, e, f, c (E → ESacD) )
• V 4 \u003d (S, C, D, E, a, b, d, e, f, c) \u003d V 3

G""((C, D, E, S), (a, b, c, d, e, f), P"", S)

• S → CaDbCe | Saka | aCb
• C→Ebd | seb
• D→fCE | ac |
• E→ESacD | aec

Lebih mudah untuk menggambarkan kosakata suatu bahasa dalam bentuk ekspresi reguler, dan untuk mengenali bahasa dengan bantuan KA. Oleh karena itu, penting untuk dapat mengubah definisi bahasa dalam bentuk ekspresi reguler menjadi definisi dalam bentuk FA. Transformasi seperti itu disarankan oleh Kennet Thompson.

Mesin negara adalah lima (S, S, d, S 0 , F)

S adalah himpunan berhingga keadaan.

S adalah himpunan terbatas dari sinyal input yang valid.

d - fungsi transisi. Ini mencerminkan himpunan Sx(SÈ(e)) ke dalam himpunan keadaan dari robot berhingga non-deterministik. Untuk otomat deterministik, fungsi transisi mencerminkan himpunan SxS ke dalam himpunan status otomat. Dengan kata lain, tergantung pada status dan simbol input, d menentukan status baru dari otomat.

S 0 - keadaan awal otomat terbatas, S 0 S.

F adalah himpunan keadaan akhir dari otomat, F S.

Pengoperasian mesin negara adalah urutan langkah-langkah. Langkah ditentukan oleh keadaan otomat dan simbol input. Langkah itu sendiri terdiri dari mengubah keadaan otomat dan membaca simbol berikutnya dari urutan input.

Ada aturan berikut untuk mengonversi ekspresi reguler ke mesin status.

1 Ekspresi reguler "e" diubah menjadi otomat dari dua keadaan dan transisi elektronik di antara keduanya (Gambar 1).

Gambar 1. - Otomaton untuk e-transisi

2 Ekspresi reguler dari satu karakter "a" diubah menjadi mesin keadaan hingga dari dua keadaan dan transisi di antara keduanya sesuai dengan sinyal input a (Gambar 2).

Gambar 2. - Automaton untuk melompat dengan simbol a

3 Biarkan ada ekspresi reguler rs dan automata hingga untuk ekspresi r dan ekspresi s telah dibangun. Kemudian kedua automata dihubungkan secara seri. Gambar 3 menunjukkan automata awal untuk bahasa r dan s. Gambar tersebut menunjukkan sebuah robot untuk mengenali rangkaian bahasa-bahasa ini.

Otomatis untuk r Otomatis untuk s

Gambar 3. - Automata awal

Gambar 4. - Mesin untuk menggabungkan bahasa

4 Biarkan ada ekspresi reguler r | s dan finite automata telah dibuat untuk ekspresi r dan ekspresi s (Gambar 3). Kemudian pada otomata yang dihasilkan harus ada alternatif untuk mengeksekusi salah satu dari dua otomata tersebut. Artinya, otomat untuk ekspresi r | s untuk automata untuk r dan s dari Gambar 3 memiliki bentuk yang ditunjukkan pada Gambar 5.

Gambar 5. - Mesin untuk menggabungkan bahasa

5 Misalkan ada ekspresi reguler r* dengan otomat hingga yang dibangun r. Dalam hal ini, dua keadaan baru diperkenalkan untuk kemungkinan melewati otomat dari ekspresi r, dan transisi-e antara keadaan akhir dan awal juga diperkenalkan untuk kemungkinan pengulangan berulang dari otomat r. Jika sebuah robot yang mirip dengan Gambar 3 dibangun untuk ekspresi reguler r, maka robot hingga yang ditunjukkan pada Gambar 6 sesuai dengan ekspresi reguler r*.

Pengaturan

Menurut teorema Kleene, ekspresi reguler apa pun dapat dikaitkan dengan otomat hingga, yang merupakan model formal dari algoritma untuk mengenali leksem yang dilambangkan dengan ekspresi reguler ini. Dalam istilah yang paling umum, sebuah automaton-recognizer terbatas didefinisikan oleh satu set terbatas dari karakteristik negara aliran input dan transisi di antara mereka. Perubahan status terjadi ketika karakter aliran input diterima dari alfabet yang diberikan sesuai dengan fungsi transisi , yang menentukan kemungkinan status selanjutnya dari karakter input dan status saat ini. Di antara status yang mungkin, status awal (awal) dan akhir (memungkinkan) dibedakan, di mana pengenal otomat terbatas dapat ditempatkan, masing-masing, pada awal dan penyelesaian pemrosesan token aliran input. Jika urutan input karakter dapat menghasilkan urutan transisi yang dapat mentransfer otomaton berhingga dari keadaan awal ke salah satu keadaan akhir, maka ia dianggap masuk dan termasuk dalam himpunan biasa yang dikenalinya.

(00|11)*((01|10)(00|11)*(01|10)(00|11)*)*

Tabel 1

	0	1
Q1	Q4	Q2
Q2	Q3	Q1
Q3	Q2	Q4
Q4	Q1	Q3

Kolom tabel transisi mewakili karakter alfabet input, dan baris sesuai dengan status DFA saat ini. Elemen-elemen dari setiap baris menunjukkan status DFA ke mana ia harus bertransisi dari status saat ini saat menerima karakter yang sesuai dari alfabet input. Secara khusus, berikut dari baris pertama tabel transisi ini bahwa menerima simbol 0 dan 1 di keadaan awal Q1 mentransfer DFA ke keadaan Q4 dan Q2, masing-masing.

Saat mengenali urutan input dari tabel transisi, mudah untuk melacak perubahan status DFA untuk menentukan apakah salah satu status penerima tercapai atau tidak. Khususnya, untuk vektor biner 01001000 dengan jumlah nol dan satu genap, DFA yang dipertimbangkan menghasilkan urutan transisi berikut, di mana setiap transisi diberi label dengan karakter alfabet input yang menyebutnya:

Q1 0 Q4 1 Q3 0 Q2 0 Q3 1 Q4 1 Q1 0 Q4 0 Q1

Urutan transisi ini berakhir dengan status penerimaan Q1, oleh karena itu, vektor biner 01001000 termasuk dalam himpunan reguler yang dikenali oleh DFA yang dipertimbangkan dan memenuhi ekspresi reguler di atas.

Sebagai kesimpulan, perlu dicatat bahwa metode konstruksi informal yang dipertimbangkan

Ekspresi reguler (RE) adalah bentuk penulisan yang sangat nyaman yang disebut bahasa reguler atau otomatis. Oleh karena itu, RT digunakan sebagai bahasa input di banyak sistem yang memproses rantai. Pertimbangkan contoh sistem seperti itu:

• Perintah grep Unix, atau perintah serupa untuk mencari string, seperti yang ditemukan di browser Web atau sistem pemformatan teks. Dalam sistem seperti itu, RE digunakan untuk menggambarkan pola yang dicari pengguna dalam file. Berbagai mesin pencari mengonversi RT menjadi deterministic finite state machine (DFA) atau non-deterministic finite state machine (NFA) dan menerapkan mesin status ini ke file yang sedang dicari.
• Generator penganalisis leksikal. Penganalisis leksikal adalah komponen kompiler, mereka memecah program sumber menjadi unit logis (token), yang dapat terdiri dari satu atau lebih karakter dan memiliki arti tertentu. Generator penganalisis leksikal mengambil deskripsi formal dari token, yang pada dasarnya adalah RE, dan membuat DFA yang mengenali token mana yang muncul dalam inputnya.
• RT dalam bahasa pemrograman.

Pada artikel ini, pertama-tama kita akan mengenal finite automata dan jenisnya (DFA dan NFA), dan kemudian kita akan mempertimbangkan contoh membangun DFA minimal menggunakan ekspresi reguler.

Mesin Negara

finite automaton (FA) adalah konverter yang memungkinkan Anda mengaitkan input dengan output yang sesuai, dan output ini mungkin tidak hanya bergantung pada input saat ini, tetapi juga pada apa yang terjadi sebelumnya, pada prasejarah finite automaton. Bahkan perilaku manusia, dan bukan hanya sistem buatan, dapat dijelaskan menggunakan CA. Menggunakan KA, seseorang dapat menggambarkan tidak hanya perilaku sistem buatan, tetapi bahkan perilaku manusia. Misalnya, reaksi Anda terhadap kenyataan bahwa tetangga Anda mendengarkan musik keras di malam hari akan menjadi satu setelah kejadian pertama dan sama sekali berbeda setelah beberapa kejadian seperti itu. Mungkin ada jumlah tak terbatas dari backstory semacam itu, muncul pertanyaan; Jenis memori apa yang harus dimiliki pesawat ruang angkasa agar berperilaku berbeda untuk setiap pengaturan sebelumnya? Jelas bahwa tidak mungkin menyimpan prasejarah dalam jumlah tak terbatas. Oleh karena itu, robot, seolah-olah, membagi semua kemungkinan prasejarah ke dalam kelas kesetaraan. Dua sejarah adalah setara jika mereka sama-sama mempengaruhi perilaku robot di masa depan. Kelas ekivalensi yang dikaitkan oleh otomat dengan sejarahnya saat ini juga disebut keadaan internal otomat.

Sekarang mari kita lihat cara-cara di mana CA dapat ditentukan. Mereka dapat ditentukan dalam bentuk grafik atau dalam bentuk tabel kontrol. Dalam bentuk grafik, KA ditentukan sebagai berikut:

• simpul grafik sesuai dengan status CA.
• tepi yang diarahkan sesuai dengan fungsi transisi (di dekat setiap tepi tersebut, simbol di mana transisi dilakukan ditunjukkan).
• sebuah simpul dengan sisi yang memasukinya yang tidak meninggalkan lebih dari satu keadaan sesuai dengan keadaan awal.
• status akhir CA ditandai dengan garis tebal.

Dalam bentuk tabel kontrol, seperti ini:

• Status KA terletak di deretan tabel.
• karakter bahasa yang dikenali - dalam kolom.
• di persimpangan, keadaan ditunjukkan, yang dapat dicapai dari keadaan tertentu dengan simbol yang diberikan.

Contoh KA dalam bentuk grafik dan dalam bentuk tabel kontrol akan disajikan di bawah ini.

DKA dan NKA

Perbedaan utama antara DFA dan NFA adalah bahwa DFA hanya dapat berada dalam satu keadaan selama operasi, sedangkan NFA dapat berada di beberapa keadaan pada waktu yang sama. Sebagai contoh karya NCA, orang dapat mengutip gagasan fisikawan Amerika Hugh Everett bahwa setiap peristiwa memecah dunia menjadi beberapa dunia, di mana masing-masing peristiwa ini berakhir dengan caranya sendiri. Misalnya, di satu dunia, Hitler memenangkan Dunia ke-2. perang, di tempat lain - Newton masuk ke bisnis alih-alih fisika dan penemuan hukum mekanika klasik harus ditunda selama 50 tahun.Untuk menarik kesimpulan apa pun dari pengoperasian mesin, seseorang harus mempelajari semua "dunia". Setelah seluruh rantai masukan telah dibaca, kami berasumsi bahwa NFA menerima rantai ini jika telah menyelesaikan pekerjaannya dalam keadaan menerima di setidaknya satu dari banyak "dunia". Dengan demikian, otomat menolak anak tangga jika diakhiri dalam keadaan yang tidak dapat diterima di setiap "dunia". DFA, di sisi lain, menerima string, ini jelas jika, setelah membaca seluruh input string, ia menemukan dirinya dalam keadaan menerima.

Dalam kebanyakan kasus, membangun NFA jauh lebih mudah daripada membangun DFA. Namun, meskipun demikian, menggunakan NFA untuk pemodelan bukanlah ide yang baik. Untungnya, untuk setiap NFA dimungkinkan untuk membuat DFA yang menerima bahasa input yang sama. Dalam artikel ini, kami tidak akan menyajikan algoritme untuk membuat DFA dari NFA, tetapi pertimbangkan algoritme ini berdasarkan contoh visual di bawah ini.

Membangun DFA Minimal dari Ekspresi Reguler

Untuk memulainya, berikut adalah sintaks RW yang digunakan dalam artikel ini:

• penggabungan ditentukan dengan spasi atau string kosong (misalnya: ab)
• serikat, menggunakan simbol "|"
• iterasi (penutupan Kleene), dengan simbol "*"

Pertimbangkan contoh yang diberikan ekspresi reguler:

xy* (x | y*) | ab (x | y*) | (x | a*) (x | y*)

Hal ini diperlukan untuk membangun DFA minimal dari ekspresi reguler dan menunjukkan pengenalan string yang benar dan salah.

Untuk memulainya, kita sederhanakan RT ini, dengan menggunakan hukum distributif rangkaian tangan kanan sehubungan dengan serikat, kita memperoleh RT berikut:

(xy* | ab | (x | a*)) (x | y*)

Sekarang kita membangun sebuah robot untuk RV ini:

Menurut aturan transformasi gabungan (kami tidak akan memberikan aturan untuk mengubah RV menjadi KA, karena mereka cukup jelas), kami mendapatkan otomat berikut:

Dengan aturan transformasi serikat:

Menurut aturan transformasi rangkaian:

Dan pada akhirnya kami menerapkan aturan transformasi penutupan dan mendapatkan NCA:

Kami menyingkirkan -transisi ("tanda bintang" menunjukkan status akhir):

Dalam NFA ini, keadaan s3 dan s5 adalah ekuivalen, karena (s3, x) = (s5, x) = s1 dan (s3, y) = (s5, y) = s5, s7. Ganti nama status s6 -> s5 dan s7 -> s6:

Kami membangun DFA menurut NFA:

Dalam DFA ini, keadaan p1 dan p5 adalah ekuivalen, karena
(p1, x) = (p5, x) = p4 dan (p1, y) = (p5, y) = p5. Ganti nama status p6 -> p5 dan p7 -> p6:

Robot ini adalah DFA minimum.

Misalkan adalah fungsi transisi, maka fungsi transisi yang diperluas yang dibangun dari akan dilambangkan dengan ', dan adalah string input.

Biarkan rantai = aaax menjadi input, kami berharap otomat berada di salah satu status penerima.

'(p0, ) = p0
'(p0, a) = (δ'(p0, ), a) = (p0, a) = p3
'(p0, aa) = (δ'(p0, a), a) = (p3, a) = p5
'(p0, aaa) = (δ'(p0, aa), a) = (p5, a) = p5
'(p0, aaax) = (δ'(p0, aaa), a) = (p5, a) = p4

p4 adalah status akhir yang valid, jadi string aaax valid untuk robot ini.

Sekarang anggaplah = xyyb:

'(p0, ) = p0
'(p0, x) = (δ'(p0, ), x) = (p0, x) = p1
'(p0, xy) = (δ'(p0, x), y) = (p1, y) = p1
'(p0, xyy) = (δ'(p0, xy), y) = (p1, y) = p1
'(p0, xyyb) = (δ'(p0, xyy), b) = (p1, b) =

Di sini kita melihat bahwa jika simbol b diinput ke otomat saat dalam keadaan p1, maka otomat ini akan mati, oleh karena itu rantai xyyb salah.

P.S. Dalam artikel ini, algoritma untuk membangun DFA oleh RT dipertimbangkan, tetapi ada algoritma yang lebih nyaman, khususnya untuk pemrograman, tetapi ini adalah topik untuk artikel lain ...

Untuk studi lebih lanjut tentang sifat-sifat automata hingga dan, khususnya, untuk memecahkan masalah sintesis, teorema berikut ini penting.

Teorema 7.7 (teorema determinisasi). Untuk setiap otomat hingga, sebuah otomat hingga deterministik yang setara dapat dibangun.

Untuk membuktikan teorema tersebut, pertama-tama perlu untuk menggambarkan algoritma untuk membangun sebuah otomat hingga deterministik dari yang asli; kedua, membenarkan algoritma ini dengan ketat membuktikan bahwa itu memang memberikan otomat terbatas yang deterministik dan setara dengan yang asli. Di sini kami hanya menyajikan algoritma untuk membangun sebuah robot deterministik.

Transformasi otomat terbatas sewenang-wenang menjadi deterministik setara dilakukan dalam dua tahap: pertama, busur dengan label \lambda dihapus, kemudian penentuan yang sebenarnya dilakukan.

1. Penghapusan -transisi (busur berlabel \lambda ).

Untuk berpindah dari mesin keadaan asli M=(V,Q,q_0,F,\delta) ke otomat terbatas yang setara M"=(V,Q",q_0,F",\delta") tanpa -transisi, cukup untuk melakukan transformasi berikut dalam grafik asli M.

sebuah. Semua status, kecuali status awal, yang hanya dimasukkan oleh busur berlabel \lambda , dihapus; ini mendefinisikan set Q" dari otomat terbatas M" . Jelas bahwa Q"\subseteq Q . Dalam hal ini, kita asumsikan bahwa keadaan awal tetap sama.

b. Himpunan busur dari otomat terbatas M" dan labelnya (dengan demikian fungsi transisi M" ) didefinisikan sebagai berikut: untuk dua keadaan apa pun p,r\in Q",~ p\to_(a)r berlaku jika dan hanya jika a\dalam V , dan salah satu dari berikut ini berlaku dalam grafik M: baik terdapat busur dari p ke r yang labelnya berisi simbol a , atau terdapat keadaan q sedemikian rupa sehingga p\Panah Kanan_(\lambda)^(+)q dan q\to_(a)r . Dalam hal ini, verteks q, secara umum, mungkin bukan milik himpunan Q ", yaitu, mungkin hilang ketika diteruskan ke otomat M" (Gbr. 7.11). Tetapi jika q\di Q" , maka, tentu saja, busur (q,r) akan dipertahankan di M" dan simbol a akan menjadi salah satu simbol yang termasuk dalam label busur ini (Gbr. 7.12).

Jadi, dalam M" semua busur M disimpan yang labelnya berbeda dari \lambda dan yang menghubungkan pasangan (simpul) keadaan dari himpunan Q" (tidak dihapus menurut butir a). Selain itu, untuk setiap rangkap tiga keadaan p,q,r (tidak harus berbeda!), sehingga p,r\di Q" dan terdapat lintasan dengan panjang bukan nol dari p ke q yang labelnya sama dengan \lambda (yaitu, jalur dengan -transisi), dan dari q ke r sebuah busur mengarah, label yang berisi simbol a dari alfabet input, di M" busur dibangun dari p ke r, label yang berisi simbol a (lihat Gambar 7.11).

di. Himpunan status akhir F" dari otomat hingga M" berisi semua status q\dalam Q" , yaitu, status dari otomat hingga M yang tidak dihapus menurut item a, yang q\Rightarrow_(\lambda)^(\ast)q_f untuk beberapa q_f\in F (yaitu, keadaan q itu sendiri adalah keadaan akhir dari otomat berhingga M , atau darinya sebuah jalur dengan panjang bukan nol di sepanjang busur berlabel \lambda mengarah ke salah satu status akhir dari otomat berhingga M ) (Gbr. 7.13).

2. Sebenarnya tekad.

Biarlah M=(Q,V,q_0,F,\delta) adalah otomat berhingga tanpa transisi-. Mari kita membangun sebuah otomat terbatas deterministik yang setara M_1 .

Robot berhingga ini didefinisikan sedemikian rupa sehingga himpunan keadaannya adalah himpunan semua himpunan bagian dari himpunan keadaan otomat berhingga M . Ini berarti bahwa setiap keadaan individu dari otomat hingga M_1 didefinisikan sebagai beberapa subset dari himpunan keadaan dari otomat hingga M . Dalam hal ini, keadaan awal dari otomat hingga yang baru (yaitu M_1 ) adalah subset tunggal yang berisi keadaan awal dari otomat hingga yang lama (yaitu M ), dan keadaan akhir dari otomat hingga yang baru adalah semua himpunan bagian Q yang berisi setidaknya satu final bagian atas otomat terbatas asli M .

Untuk selanjutnya, dengan mengizinkan kebebasan berbicara, kadang-kadang kita akan menyebut keadaan otomat terbatas M_1 himpunan keadaan. Akan tetapi, penting untuk dipahami dengan jelas bahwa setiap himpunan keadaan seperti itu adalah keadaan terpisah dari otomaton berhingga yang baru, tetapi bukan himpunan keadaannya. Pada saat yang sama, untuk otomat M yang asli ("lama"), ini justru merupakan himpunan statusnya. Secara kiasan, setiap subset status dari otomat hingga lama "diciutkan" menjadi satu status dari otomat hingga yang baru*.

*Secara formal, himpunan Q_1 harus didefinisikan sebagai himpunan yang berkorespondensi satu-satu dengan himpunan 2^Q , tetapi masih lebih mudah bagi kita untuk menganggap bahwa Q_1 bertepatan dengan 2^Q , karena himpunan status dari otomaton berhingga dapat berupa himpunan berhingga yang tidak kosong.

Fungsi transisi dari otomat hingga yang baru didefinisikan sehingga dari himpunan keadaan S dengan simbol input a otomat berhingga M_1 menuju ke himpunan keadaan, yang merupakan gabungan dari semua himpunan keadaan dari otomat hingga yang lama, ke yang mana otomat lama yang terbatas ini melewati simbol a dari setiap set negara bagian S . Jadi, otomat berhingga M_1 bersifat deterministik dengan konstruksi.

Deskripsi verbal di atas dapat diterjemahkan ke dalam rumus sebagai berikut: kami membangun mesin negara M_1 sehingga

M_1=(Q_1,V,\(q_0\),F_1,\delta_1), di mana

\begin(cases)Q_1=2^Q,\quad F_1=\(T\colon\, T\cap F\ne\varnothing,~T\in2^Q\),\\ (\forall S\subseteq Q) (\untuk semua\dalam V)\Bigl(\delta_1(S,a)= \bigcup\limits_(q\dalam S)\delta(q,a)\Bigr). \end(kasus)

Mari kita perhatikan fakta bahwa di antara keadaan otomat hingga yang baru ada keadaan \varnothing , dan, menurut (7.8), \delta_1(\varnothing,a)=\varnothing untuk setiap karakter input a . Ini berarti, sekali dalam keadaan seperti itu, mesin keadaan M_1 tidak akan meninggalkannya. Secara umum, setiap keadaan q dari otomat berhingga sedemikian rupa sehingga untuk setiap simbol input a yang kita miliki \delta(q,a)=q disebut keadaan penyerap dari otomat berhingga. Jadi, keadaan \tidak ada yang diserap oleh mesin keadaan deterministik M_1. Hal ini juga berguna untuk dicatat bahwa \delta_1(S,a)=\varnothing jika dan hanya jika untuk setiap q\dalam S (keadaan otomat berhingga lama dari himpunan keadaan S ) \delta(q,a)=\varnothing, yaitu dalam grafik M, setiap keadaan q seperti itu tidak meninggalkan busur yang ditandai dengan simbol a .

Dapat dibuktikan bahwa otomat hingga yang diperoleh dengan algoritma tersebut ekuivalen dengan yang asli.

Contoh 7.9. Kami menentukan otomat terbatas yang ditunjukkan pada Gambar. 7.14.

Sebuah robot finite ekivalen tanpa -transisi ditunjukkan pada gambar. 7.15. Perhatikan bahwa simpul q_2 menghilang, karena hanya busur "kosong" yang memasukinya.

Untuk menentukan otomat yang dihasilkan, sama sekali tidak perlu menuliskan semua status 2^3=8, banyak di antaranya mungkin tidak dapat dicapai dari status awal \(q_0\) . Untuk mendapatkan reachable dari status \(q_0\), dan hanya mereka, kami menggunakan apa yang disebut metode pull.

Metode ini dapat digambarkan dalam kasus umum sebagai berikut.

Dalam otomat terbatas asli (tanpa busur kosong), kami mendefinisikan semua set status yang dapat dijangkau dari yang awal, yaitu. untuk setiap karakter input a kita menemukan himpunan \delta(q_0,a) . Setiap set seperti itu di otomat baru adalah status yang dapat diakses langsung dari yang awal.

Untuk setiap himpunan keadaan S yang didefinisikan dan setiap simbol input a, kita temukan himpunannya \textstyle(\mathop(\bigcup\limits_(q\in S) \delta(q,a))\limits^(\phantom(A)^(.))). Semua status yang diperoleh pada langkah ini akan menjadi status dari otomat baru (deterministik), yang dapat dicapai dari simpul awal sepanjang jalur dengan panjang 2. Kami mengulangi prosedur yang dijelaskan hingga tidak ada set status baru (termasuk yang kosong) yang muncul. Dapat ditunjukkan bahwa dalam kasus ini semua keadaan seperti itu dari otomat hingga M_1 diperoleh yang dapat dicapai dari keadaan awal \(q_0\) .

Untuk mesin keadaan hingga pada Gambar. 7.15 kita memiliki:

\begin(aligned)& \delta_1(\(q_0\),a)=\(q_1\);\qquad \delta_1(\(q_0\),b)=\(q_1,q_3\);\\ & \ delta_1(\(q_1\),a)=\(q_1\);\qquad \delta_1(\(q_1\),b)=\(q_1\);\\ & \delta_1(\(q_1,q_3\) ,a)= \delta(q_1,a)\cup \delta(q_3,a)= \(q_1\)\cup\(q_1\)=\(q_1\);\\ & \delta_1(\(q_1, q_3\),b)= \delta(q_1,b)\cup \delta(q_3,b)= \(q_1\)\cup\(q_1\)=\(q_1\). \end(selaras)

Karena tidak ada lagi state-set baru, prosedur "menarik" berakhir di sini, dan kita mendapatkan grafik yang ditunjukkan pada Gambar. 7.16.

Pelengkap Bahasa Reguler

Salah satu konsekuensi teoritis penting dari teorema determinisasi adalah teorema berikut.

Teorema 7.8. Pelengkap bahasa reguler adalah bahasa reguler.

Biarkan L menjadi bahasa reguler dalam alfabet V . Maka pelengkap bahasa L (sebagai himpunan kata) adalah bahasa \overline(L)=V^(\ast)\setminus L.

Menurut Teorema 7.7, untuk bahasa reguler L, sebuah otomat hingga deterministik M dapat dibangun yang mengakui L . Karena dalam otomat deterministik dari setiap simpul, untuk setiap simbol input, transisi ke tepat satu simpul didefinisikan, maka, apa pun string x dalam alfabet V , ada jalur unik untuknya di M , mulai dari awal keadaan di mana string x dibaca. Jelas bahwa string x diizinkan oleh otomat M , yaitu x\in L(M) , jika dan hanya jika status terakhir dari jalur yang ditentukan adalah final. Ini menyiratkan bahwa rantai x\notin L(M) jika dan hanya jika status terakhir dari jalur yang ditentukan tidak final. Tapi kita hanya membutuhkan otomat terbatas M" , yang memungkinkan rantai x jika dan hanya jika otomat hingga M asli tidak. .

Teorema terbukti memungkinkan kita untuk membangun sebuah otomat hingga yang tidak memungkinkan satu set rantai tertentu dengan metode berikut: pertama, kami membangun sebuah otomat yang memungkinkan satu set rantai tertentu, kemudian kami menentukannya dan meneruskan ke otomat untuk pelengkap seperti yang ditunjukkan dalam bukti Teorema 7.8.

Contoh 7.10. sebuah. Mari kita buat otomat terbatas yang mengizinkan semua string dalam alfabet \(0;1\) kecuali string 101.

Pertama, kita membangun sebuah otomat terbatas yang memungkinkan rantai tunggal 101. Otomaton ini ditunjukkan pada gambar. 7.17.

Otomat ini adalah quasi-deterministik, tetapi tidak deterministik, karena tidak sepenuhnya didefinisikan. Mari kita tentukan dan dapatkan otomat hingga ekuivalen deterministik yang ditunjukkan pada Gambar. 7.18.

Dan akhirnya, beralih ke penambahan (dan mengganti nama status), kami mendapatkan otomat yang ditunjukkan pada Gambar. 7.19.

Perhatikan bahwa dalam otomaton yang dihasilkan, semua simpul, kecuali simpul s_3 , adalah final.

Perhatikan juga bahwa perjalanan ke komplemen, yang dibahas dalam pembuktian Teorema 7.8, hanya dapat dilakukan dalam otomat deterministik. Jika kita membalikkan peran simpul final dan non-final dalam otomat yang ditunjukkan pada Gambar. 7.17, kita akan mendapatkan otomat yang mengakui bahasa \(\lambda,1,10\) , yang bukan - seperti yang mudah dilihat - himpunan semua string selain string 101.

Perhatikan juga bahwa mesin keadaan terbatas pada Gambar. 7.19 mengizinkan semua string yang berisi kemunculan string 101 tetapi tidak cocok dengan string itu sendiri. Di sini, misalnya, adalah jalur yang membawa rantai 1011: s_0,s_1,s_2,s_3,t.

b. Mari kita membangun sebuah robot berhingga yang mengizinkan semua string dalam alfabet \(0;1\) , kecuali yang berisi kemunculan string 101. Pertimbangkan bahasa L , setiap string berisi kemunculan string 101. Ini dapat didefinisikan sebagai berikut:

L=(0+1)^(\ast)101(0+1)^(\ast).

Kita perlu membangun sebuah robot untuk melengkapi bahasa L.

Langsung dari ekspresi reguler dalam kasus ini, mudah untuk membangun sebuah robot hingga yang memungkinkan bahasa L (Gbr. 7.20).

Kemudian, dengan metode "menarik", kami akan melakukan penentuan. Hasil penentuan ditunjukkan pada gambar. 7.21.

Untuk solusi lengkap dari masalah, hanya Gambar. 7.21 menukar peran simpul final dan non-final (Gbr. 7.22).

di. Mari kita bahas ide membangun otomat berhingga yang memungkinkan string tersebut dan hanya string dalam alfabet \(0;1\) yang tidak dimulai dengan string 01 dan tidak diakhiri dengan string 11 (yaitu string dari bentuk 01x dan string bentuk y11 tidak diperbolehkan, apa pun yang ada rantai x,y\in\(0;1\) ).

Dalam hal ini, pelengkap dari bahasa yang ingin Anda buat otomat hingga adalah himpunan semua string nol dan yang dimulai dengan string 01 atau diakhiri dengan string 11. Sebuah robot yang menerima set string ini dibangun sebagai robot untuk menggabungkan 01(0+1)^(\ast)+(0+1)^(\ast)11 dengan cara yang sama seperti dalam pembuktian teorema Kleene (lihat Teorema 7.6).

Properti kelas bahasa reguler ditutup di bawah komplemen (lihat Teorema 7.8) segera menyiratkan bahwa kelas ini ditutup di bawah persimpangan, set-teoritis dan perbedaan simetris.

Akibat wajar 7.3. Untuk dua bahasa reguler apa pun L_1 dan L_2, pernyataan berikut ini benar:

1) perpotongan L_1\cap L_2 beraturan;
2) perbedaan L_1\setminus L_2 adalah biasa;
3) perbedaan simetris L_1\variangle L_2 reguler.

Keabsahan pernyataan berikut dari identitas:

\begin(aligned) &(\scriptstyle(\mathsf(1))))\quad L_1\cap L_2= \overline(\overline(L_1) \cup\overline(L_2))\,;\\ &(\scriptstyle (\mathsf(2))))\quad L_1\setminus L_2= L_1\cap \overline(L_2)\,;\\ &(\scriptstyle(\mathsf(3))))\quad L_1\,\triangle\ ,L_2 = (L_1\cup L_2)\setminus (L_1\cap L_2).\end(selaras)

Pertama, hasil yang diperoleh memungkinkan kita untuk menyatakan bahwa kelas bahasa reguler sehubungan dengan operasi persatuan, persimpangan, dan penambahan adalah aljabar Boolean, di mana satuannya adalah bahasa universal, dan nol adalah bahasa kosong. . Kedua, sifat aljabar dari keluarga bahasa reguler ini memungkinkan kita untuk memecahkan masalah penting dalam mengenali kesetaraan dua automata terbatas yang sewenang-wenang.

Menurut Definisi 7.10, finite automata setara jika bahasa yang mereka izinkan sama. Oleh karena itu, untuk memverifikasi kesetaraan automata M_1 dan M_2 , cukup untuk membuktikan bahwa perbedaan simetris bahasa L(M_1) dan L(M_2) kosong. Untuk melakukan ini, pada gilirannya, cukup untuk membangun sebuah otomat yang mengakui perbedaan ini dan memverifikasi bahwa bahasa yang diakuinya kosong. Secara umum, masalah mengenali bahasa mesin keadaan kosong disebut masalah kekosongan mesin keadaan. Untuk mengatasi masalah ini, cukup mencari himpunan keadaan akhir dari otomat yang dapat dicapai dari keadaan awal. Karena finite state machine adalah graf berarah, masalah ini dapat diselesaikan, misalnya, menggunakan pencarian luas-pertama. Bahasa yang diperbolehkan oleh finite automaton kosong jika dan hanya jika himpunan status akhir yang dapat dicapai dari status awal kosong. Dalam praktiknya, lebih disukai untuk mengenali ekivalensi automata berhingga menggunakan algoritme minimisasi, tetapi sekarang penting bagi kita untuk menekankan bahwa kemungkinan mendasar untuk menyelesaikan masalah ekivalensi mengikuti Teorema 7.7 dan konsekuensi aljabarnya.