Bagaimana cara membuat DFA dari ekspresi reguler tanpa menggunakan NFA?

12

Tujuannya adalah membuat DFA dari ekspresi reguler dan menggunakan "Exp reguler> NFA> Konversi DFA" bukan opsi. Bagaimana seharusnya orang melakukan itu?

Saya mengajukan pertanyaan ini kepada profesor kami tetapi dia mengatakan kepada kami bahwa kami dapat menggunakan intuisi dan dengan baik hati menolak untuk memberikan penjelasan. Jadi saya ingin bertanya kepada Anda.

"Exp reguler> NFA> Konversi DFA" bukan opsi karena konversi seperti itu membutuhkan banyak waktu untuk mengonversi ekspresi reguler yang agak rumit. Misalnya, untuk regex tertentu "regex> NFA> DFA" membutuhkan waktu 1 jam untuk manusia. Saya perlu mengonversi regex ke DFA dalam waktu kurang dari 30 menit.

— Raphael
sumber

2

Anda perlu memberikan lebih banyak konteks. Algoritma (informal) apa yang saat ini Anda gunakan untuk menerjemahkan ekspresi reguler? Mungkin bermanfaat untuk menjelaskan proses Anda dengan contoh seperti a(a|ab|ac)*a+. Anda bisa langsung menerjemahkannya ke NDFA yang Anda kurangi menjadi DFA, atau Anda bisa menormalkannya menjadi sesuatu yang segera dipetakan ke DFA.

— amon

Apakah Anda harus melakukannya pada contoh spesifik dengan cara apa pun, atau apakah Anda harus memberikan prosedur umum. Untuk diterapkan oleh komputer?

— babou

18

Karena Anda ingin "mengubah regex menjadi DFA dalam waktu kurang dari 30 menit", saya kira Anda bekerja dengan tangan pada contoh yang relatif kecil.

Dalam hal ini Anda dapat menggunakan algoritma Brzozowski , yang menghitung secara langsung otomat Nerode dari suatu bahasa (yang diketahui sama dengan otomat deterministik minimalnya). Ini didasarkan pada perhitungan langsung dari derivatif dan juga berfungsi untuk ekspresi reguler yang diperpanjang yang memungkinkan persimpangan dan komplementasi. Kelemahan dari algoritma ini adalah bahwa ia perlu memeriksa ekuivalensi ekspresi yang dihitung sepanjang jalan, proses yang mahal. Tetapi dalam praktiknya, dan untuk contoh kecil, ini sangat efisien. $[1]$

Quotients kiri . Biarkan menjadi bahasa dan biarkan menjadi kata. Kemudian Bahasa disebut quotient kiri (atau kiri turunan ) dari . $L$ $A^*$ $u$

u^{- 1} L = {v \in A^{*} ∣ u v \in L}

$u^{-1}L = \{v \in A^* \mid uv \in L \}$

u^{- 1} L

$u^{-1}L$

L

$L$

Otomat Nerode . The Nerode otomat dari adalah deterministik otomat di mana , dan fungsi transisi didefinisikan, untuk setiap , dengan rumus Waspadai definisi yang agak abstrak ini. Setiap status adalah hasil bagi kiri dari per kata, dan karenanya adalah bahasa . Keadaan awal adalah bahasa , dan himpunan menyatakan akhir adalah himpunan semua quotients kiri $L$ $\mathcal{A}(L) = (Q, A, \cdot, L, F)$ $Q = \{u^{-1}L \mid u \in A^*\}$ $F = \{u^{-1}L \mid u \in L\}$ $a \in A$

(u^{- 1} L) \cdot a = a^{- 1} (u^{- 1} L) = (u a)^{- 1} L

$(u^{-1}L)\cdot a = a^{-1}(u^{-1}L)=(ua)^{-1}L$

A

$\mathcal{A}$

L

$L$

A^{*}

$A^*$

L

$L$

L

$L$ oleh firman .

L

$L$

Algoritma Brzozowski . Biarkan menjadi huruf. Seseorang dapat menghitung quotients kiri menggunakan rumus berikut: $a, b$

