Düzenli ifadeleri aynı dili kabul eden (en az) NFA'ya dönüştürmek standart algoritmalar ile kolaydır, örneğin Thompson algoritması . Diğer yön daha sıkıcı görünüyor, ancak bazen ortaya çıkan ifadeler dağınık.

NFA'yı eşdeğer normal ifadelere dönüştürmek için hangi algoritmalar var? Zaman karmaşıklığı veya sonuç büyüklüğü ile ilgili avantajlar var mı?

^{Bunun bir referans sorusu olması gerekiyordu. Lütfen yönteminizin genel bir tanımını ve önemsiz olmayan bir örneği ekleyin.}

Sonlu otomatlardan normal ifadelere dönüşüm yapmak için birkaç yöntem vardır. Burada genelde okulda öğretilen, çok görsel olanı anlatacağım. Uygulamada en çok kullanılan olduğuna inanıyorum. Ancak, algoritmayı yazmak o kadar da iyi bir fikir değil.

Devlet kaldırma yöntemi

Bu algoritma, otomatın grafiğini kullanmakla ilgilidir ve bu nedenle ... durum kaldırma gibi grafik ilkellerine ihtiyaç duyduğundan algoritmalar için çok uygun değildir. Bunu daha yüksek seviyeli ilkel kullanarak tarif edeceğim.

Anahtar fikir

Buradaki fikir, kenarlardaki etiketleri tutarlı tutarken, kenarlarda düzenli ifadeleri düşünmek ve ardından ara durumları kaldırmaktır.

Ana desen, aşağıdaki şekillerde görülebilir. İlki arasında normal ifadeler olan e , f , g , h , i etiketlerine sahip ve q ' yu kaldırmak istiyoruz .$p,q,r$$e,f,g,h,i$$q$

Kaldırıldıktan sonra, birlikte oluştururuz ( p ve r arasındaki diğer kenarları korurken ancak bu gösterilmez):$e,f,g,h,i$$p$$r$

Örnek

Raphael'in cevabındakiyle aynı örneği kullanarak :

art arda kaldırıyoruz :$q_2$

ve :$q_3$

Sonra biz hala gelen ifadeye Yıldız eklemek zorunda ile q 1 . Bu durumda, son durum da başlangıçta olduğundan gerçekten bir yıldız eklememiz gerekiyor:$q_1$$q_1$

Algoritma

L[i,j], dilin düzenli ifadesi olan için q, j . İlk önce tüm çoklu kenarları kaldırıyoruz:$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

Şimdi, devlet kaldırma. Biz devlet kaldırmak istediğinizi varsayalım :$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]

star(ε)=εe.ε=e∅+e=e∅.e=∅$∅$$ε$$q_i$$q_k$$q_j$$q_k$

Şimdi nasıl kullanılır remove(k)? Son halleri veya ilk halleri hafifçe silmemelisiniz, aksi halde dilin bölümlerini özleyeceksiniz.

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

Yalnızca bir son durum ve bir başlangıç ​​durum o zaman son ifade şöyledir:$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])

Birkaç son durumunuz (veya hatta ilk durumlarınız) varsa, geçişli kapatma yöntemini uygulamaktan başka, bunları birleştirmenin basit bir yolu yoktur. Genellikle bu elle elde edilen bir problem değildir ancak algoritmayı yazarken bu oldukça zordur. Daha basit bir çözüm tüm çiftleri numaralandırmak için ve tüm ifadeler, elde etmek için (daha önce devlet kaldırıldı) grafikte algoritması çalıştırmak varsayılarak , sadece ilk durumu ve nihai sadece Devlet, sonra tüm yapıyorum .$(s,f)$$e_{s,f}$$s$$f$$e_{s,f}$

Bu, ve bunun dilleri ilk yöntemden daha dinamik olarak değiştirmesi, programlama sırasında hataya daha yatkın hale getirir. Başka bir yöntem kullanmanızı öneririm.

Eksileri

Bu algoritmada, örneğin hangi düğümü kaldırmamız gerektiğinin seçilmesi, sondaki son durumların sayısı, son bir durumun da başlangıç ​​olabileceği gerçeği gibi birçok durum vardır.

