Ещё немного про производные для регулярок: построение автомата по регулярке.

gsvgit · gsvgit · commit 41779027ca81 · 2024-10-24T10:03:24.000+03:00
diff --git a/tex/RegularLanguages.tex b/tex/RegularLanguages.tex
@@ -118,7 +118,7 @@ \section{Конечные автоматы}
 Заметим, что функцию переходов можно представить разными способами: это может быть множество троек вида $(q_i, t, q_j)$, матрица, или же граф с метками на рёбрах
 \[G = \langle Q, \{(q_i,t,q_j \mid q_j \in \delta(q_i,t))\}, \Sigma \rangle.\]
 В дальнейшем мы чаще всего будем использовать представление автомата в виде графа.
-Чтобы такое представление было полным, в графе отдельно обозначают стартовые и финальные состояния, как это показано на рисунке~\ref{fa:fa_example}.
+Чтобы такое представление было полным, в графе отдельно обозначают стартовые и финальные состояния, как это показано на рисунке~\ref{fig:nfa_example}.
 
 Так как нас интересуют конечные автоматы в контексте языков, то будем говорить, что на ленте автомата записано какое-то слово (или строка).
 Иными словами, будем говорить, что автомат принимает на вход слово или строку.
@@ -138,7 +138,7 @@ \section{Конечные автоматы}
             \delta(0,\varepsilon) =& \varnothing & \delta(1,\varepsilon) =& \{0\}   & \delta(2,\varepsilon) =& \varnothing.
         \end{alignat*}
     \end{itemize}
-    Тогда его можно представить в виде графа как показано на рисунке~\ref{fa:fa_example}.
+    Тогда его можно представить в виде графа как показано на рисунке~\ref{fig:nfa_example}.
     \begin{marginfigure}
         \begin{center}
             \begin{tikzpicture}
@@ -154,7 +154,7 @@ \section{Конечные автоматы}
             \end{tikzpicture}
         \end{center}
         \caption{Пример конечного автомата в котором состояние $0$~--- стартовое, а состояние $1$~--- финальное}
-        \label{fa:fa_example}
+        \label{fig:nfa_example}
     \end{marginfigure}
 \end{example}
 
@@ -216,7 +216,7 @@ \section{Конечные автоматы}
 Это поможет при написании реального интерпретатора: будем отслеживать уже посещённые (обработанные) конфигурации\sidenote{Техника, аналогичная той, что применяется в обходах графов (обход в ширину, обход в глубину) для того, чтобы избежать повторного посещения вершин и, как следствие, зацикливания обхода. Более того, она типична для алгоритмов с рабочим множеством.}.
 
 \begin{example}