\begin{aligned} a^{- 1} 1 & = 0 & a^{- 1} b & = {\begin{cases} 1 & if a = b \\ 0 & if a \neq b \end{cases} \\ a^{- 1} (L_{1} \cup L_{2}) & = a^{- 1} L_{1} \cup u^{- 1} L_{2}, & a^{- 1} (L_{1} ∖ L_{2}) & = a^{- 1} L_{1} ∖ u^{- 1} L_{2}, \\ a^{- 1} (L_{1} \cap L_{2}) & = a^{- 1} L_{1} \cap u^{- 1} L_{2}, & a^{- 1} L^{*} & = (a^{- 1} L) L^{*} \end{aligned}

$\begin{align*} a^{-1}1 &= 0 & a^{-1}b &= \begin{cases} 1 &\text{if $a = b$}\\ 0 &\text{if $a \not= b$}\\ \end{cases}\\ a^{-1}(L_1 \cup L_2) &= a^{-1}L_1 \cup u^{-1}L_2,& a^{-1}(L_1 \setminus L_2) &= a^{-1}L_1 \setminus u^{-1}L_2,\\ a^{-1}(L_1 \cap L_2) &= a^{-1}L_1 \cap u^{-1}L_2, & a^{-1}L^* &= (a^{-1}L)L^* \end{align*}$

\begin{aligned} a^{- 1} (L_{1} L_{2}) & = {\begin{cases} (a^{- 1} L_{1}) L_{2} & si 1 \notin L_{1}, \\ (a^{- 1} L_{1}) L_{2} \cup a^{- 1} L_{2} & si 1 \in L_{1} \end{cases} \end{aligned}

$\begin{align*} a^{-1}(L_1L_2) &= \begin{cases} (a^{-1}L_1)L_2 &\text{si $1 \notin L_1$,}\\ (a^{-1}L_1)L_2 \cup a^{-1}L_2 &\text{si $1 \in L_1$}\\ \end{cases}\\ %\\v^{-1}(u^{-1}L) &= (uv)^{-1}L. \end{align*}$

Contoh . Untuk , kami mendapatkan berturut-turut: yang memberikan otomat minimal berikut. $L = (a(ab)^*)^* \cup (ba)^*$

\begin{aligned} 1^{- 1} L & = L = L_{1} \\ a^{- 1} L_{1} & = (a b)^{*} (a (a b)^{*})^{*} = L_{2} \\ b^{- 1} L_{1} & = a (b a)^{*} = L_{3} \\ a^{- 1} L_{2} & = b (a b)^{*} (a (a b)^{*})^{*} \cup (a b)^{*} (a (a b)^{*})^{*} = b L_{2} \cup L_{2} = L_{4} \\ b^{- 1} L_{2} & = \emptyset \\ a^{- 1} L_{3} & = (b a)^{*} = L_{5} \\ b^{- 1} L_{3} & = \emptyset \\ a^{- 1} L_{4} & = a^{- 1} (b L_{2} \cup L_{2}) = a^{- 1} L_{2} = L_{4} \\ b^{- 1} L_{4} & = b^{- 1} (b L_{2} \cup L_{2}) = L_{2} \cup b^{- 1} L_{2} = L_{2} \\ a^{- 1} L_{5} & = \emptyset \\ b^{- 1} L_{5} & = a (b a)^{*} = L_{3} \end{aligned}

$\begin{align*} 1^{-1}L &= L=L_1\\ a^{-1}L_1 &=(ab)^*(a(ab)^*)^*=L_2\\ b^{-1}L_1 &= a(ba)^*=L_3\\ a^{-1}L_2 &= b(ab)^*(a(ab)^*)^* \cup (ab)^*(a(ab)^*)^*=bL_2 \cup L_2=L_4\\ b^{-1}L_2 &=\emptyset \\ a^{-1}L_3 &=(ba)^*=L_5\\ b^{-1}L_3 &=\emptyset \\ a^{-1}L_4 &= a^{-1}(bL_2 \cup L_2)=a^{-1}L_2=L_4 \\ b^{-1}L_4 &= b^{-1}(bL_2 \cup L_2)= L_2\cup b^{-1}L_2 = L_2 \\ a^{-1}L_5 &= \emptyset\\ b^{-1}L_5 &=a(ba)^*=L_3 \end{align*}$ Otomat minimal

$[1]$ J. Brzozowski, Derivatif Ekspresi Reguler, J.ACM 11 (4), 481–494, 1964.

Edit . (5 April 2015) Saya baru saja menemukan bahwa pertanyaan serupa: Algoritma apa yang ada untuk konstruksi DFA yang mengenali bahasa yang dijelaskan oleh regex yang diberikan? diminta pada cstheory. Jawabannya sebagian membahas masalah kompleksitas.

— J.-E. Pin
sumber

Bisakah Anda mengatakan lebih banyak tentang kompleksitas algoritma ini?

— babou

@ baou Mengubah RE menjadi DFA adalah PSPACE-hard, jadi pasti eksponensial.

— jmite

Ini mungkin harus masuk ke jawabannya. OP dimulai dengan "konstruksi standar melalui NFA terlalu lambat" dan bagian dari jawabannya tampaknya "sial, sebenarnya tidak ada solusi cepat". Masih membahas apakah ini di sini lebih baik daripada konstruksi standar. (cc @jmite)

— Raphael

@iteite Ya saya mengharapkan itu. Alasan pertanyaan saya adalah mengapa cara membangun DFA ini harus dianggap lebih mudah. (catatan: sistem membutuhkan waktu sehari penuh untuk memberi tahu saya tentang jawaban @ jmite).

— babou

2

J.-E. Pin memberikan jawaban yang lebih baik dalam hal formalitas dan kelengkapan, tetapi saya pikir ada sesuatu yang bisa dikatakan untuk "intuisi" yang disindir profesor Anda.

Dalam sebagian besar kasus ini, hal yang paling mudah untuk dilakukan adalah melihat ekspresi reguler, memahami bahasa apa yang diterimanya, kemudian gunakan kreativitas / kepintaran Anda untuk membangun DFA yang menerima bahasa itu.

Tidak ada cara langsung untuk melakukan ini, selain algoritma yang diberikan orang lain, tetapi berikut adalah beberapa panduan yang mungkin terbukti bermanfaat.

Tanyakan kepada diri sendiri, dapatkah saya menulis sebuah program yang menerima RE ini hanya menggunakan variabel boolean atau variabel integer yang sangat kecil? Kemudian tulis program itu, dan konversikan menjadi DFA di mana ada keadaan untuk setiap kombinasi nilai.
Cari bagian dari ekspresi reguler yang Anda tahu dapat Anda terima secara deterministik, di mana Anda tahu "Jika saya melihat ini, maka saya harus mencocokkan bagian RE ini." Tidak akan selalu ada banyak ini, tetapi mengidentifikasi bagian-bagian ini dapat menunjukkan bagian-bagian yang akan mudah untuk membuat DFA, sehingga Anda dapat menghabiskan lebih banyak waktu pada bagian-bagian yang benar-benar membutuhkan non-determinisme.
Konstruksi subset untuk NFA-> DFA sebenarnya tidak rumit dari suatu algoritma. Jadi jika ini adalah tugas, bukan pertanyaan ujian, mungkin lebih cepat untuk hanya membuat kode implementasi, dan biarkan program Anda mengonversi NFA ke DFA. Jika Anda menggunakan kode Anda sendiri, seharusnya tidak ada masalah plagarisme.

Ingat bahwa apa pun yang Anda lakukan, teknik apa pun akan meledak secara eksponensial dalam kasus terburuk (kecuali jika Anda menemukan algoritma polinomial untuk ini, dalam hal ini, selamat, Anda telah membuktikan dan Anda sekarang menjadi jutawan .) $P=NP=PSPACE$

Cobalah untuk "melihat ke depan," memotong sudut ketika Anda dapat menggunakan intuisi Anda di tempat-tempat ketika algoritma akan membutuhkan banyak langkah tetapi hasilnya jelas.

— Ya ampun
sumber

-2

Meskipun ini bukan cara yang benar tetapi itu berfungsi sebagian besar waktu.

Langkah Pertama : Temukan string terkecil yang dapat diterima oleh Ekspresi Reguler. Langkah Kedua : Gambarkan status yang diperlukan dengan transaksi mesin penerima string minimum. Langkah Ketiga : Untuk semua negara bagian, tarik transaksi alfabet yang tersisa.

Sebagai Contoh: Ekspresi Reguler (0 +1) * 1 "String yang diakhiri dengan 1" Langkah 1: String Terkecil: 1 Langkah 2: dua status Q0 dan Q1. memiliki transaksi 1 dari Q0 ke Q1. dan Q1 adalah negara penerima. Langkah 3: untuk Q0 Negara Q0 1 transaksi adalah ke Q1. Sekarang lakukan 0 transaksi di Q0 itu sendiri. Untuk Negara Q1 Q1 1 transaksi akan tetap di Q1. Dan 0 transaksi akan masuk Q0.

— Naveen CS
sumber