Şimdi algoritmanın yazıldığına dikkat edin, bu geçişli kapatma yöntemine çok benziyor. Sadece kullanımın içeriği farklı. Algoritmanın uygulanmasını önermiyorum, ancak bunu elle yapmak için yöntemi kullanmak iyi bir fikirdir.

Yöntem

Gördüğüm en güzel yöntem, otomatonu çözülebilecek (normal) dillerin denklem sistemi olarak ifade eden yöntem. Diğer yöntemlerden daha özlü ifadeler vermiş gibi göründüğü için özellikle güzel.

Let olmayan bir NFA -transitions. Her durumu için denklemi yaratın$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}$

burada bir son halin ve setidir bir geçiş olduğu anlamına gelir için ile etiketlenmiş . veya olarak okursanız (normal ifade tanımınıza bağlı olarak), bunun normal ifadelerin bir denklemi olduğunu görürsünüz.$F$$q_i \overset{a}{\to} q_j$$q_i$$q_j$$a$$\cup$$+$$\mid$

Sistemi çözmek için, ve (string bitiştirme), ve Arden's Lemma ¹ nın birleşimine ve dağıtıcılığına ihtiyacınız var :$\cup$$\cdot$$\cup$

Let düzenli diller . Sonra,$L,U,V \subseteq \Sigma^*$$\varepsilon \notin U$

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

Solüsyon düzenli ifadeler kümesidir , her devlet için bir tane . , başlatıldığında tarafından kabul edilebilecek sözcükleri tam olarak ; bu nedenle (eğer başlangıç ​​durumu ise) istenen ifadedir.q i Q i A q i Q 0 q $Q_i$$q_i$$Q_i$$A$$q_i$$Q_0$$q_0$

Örnek

^{Netlik açısından, singleton setlerini elementleri ile ifade ederiz, yani . Örnek Georg Zetzsche'den kaynaklanmaktadır.$a = \{a\}$}

Bu NFA'yı düşünün:

^{[ kaynak ]}

İlgili denklem sistemi:

$\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}$

Şimdi üçüncü denklemi ikinciye takın:

$\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}$

Son adım için, , ve . Üç dilin de normal olduğunu ve lemma uygulayabilmemizi sağlayan olduğunu unutmayın. Şimdi bu sonucu ilk denklemde gösteriyoruz:$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}$

Böylece, yukarıdaki otomat tarafından kabul edilen dil için, yani

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

Oldukça özelsin (diğer yöntemlerin sonuçlarıyla karşılaştırın), ancak benzersiz bir şekilde belirlenemediğine dikkat edin; denklem sistemini farklı manipülasyon dizileriyle çözmek diğerine eşdeğerdir! -- ifade.

1. Arden'in Lemması'nın bir kanıtı için buraya bakın .

Brzozowski cebirsel yöntem

Bu, Raphael'in cevabında açıklanan yöntemle aynıdır , ancak sistematik bir algoritma ve daha sonra gerçekten de algoritma açısından. Nereden başlayacağınızı öğrendikten sonra uygulamanın kolay ve doğal olduğu ortaya çıkıyor. Ayrıca, eğer tüm otomatların çizilmesi bir nedenden ötürü pratik değilse, elle yapmak daha kolay olabilir.

Bir algoritma yazarken, denklemlerin her zaman lineer olması gerektiğini hatırlamanız gerekir, böylece denklemlerin iyi bir soyut temsiline sahip olacaksınız, el ile çözerken unutabileceğiniz şeyler.

Algoritma fikri

Nasıl çalıştığını anlatmayacağım çünkü daha önce okumayı önerdiğim Raphael'in cevabında iyi iş çıkardın . Bunun yerine, fazladan fazla hesaplama veya fazladan durum olmadan denklemleri hangi sırayla çözmeniz gerektiğine odaklanıyorum.

Başlayarak Arden'in kuralı 'ın ustaca çözümü dili denkleme biz formun denklem kümesi olarak Otomaton düşünebiliriz:$X=A^*B$$X=AX∪B$

buna göre ve dizilerini güncelleyerek indüksiyon yaparak çözebiliriz . adımında , biz var:$n$$A_{i,j}$$B_{i,j}$$n$

Arden'in kuralı bize şunları veriyor:

ve ve ayarını :$B'_n = A_{n,n}^* B_n$$A'_{n,i}=A_{n,n}^*A_{n,i}$

