Mengubah ekspresi reguler menjadi (minimal) NFA yang menerima bahasa yang sama adalah mudah dengan algoritma standar, misalnya algoritma Thompson . Namun, arah yang lain tampaknya lebih membosankan, dan terkadang ekspresi yang dihasilkannya berantakan.

Algoritma apa yang ada untuk mengubah NFA menjadi ekspresi reguler yang setara? Apakah ada keuntungan terkait kompleksitas waktu atau ukuran hasil?

^{Ini seharusnya menjadi pertanyaan referensi. Harap sertakan uraian umum tentang metode Anda serta contoh yang tidak sepele.}

Ada beberapa metode untuk melakukan konversi dari automata terbatas ke ekspresi reguler. Di sini saya akan menjelaskan yang biasanya diajarkan di sekolah yang sangat visual. Saya percaya ini adalah yang paling banyak digunakan dalam praktik. Namun, menulis algoritme bukanlah ide yang bagus.

Metode penghapusan negara

Algoritma ini adalah tentang penanganan grafik automaton dan oleh karena itu sangat tidak cocok untuk algoritma karena perlu grafik primitif seperti ... penghapusan negara. Saya akan menggambarkannya menggunakan primitif tingkat tinggi.

Ide kuncinya

Idenya adalah untuk mempertimbangkan ekspresi reguler pada tepian dan kemudian menghapus negara perantara sambil menjaga label tepi konsisten.

Pola utama dapat dilihat pada gambar di bawah ini. Yang pertama memiliki label antara yang merupakan ekspresi reguler dan kami ingin menghapus .e , f , g , h , i $p,q,r$$e,f,g,h,i$$q$

Setelah dihapus, kami menyusun bersamaan (sambil mempertahankan tepi lainnya antara dan tetapi ini tidak ditampilkan pada ini):p $e,f,g,h,i$$p$$r$

Contoh

Menggunakan contoh yang sama seperti dalam jawaban Raphael :

kami berhasil menghapus :$q_2$

lalu :$q_3$

maka kita masih harus menerapkan bintang pada ekspresi dari hingga . Dalam hal ini, keadaan akhir juga awal sehingga kita benar-benar hanya perlu menambahkan bintang:q $q_1$$q_1$

Algoritma

L[i,j]adalah regexp dari bahasa dari ke . Pertama, kami menghapus semua multi-edge:q $q_i$$q_j$

for i = 1 to n:
  for j = 1 to n:
    if i == j then:
      L[i,j] := ε
    else:
      L[i,j] := ∅
    for a in Σ:
      if trans(i, a, j):
        L[i,j] := L[i,j] + a

Sekarang, penghapusan status. Misalkan kita ingin menghapus status :$q_k$

remove(k):
  for i = 1 to n:
    for j = 1 to n:
      L[i,i] += L[i,k] . star(L[k,k]) . L[k,i]
      L[j,j] += L[j,k] . star(L[k,k]) . L[k,j]
      L[i,j] += L[i,k] . star(L[k,k]) . L[k,j]
      L[j,i] += L[j,k] . star(L[k,k]) . L[k,i]

Perhatikan bahwa kedua dengan pensil kertas dan dengan algoritma Anda harus menyederhanakan ekspresi seperti star(ε)=ε, e.ε=e, ∅+e=e, ∅.e=∅(Dengan tangan Anda hanya tidak menulis tepi ketika itu tidak , atau bahkan untuk diri loop dan Anda mengabaikan ketika ada tidak ada transisi antara dan atau dan )$∅$q j q $ε$q $q_i$$q_k$$q_j$$q_k$

Sekarang, bagaimana cara menggunakannya remove(k)? Anda tidak boleh menghapus status akhir atau awal dengan ringan, jika tidak, Anda akan kehilangan bagian bahasa.

for i = 1 to n:
  if not(final(i)) and not(initial(i)):
    remove(i)

Jika Anda hanya memiliki satu status akhir dan satu status awal maka ekspresi terakhirnya adalah:q $q_f$$q_s$

e := star(L[s,s]) . L[s,f] . star(L[f,s] . star(L[s,s]) . L[s,f] + L[f,f])