-    Рассмотрим пример работы конечного автомата, представленного на рисунке~\ref{fa:fa_example}, на входной цепочке \texttt{abb}.
+    Рассмотрим пример работы конечного автомата, представленного на рисунке~\ref{fig:nfa_example}, на входной цепочке \texttt{abb}.
     В данном автомате стартовое состояние одно, потому множество стартовых конфигураций состоит из одной конфигурации:
     \[
     C_S = \{(0,\texttt{abb})\}.
@@ -262,7 +262,7 @@ \section{Конечные автоматы}
 Во-первых, стартовое состояние ровно одно.
 Во-вторых, функция переходов не допускает переходов по $\varepsilon$ и из любого состояния существует не более одного перехода по конкретному символу.
 
-\begin{example}
+\begin{example}\label{example:DFA}
     Пусть задан детерминированный автомат $M=\langle Q, q_S, Q_F, \delta, \Sigma\rangle$, где
     \begin{itemize}
         \item $Q = \{0,1,2\}$;
@@ -409,22 +409,113 @@ \section{Производные для регулярных языков}
 
 \section{Построение конечного автомата по регулярному выражению}
 
-На производных%
+Конечные автоматы и регулярные выражения --- два способа задать оди и тот же класс языков.
+Для того, чтобы убедиться в их равной выразительной силе, для начала, научимся строить конечный автомат по регулярному выражению.
+Использование производных позволит нам сразу построить полный детерминированный автомат%
 \sidenote{Существуют и другие алгоритмы построения автомата по регулярному выражению. Например, алгоритм Томпсона~\cite{10.1145/363347.363387} или алгоритм Глушкова~\cite{Glushkov1961}.
 Как правило, каждый алгоритм строит автомат со специфичными свойствами: детерминированный или нет, с $\varepsilon$-переходами или без них.}.
 
-Каждое состояние соответствует языку, распозноваемому из этого состояния.
+Состояниям автомата будут соответствовать регулярные выражения: если (в результирующем автомате) состояние выбрать стартовым, то получившийся автомат будет распознавать язык, задаваемый соответствующим регулярным выражением.
+Чтобы автомат был минимальным нам будет необходимо проверять на эквивалентность языки, задаваемые регулярными выражениями и не дублировать состояния.
+Хотя задача проверки эквивалентности регулярных языков разрешима, на практике, в рамках данного алгоритма, чаще пользуются более быстро проверяемой структурной эквивалентностью~\sidenote{На деле, при проверке структурной эквивалентности дополнительно пользуются знаниями об ассоциативности некоторых операций и другимим свойствами выражений.} регулярных выражений~\sidecite{OWENS_REPPY_TURON_2009}.
+
 
-Стартовое --- исходное регулярное выражение. Далее в цикле.
+Таким образом, получится алгоритм с рабочим множеством, который состоит в следующем.
+В качестве стартового состояния возьмём состояние, соответствующее исходному регулярному выражению.
+В рабочее множество добавим стартовое состояние.
+Далее, пока рабочее множество не пусто, в цикле повторяем следующие шаги.
+\btgin{enumerate}
+    \item Берём из множества очередное состояние $q$, соответствующее регулярному выражению $R_q$.
+    \item Для всех символов из алфавита вычисляем производные $R_q$:.
+    \item Для всех построенных состояний проверяем, существует ли уже
+\end{enumerate}
 Берём очередное необработанное состояние, по каждому символу из алфавита берём производную соответствующего ему регулярного выражения.
 Добавляем получившееся состояние (если ещё не было такого).
 Если состояние isNullable, то помечаем его финальным.
 Добавляем ребро.
 
-В результате получим полный детерминированный конечный автомат\sidenote{Формально можно получить минимальный, но на практике это сложно. Но часто всё же достаточно близко к минимальному получается.}.
+В результате получим полный детерминированный конечный автомат\sidenote{Формально, если честно проверять равенство языков, можно получить минимальный, но на практике это сложно. Но часто всё же достаточно близко к минимальному получается.}.
 
-Примеры.
+\begin{example}
+    Построим автомат по регулярному выражению $a(a \mid (b \ b))^*$.
+    Состояние, помеченное данным выражением назначим стартовым и вычислим производные по символам.
+    Так как $\emph{IsNull}(a(a \mid (b \ b))^*) = \emph{false}$, финальным данное состояние не является.
+    Вычислим производные исходного выражения по всем символам из алфавита.
+    Проверим, что получившиеся выражения задают различные языки и добавим соответствующие переходы.
+    Одно из состояний соответствует пустому языку.
+    Данное состояние будет <<дьявольским>> или <<стоком>>.
+    Второе, помеченное $(a \mid (b \ b))^*$, соответствует языку, содержащему пустую цепочку.
+    То есть это состояние должно быть финальным.
+    В результате данного шага мы получим автомат, представленный на рисунке~\ref{fig:regexp_to_dfa_example_step_1}.
+
+    Продолжаем работу.
+    Возьмём производные для двух новых состояний и проделаем все соответствующие процедуры.
+    Уже видно, почему одно из состояний (соответствующее пустому языку), является <<дьявольским>>: попав в него однажды, остаёмся в нём навсегда.
+    Обработаем аналогичным образом новые состояния. Итог~\ref{fig:regexp_to_dfa_example_step_2}
+
+    Обработаем аналогичным образом новые состояния. Итог~\ref{fig:regexp_to_dfa_example_step_3}
+    \begin{marginfigure}
+        \begin{center}
+            \scalebox{0.64}{
+            \begin{tikzpicture}
+                \node[elliptic state,initial] (q_0) {$a(a \mid (b \ b))^*$};
+                \node[elliptic state,accepting] (q_1) [right = of q_0] {$(a \mid (b \ b))^*$};
+                \node[state] (q_2) [above = of q_0] {$\varnothing$};
+                \path[->]
+                    (q_0) edge[bend right, below]   node {$a$} (q_1)
+                    (q_0) edge[bend left, left]   node {$b$} (q_2);
+            \end{tikzpicture}}
+        \end{center}
+        \caption{Пример детерминированного конечного автомата в котором состояние $0$}
+        \label{fig:regexp_to_dfa_example_step_1}
+    \end{marginfigure}
+    \begin{marginfigure}
+        \begin{center}
+            \scalebox{0.64}{
+            \begin{tikzpicture}
+                \node[elliptic state,initial] (q_0) {$a(a \mid (b \ b))^*$};а
+                \node[elliptic state,accepting] (q_1) [right = of q_0] {$(a \mid (b \ b))^*$};
+                \node[state] (q_2) [above = of q_0] {$\varnothing$};
+                \node[elliptic state] (q_3) [above = of q_1] {$b(a \mid (b \ b))^*$};
+                \path[->]
+                    (q_0) edge[bend right, below]   node {$a$} (q_1)
+                    (q_0) edge[bend left, left]   node {$b$} (q_2)
+                    (q_1) edge[bend left, left]   node {$b$} (q_3)
+                    (q_2) edge[loop left, left]   node {$b,a$} (q_2)
+                    (q_1) edge[loop below, above]   node {$a$} (q_1);
+            \end{tikzpicture}
+            }
+        \end{center}
+        \caption{Пример детерминированного конечного автомата в котором состояние}
+        \label{fig:regexp_to_dfa_example_step_2}
+    \end{marginfigure}
+    \begin{marginfigure}
+        \begin{center}
+            \scalebox{0.64}{
+            \begin{tikzpicture}
+                \node[elliptic state,initial] (q_0) {$a(a \mid (b \ b))^*$};
+                \node[elliptic state,accepting] (q_1) [right = of q_0] {$(a \mid (b \ b))^*$};
+                \node[state] (q_2) [above = of q_0] {$\varnothing$};
+                \node[elliptic state] (q_3) [above = of q_1] {$b(a \mid (b \ b))^*$};
+                \path[->]
+                    (q_0) edge[bend right, below]   node {$a$} (q_1)
+                    (q_0) edge[bend left, left]   node {$b$} (q_2)
+                    (q_1) edge[bend left, left]   node {$b$} (q_3)
+                    (q_2) edge[loop left, left]   node {$b,a$} (q_2)
+                    (q_1) edge[loop below, above]   node {$a$} (q_1)
+                    (q_3) edge[bend left, right]   node {$b$} (q_1)
+                    (q_3) edge[bend left, below]   node {$a$} (q_2);
+            \end{tikzpicture}
+            }
+        \end{center}
+        \caption{Пример детерминированного конечного автомата в }
+        \label{fig:regexp_to_dfa_example_step_3}
+    \end{marginfigure}
+\end{example}
 
+В результате построения мы получили автомат, очень похожий на автомат из примера~\ref{example:DFA}.
+Единственная разница заключается в том, что автомат из примера не является полным.
+Само же сходство не случайно: автоматы действительно задают один и тот же регулярный язык.
 
 \section{Построение регулярного выражения по конечному автомату}
 
@@ -518,7 +609,6 @@ \section{Построение регулярного выражения по к
 
                 \end{tikzpicture}
             \end{center}
-
             \caption{Автомат перед устранением состояния $v$}
             \label{fa:fa3}
 
@@ -559,8 +649,8 @@ \section{Построение регулярного выражения по к
 \end{figure}
 
 После завершения основного цикла (когда в автомате осталось ровно два состояния), необходимо ещё раз объединить параллельные рёбра.
-Общий вид получившегося автомата представлен на рисунке~\ref{fa:fa5}.
-По такому автомату строим выражение вида \[(R_1^* \cdot (R_2 \cdot R_3^* \cdot R_4 )^* \cdot R_2 \cdot R_3^*,\] которое и будет ответом.
+Общий вид получившегося автомата представлен на рисунке~\ref{fig:fa_to_regexp_final}.
+По такому автомату строим выражение вида \[(R_1^* \cdot (R_2 \cdot R_3^* \cdot R_4 \cdot R_1^*)^* \cdot R_2 \cdot R_3^*,\] которое и будет ответом.
 \begin{marginfigure}
 
     \begin{center}
@@ -579,12 +669,42 @@ \section{Построение регулярного выражения по к
     \end{center}
 
     \caption{Общий вид автомата после завершения основного цикла}
-    \label{fa:fa5}
+    \label{fig:fa_to_regexp_final}
 
 \end{marginfigure}
 
 \begin{example}
-    Примеры.
+    Построим регулярное выражение по автомату, представленному на рисунке~\ref{fig:nfa_example}.
+    В автомате уже одно финальное и одно стартовое состояние.
+    При этом, существует всего одно состояние, которое не является ни финальным, ни стартовым.
+    Это состояние \circled{2}.
+    Его и устраним.
+
+    После устранения состояния \circled{2} получим автомат, представленный на рисунке~\ref{fig:nfa_to_regexp}.
+    Теперь наш автомат принял вид, соответствующий представленному на рисунке~\ref{fig:fa_to_regexp_final}, и можно выписать результирующее регулярное выражение, которое будет иметь следующий вид%
+    \sidenote{Конесно, получившесея выражение не <<минимально>>: дослаточно легко можно придумать более простое и компактное регулярное выражение, задающее тот же самый язык.
+    Но алгоритм нам и не обещал ни каких дополнительных свойств получившегося выражения.}:
+    \[
+    a^*(a \ (b \ b)^* \ \varepsilon \ a^*)^* \ a \ (b \ b)^* =
+    a^*(a \ (b \ b)^* \ a^*)^* \ a \ (b \ b)^*.
+    \]
+
+    \begin{marginfigure}
+        \begin{center}
+            \begin{tikzpicture}
+                \node[state,initial] (q_0) {$0$};
+                \node[state,accepting] (q_1) [right = of q_0] {$1$};
+                \path[->]
+                    (q_0) edge[bend left, above]   node {$a$} (q_1)
+                    (q_0) edge[loop above, above]   node {$a$} (q_0)
+                    (q_1) edge[loop above, above]   node {$bb$} (q_1)
+                    (q_1) edge[bend left, below]  node {$\varepsilon$} (q_0);
+            \end{tikzpicture}
+        \end{center}
+        \caption{Пример построения регулярного выражения по конечному автомату: финальное состояние автомата}
+        \label{fig:nfa_to_regexp}
+    \end{marginfigure}
+
 \end{example}
 
 
diff --git a/tex/styles/tikz.tex b/tex/styles/tikz.tex
@@ -26,3 +26,4 @@
 }
 
 \tikzstyle{r_state} = [shape=rectangle, draw, minimum size=0.2cm]
+\tikzset{elliptic state/.style={draw,ellipse}}

Original file line number	Diff line number	Diff line change
`@@ -26,3 +26,4 @@`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`\tikzstyle{r_state} = [shape=rectangle, draw, minimum size=0.2cm]`
	`29`	`+\tikzset{elliptic state/.style={draw,ellipse}}`