ve sistemde tüm gereksinimlerini için ayarlayarak kaldırabiliriz :$X_n$$i,j<n$

olduğunda çözdüğümüzde şu gibi bir denklem elde ederiz:$X_n$$n=1$

bir ile . Böylece düzenli ifademizi aldık.$A'_{1,i}$

Algoritması

Bu sayede algoritmayı geliştirebiliriz. Yukarıdaki indüksiyondaki ile aynı konvansiyona sahip olmak için, ilk durumun olduğunu ve durum sayısının olduğunu . İlk olarak, doldurmak için başlatma :$q_1$$m$$B$

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

ve :$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] := ∅

ve sonra çözme:

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]

Son ifade şudur:

e := B[1]

uygulama

Bir algoritma için çok sembolik görünen bir denklem sistemi gibi görünse de, bu uygulama için çok uygundur. İşte bu algoritma Ocaml (kırık link) bir uygulamasıdır . İşlevden ayrı olarak brzozowski, her şeyin yazdırmak veya Raphael'in örneğini kullanmak için olduğunu unutmayın. Düzenli ifadelerin basitleştirilmesinde şaşırtıcı derecede etkili bir işlev bulunduğunu unutmayın simple_re.

Geçişli kapatma yöntemi

Bu yöntemin bir algoritma biçiminde yazması kolaydır, ancak çok büyük düzenli ifadeler oluşturur ve el ile yaparsanız, çoğunlukla bu çok sistematik olduğu için pratik değildir. Yine de bir algoritma için iyi ve basit bir çözüm.

Anahtar fikir

Let dizeleri düzenli ifade giden temsil için durumlarını kullanarak . Otomatların durum sayısı olsun .$R^k_{i,j}$$q_i$$q_j$$\{q_1, …, q_k\}$$n$

Zaten düzenli ifade biliyorum varsayalım dan için ara devlet olmadan herkes için, (ekstremitelerde hariç) . Ardından, başka bir durum eklemenin yeni normal ifade ifadesini nasıl etkileyeceğini tahmin edebilirsiniz : yalnızca doğrudan geçişleriniz varsa değişir ve şöyle ifade edilebilir:$R_{i,j}$$q_i$$q_j$$q_k$$i,j$$R'_{i,j}$$q_k$

( , dir ve , .)$R$$R^{k-1}$$R'$$R^k$

Örnek

Raphael'in cevabındaki gibi aynı örneği kullanacağız . İlk başta, yalnızca doğrudan geçişleri kullanabilirsiniz.

İşte ilk adım (a etiketli öz döngüsünün ilk dönüştüğünü unutmayın .$a$$ε$$(ε+a)$

İkinci adımda kullanabiliriz (ki bu bizim için olarak yeniden adlandırılmıştır , çünkü zaten yukarıdaki amaç için kullanılmaktadır). nasıl çalıştığını göreceğiz .$q_0$$q_1$$R^0$$R^1$

Kaynaktan için : .$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$

Neden? Bu gidiş nedeni için sadece kullanılarak bir ara devlet burada kalıyorum (yapılabilir olarak ) ya da giderek ( orada döngü,) ( ) ve geri geliyor ( ).$q_2$$q_2$$q_1$$ε$$q_1$$a$$ε^*$$b$

Bunun gibi ve de hesaplayabilirsiniz ve size son ifadeyi verecektir çünkü hem başlangıç ​​hem de sondur. İfadelerin basitleştirilmesinin burada yapıldığını unutmayın. Aksi takdirde, ilk bölgesinin olacaktır ve birinci bölgesinin olur .$R^2$$R^3$$R^3_{1,1}$$1$$a$$R^0$$(∅+a)$$a$$R^1$$((∅+a)+ε(ε)^*a)$

Algoritma

Başlatma:

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

Geçişli kapatma:

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)

O zaman son ifade şöyledir (varsayalım ki ilk durumdur):$q_s$

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

Ancak bunun çirkin düzenli ifadeler oluşturduğunu hayal edebilirsiniz. Gerçekten de aynı dili temsil eden gibi şeyleri bekleyebilirsiniz . Düzenli bir ifadeyi basitleştirmenin pratikte faydalı olduğunu unutmayın.bir $(∅)^*+(a+(∅)^*)(ε)^*(a + ∅)$$aa$