Jika Anda memiliki beberapa keadaan akhir (atau bahkan keadaan awal) maka tidak ada cara sederhana untuk menggabungkan yang ini, selain menerapkan metode penutupan transitif. Biasanya ini bukan masalah dengan tangan tetapi ini aneh ketika menulis algoritma. Solusi yang jauh lebih sederhana adalah menghitung semua pasangan dan menjalankan algoritma pada grafik (sudah dihapus) untuk mendapatkan semua ekspresi seandainya adalah satu-satunya keadaan awal dan adalah satu-satunya final nyatakan, lalu lakukan penyatuan semua .e s , f s f e s , $(s,f)$$e_{s,f}$$s$$f$$e_{s,f}$

Ini, dan fakta bahwa ini memodifikasi bahasa lebih dinamis daripada metode pertama membuatnya lebih rentan kesalahan saat pemrograman. Saya sarankan menggunakan metode lain.

Cons

Ada banyak kasus dalam algoritme ini, misalnya untuk memilih simpul mana yang harus kita hapus, jumlah keadaan akhir di akhir, fakta bahwa keadaan akhir dapat menjadi awal, juga dll.

Perhatikan bahwa sekarang setelah algoritme ditulis, ini sangat mirip dengan metode penutupan transitif. Hanya konteks penggunaannya yang berbeda. Saya tidak merekomendasikan menerapkan algoritma, tetapi menggunakan metode untuk melakukannya dengan tangan adalah ide yang bagus.

metode

Metode terbaik yang saya lihat adalah metode yang mengekspresikan otomat sebagai sistem persamaan bahasa (reguler) yang dapat diselesaikan. Ini khususnya bagus karena tampaknya menghasilkan ekspresi yang lebih ringkas daripada metode lain.

Biarkan sebuah NFA tanpa -transisi. Untuk setiap keadaan , buat persamaannya$A= (Q,\Sigma,\delta,q_0,F)$$\varepsilon$$q_i$

$\qquad \displaystyle Q_i = \bigcup\limits_{q_i \overset{a}{\to} q_j} aQ_j \cup \begin{cases} \{\varepsilon\} &,\ q_i \in F \\ \emptyset &, \text{ else}\end{cases}$

di mana adalah himpunan status akhir dan berarti ada transisi dari ke dengan label . Jika Anda membaca sebagai atau (tergantung pada definisi ekspresi reguler Anda), Anda melihat bahwa ini adalah persamaan dari ekspresi reguler.$F$$q_i \overset{a}{\to} q_j$$q_i$$q_j$$a$$\cup$$+$$\mid$

Untuk menyelesaikan sistem, Anda memerlukan asosiatif dan distribusi dari dan (penggabungan string), komutatifitas dan Arden's Lemma ¹:$\cup$$\cdot$$\cup$

Biarkan bahasa reguler dengan . Kemudian,$L,U,V \subseteq \Sigma^*$$\varepsilon \notin U$

$\qquad \displaystyle L = UL \cup V \quad \Longleftrightarrow \quad L = U^*V$

Solusinya adalah seperangkat ekspresi reguler , satu untuk setiap negara . menguraikan dengan tepat kata-kata yang dapat diterima oleh ketika dimulai pada ; oleh karena itu (jika adalah kondisi awal) adalah ekspresi yang diinginkan.$Q_i$$q_i$$Q_i$$A$$q_i$$Q_0$$q_0$

Contoh

^{Demi kejelasan, kami menunjukkan set singleton oleh elemen mereka, yaitu . Contohnya adalah karena Georg Zetzsche.$a = \{a\}$}

Pertimbangkan NFA ini:

^{[ sumber ]}

Sistem persamaan yang sesuai adalah:

$\qquad \begin{align} Q_0 &= aQ_1 \cup bQ_2 \cup \varepsilon \\ Q_1 &= bQ_0 \cup aQ_2 \\ Q_2 &= aQ_0 \cup bQ_1 \end{align}$

Sekarang hubungkan persamaan ketiga ke persamaan kedua:

$\qquad \begin{align} Q_1 &= bQ_0 \cup a(aQ_0 \cup bQ_1) \\ &= abQ_1 \cup (b \cup aa)Q_0 \\ &= (ab)^*(b \cup aa)Q_0 \end{align}$

Untuk langkah terakhir, kami menerapkan Arden's Lemma dengan , dan . Perhatikan bahwa ketiga bahasa adalah reguler dan , memungkinkan kami untuk menerapkan lemma. Sekarang kita hubungkan hasil ini ke dalam persamaan pertama:$L = Q_1$$U = ab$$V = (b \cup aa) \cdot Q_0$$\varepsilon \notin U = \{ab\}$

