如何不使用NFA从正则表达式创建DFA？

12

目标是从正则表达式创建DFA，并且不能使用“ Regular exp> NFA> DFA转换”。应该怎么做呢？

我向我们的教授问了这个问题，但他告诉我，我们可以使用直觉，并拒绝提供任何解释。所以我想问你。

不能选择“正则表达式> NFA> DFA转换”，因为这样的转换要花费大量时间来转换一个相当复杂的正则表达式。例如，对于某个正则表达式，“ regex> NFA> DFA”对于人类来说要花费1个小时。我需要在不到30分钟的时间内将正则表达式转换为DFA。

— 拉斐尔
source

2

您需要提供更多上下文。您当前使用什么（非正式）算法来翻译正则表达式？用诸如此类的示例来说明您的过程可能会有所帮助a(a|ab|ac)*a+。您可以将其直接转换为要简化为DFA的NDFA，也可以将其标准化为立即映射到DFA的内容。

— 阿蒙（Amon）

您是否必须通过特定方法在特定示例上执行此操作，还是必须提供一般步骤以供计算机应用？

— 2015年

18

由于您希望“在不到30分钟的时间内将正则表达式转换为DFA”，我想您正在手工研究相对较小的示例。

在这种情况下，您可以使用Brzozowski的算法 ，该算法直接计算语言的Nerode自动机（已知等于其最小确定性自动机）。它基于导数的直接计算，并且还适用于允许相交和补码的扩展正则表达式。该算法的缺点是需要检查沿途计算的表达式的等价性，这是一个昂贵的过程。但是在实践中，对于一些小例子，它非常有效。 $[1]$

左商。令为的语言，令为一个词。然后语言称为左商（或左衍生物）的。 $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$

Nerode自动机。所述Nerode自动机的是确定性自动其中，和过渡函数被定义，对于每个 $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$

L

$L$

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

$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*}$ 最小自动机

$[1]$

编辑。（2015年4月5日），我刚刚发现了一个类似的问题：存在什么算法可用于构建可识别给定正则表达式描述的语言的DFA？被问到cstheory。答案部分解决了复杂性问题。

— J.-E. 销
source

您能否进一步说明该算法的复杂性？

— 2015年

@babou将RE转换为DFA是PSPACE困难的，因此绝对是指数级的。

— jmite

这可能应该进入答案。OP从“通过NFA进行标准构建的速度太慢”开始，部分答案似乎是“运气不好，没有真正的快速解决方案”。有待讨论的是，这是否比标准结构更好。（cc @jmite）

— 拉斐尔

@jmite是的，我期望如此。我提出这个问题的原因是，为什么应该以这种方式简化DFA的构建。（注意：系统花了整整一天的时间将@ jmite的答案通知我）。

— 2015年

2

J.-E. Pin在形式和完整性方面提供了更好的答案，但是我认为您的教授所暗示的“直觉”要说些什么。

在大多数情况下，最简单的方法是查看正则表达式，了解其接受的语言，然后利用自己的创造力/聪明才智来构建接受该语言的DFA。

除了其他人给出的算法外，没有简单的方法可以做到这一点，但是这里有一些准则可能被证明是有用的。

问问自己，我是否可以编写仅使用布尔值或很小的整数变量来接受此RE的程序？然后编写该程序，并将其转换为DFA，其中每个值组合都有一个状态。
查找正则表达式中您确定可以接受的部分，即“如果我看到此内容，那么我必须匹配RE的这一部分。” 不一定总会有很多，但是识别这些零件可以显示易于制作DFA的零件，因此您可以在真正需要不确定性的零件上花费更多时间。
NFA-> DFA的子集构造实际上并不复杂。因此，如果这是一项作业，而不是考试题，则只需编写实施代码，然后让您的程序将NFA转换为DFA可能会更快。如果您使用自己的代码，那么应该不会出现抄袭问题。

$P=NP=PSPACE$

当您可以在算法需要很多步骤但结果显而易见的地方使用直觉时，请尝试“向前看”。

— m
source

-2

虽然这不是正确的方法，但是它大多数时候都有效。

第一步：找到正则表达式可以接受的最小字符串。 第二步：使用最小字符串接受机的事务绘制必要的状态。 第三步：为所有州绘制剩余的字母交易记录。

例如：正则表达式（0 + 1）* 1“以1结尾的字符串”步骤1：最小字符串：1步骤2：两种状态Q0和Q1。从Q0到Q1的交易量为1。Q1为接受状态。步骤3：对于Q0状态，Q0 1事务处理到Q1。现在在Q0本身进行0笔交易。对于Q1状态Q1 1交易将保留在Q1中。并且0交易将在Q0中进行。

— Naveen CS
source