$\qquad \begin{align} Q_0 &= a(ab)^*(b \cup aa)Q_0 \cup baQ_0 \cup bb(ab)^*(b \cup aa)Q_0 \cup \varepsilon \\ &= ((a \cup bb)(ab)^*(b \cup aa) \cup ba)Q_0 \cup \varepsilon \\ &= ((a \cup bb)(ab)^*(b \cup aa) \cup ba)^* \qquad \text{(by Arden's Lemma)} \end{align}$

Dengan demikian, kami telah menemukan ekspresi reguler untuk bahasa yang diterima oleh robot di atas, yaitu

$\qquad \displaystyle ((a + bb)(ab)^*(b + aa) + ba)^*.$

Perhatikan bahwa ini cukup ringkas (bandingkan dengan hasil metode lain) tetapi tidak ditentukan secara unik; memecahkan sistem persamaan dengan urutan manipulasi yang berbeda mengarah ke yang lain - setara! - ekspresi.

1. Untuk bukti Lemma Arden, lihat di sini .

Metode aljabar Brzozowski

Ini adalah metode yang sama dengan yang dijelaskan dalam jawaban Raphael , tetapi dari sudut pandang algoritma sistematis, dan kemudian, memang, algoritma tersebut. Ternyata menjadi mudah dan alami untuk diterapkan setelah Anda tahu harus mulai dari mana. Juga mungkin lebih mudah dengan tangan jika menggambar semua automata tidak praktis untuk beberapa alasan.

Saat menulis sebuah algoritma Anda harus ingat bahwa persamaan harus selalu linier sehingga Anda memiliki representasi abstrak yang baik dari persamaan, hal yang dapat Anda lupakan ketika Anda menyelesaikan dengan tangan.

Gagasan algoritma

Saya tidak akan menjelaskan cara kerjanya karena dilakukan dengan baik dalam jawaban Raphael yang saya sarankan untuk dibaca sebelumnya. Sebagai gantinya, saya fokus pada urutan mana Anda harus menyelesaikan persamaan tanpa melakukan terlalu banyak perhitungan ekstra atau kasus ekstra.

Mulai dari solusi cerdas peraturan Arden ke persamaan bahasa kita dapat mempertimbangkan otomat sebagai seperangkat persamaan bentuk:$X=A^*B$$X=AX∪B$

kita dapat menyelesaikan ini dengan induksi pada dengan memperbarui array dan sesuai. Pada langkah , kita memiliki:$n$$A_{i,j}$$B_{i,j}$$n$

dan aturan Arden memberi kita:

dan dengan mengatur dan kita dapatkan:$B'_n = A_{n,n}^* B_n$$A'_{n,i}=A_{n,n}^*A_{n,i}$

dan kita kemudian dapat menghapus semua kebutuhan dalam sistem dengan mengatur, untuk :$X_n$$i,j<n$

Ketika kami telah menyelesaikan ketika , kami memperoleh persamaan seperti ini:$X_n$$n=1$

tanpa . Jadi kami mendapatkan ekspresi reguler kami.$A'_{1,i}$

Algoritma

Berkat ini, kami dapat membangun algoritme. Untuk memiliki konvensi yang sama dari pada induksi di atas, kita akan mengatakan bahwa keadaan awal adalah dan bahwa jumlah keadaan adalah . Pertama, inisialisasi untuk mengisi :$q_1$$m$$B$

for i = 1 to m:
  if final(i):
    B[i] := ε
  else:
    B[i] := ∅

dan :$A$

for i = 1 to m:
  for j = 1 to m:
    for a in Σ:
      if trans(i, a, j):
        A[i,j] := a
      else:
        A[i,j] := ∅

dan kemudian solusinya:

for n = m decreasing to 1:
  B[n] := star(A[n,n]) . B[n]
  for j = 1 to n:
    A[n,j] := star(A[n,n]) . A[n,j];
  for i = 1 to n:
    B[i] += A[i,n] . B[n]
    for j = 1 to n:
      A[i,j] += A[i,n] . A[n,j]

ekspresi terakhirnya adalah:

e := B[1]

Penerapan

Bahkan jika itu mungkin tampak suatu sistem persamaan yang tampaknya terlalu simbolis untuk suatu algoritma, yang satu ini sangat cocok untuk suatu implementasi. Berikut ini adalah implementasi dari algoritma ini di Ocaml (broken link) . Perhatikan bahwa selain fungsi brzozowski, semuanya untuk dicetak atau digunakan untuk contoh Raphael. Perhatikan bahwa ada fungsi penyederhanaan ekspresi reguler yang sangat efisien simple_re.

Metode penutupan transitif

Metode ini mudah ditulis dalam bentuk algoritme, tetapi menghasilkan ekspresi reguler besar yang tidak masuk akal dan tidak praktis jika Anda melakukannya dengan tangan, terutama karena ini terlalu sistematis. Ini adalah solusi yang baik dan sederhana untuk suatu algoritma.

Ide kuncinya

Biarkan mewakili ekspresi reguler untuk string dari ke menggunakan status . Biarkan menjadi jumlah status otomat.$R^k_{i,j}$$q_i$$q_j$$\{q_1, …, q_k\}$$n$

Misalkan Anda sudah tahu ekspresi reguler dari ke tanpa status perantara (kecuali untuk ekstremitas), untuk semua . Maka Anda dapat menebak bagaimana menambahkan status lain akan memengaruhi ekspresi reguler baru : ia hanya berubah jika Anda memiliki transisi langsung ke , dan itu dapat diekspresikan seperti itu:$R_{i,j}$$q_i$$q_j$$q_k$$i,j$$R'_{i,j}$$q_k$

( adalah dan adalah .)$R$$R^{k-1}$$R'$$R^k$

Contoh

Kami akan menggunakan contoh yang sama seperti dalam jawaban Raphael . Pada awalnya, Anda hanya dapat menggunakan transisi langsung.

Inilah langkah pertama (perhatikan bahwa loop otomatis dengan label akan mengubah pertama menjadi .$a$$ε$$(ε+a)$

Pada langkah kedua kita dapat menggunakan (yang diubah namanya menjadi untuk kita, karena sudah digunakan untuk tujuan di atas). Kita akan melihat bagaimana bekerja.$q_0$$q_1$$R^0$$R^1$

Dari ke : .$q_2$$q_2$$R^1_{2,2} = R^0_{2,2} + R^0_{2,1} {R^0_{1,1}}^* R^0_{1,2} = ε + b ε^* a = ε + ba$

Mengapa demikian? Itu karena pergi dari ke hanya menggunakan sebagai keadaan peralihan dapat dilakukan dengan tetap di sini ( ) atau pergi ke ( ), berputar-putar di sana ( ) dan kembali ( ).$q_2$$q_2$$q_1$$ε$$q_1$$a$$ε^*$$b$

Anda dapat menghitung seperti itu dan juga, dan akan memberi Anda ekspresi akhir karena adalah awal dan akhir. Perhatikan bahwa banyak penyederhanaan ekspresi telah dilakukan di sini. Jika tidak pertama dari akan dan yang pertama dari akan menjadi .$R^2$$R^3$$R^3_{1,1}$$1$$a$$R^0$$(∅+a)$$a$$R^1$$((∅+a)+ε(ε)^*a)$

Algoritma

Inisialisasi:

for i = 1 to n:
  for j = 1 to n:
    if i == j:
      R[i,j,0] := ε
    else:
      R[i,j,0] := ∅
    for a in Σ:
      if trans(i, a, j):
        R[i,j,0] := R[i,j,0] + a

Penutupan transitif:

for k = 1 to n:
  for i = 1 to n:
    for j = 1 to n:
      R[i,j,k] := R[i,j,k-1] + R[i,k,k-1] . star(R[k,k,k-1]) . R(k,j,k-1)

Kemudian ekspresi terakhirnya adalah (seandainya adalah keadaan awal):$q_s$

e := ∅
for i = 1 to n:
  if final(i):
    e := e + R[s,i,n]

Tapi Anda bisa bayangkan itu menghasilkan ekspresi reguler jelek. Anda memang dapat mengharapkan hal-hal seperti yang mewakili bahasa yang sama dengan . Perhatikan bahwa menyederhanakan ekspresi reguler berguna dalam praktiknya.a $(∅)^*+(a+(∅)^*)(ε)^*(a + ∅)$$aa$