|
532
|
1 |
% Chapter Template
|
|
|
2 |
|
|
|
3 |
\chapter{Finiteness Bound} % Main chapter title
|
|
|
4 |
|
|
|
5 |
\label{Finite}
|
|
|
6 |
% In Chapter 4 \ref{Chapter4} we give the second guarantee
|
|
|
7 |
%of our bitcoded algorithm, that is a finite bound on the size of any
|
|
|
8 |
%regex's derivatives.
|
|
|
9 |
|
|
576
|
10 |
In this chapter we give a guarantee in terms of size:
|
|
590
|
11 |
given an annotated regular expression $a$, for any string $s$
|
|
|
12 |
our algorithm $\blexersimp$'s internal annotated regular expression
|
|
|
13 |
size is finitely bounded
|
|
|
14 |
by a constant $N_a$ that only depends on $a$:
|
|
576
|
15 |
\begin{center}
|
|
593
|
16 |
$\llbracket \bderssimp{a}{s} \rrbracket \leq N_a$
|
|
576
|
17 |
\end{center}
|
|
|
18 |
\noindent
|
|
577
|
19 |
where the size of an annotated regular expression is defined
|
|
|
20 |
in terms of the number of nodes in its tree structure:
|
|
|
21 |
\begin{center}
|
|
593
|
22 |
\begin{tabular}{ccc}
|
|
|
23 |
$\llbracket _{bs}\ONE \rrbracket$ & $\dn$ & $1$\\
|
|
|
24 |
$\llbracket \ZERO \rrbracket$ & $\dn$ & $1$ \\
|
|
|
25 |
$\llbracket _{bs} r_1 \cdot r_2 \rrbracket$ & $\dn$ & $\llbracket r_1 \rrbracket + \llbracket r_2 \rrbracket + 1$\\
|
|
|
26 |
$\llbracket _{bs}\mathbf{c} \rrbracket $ & $\dn$ & $1$\\
|
|
|
27 |
$\llbracket _{bs}\sum as \rrbracket $ & $\dn$ & $\map \; (\llbracket \_ \rrbracket)\; as + 1$\\
|
|
|
28 |
$\llbracket _{bs} a^* \rrbracket $ & $\dn$ & $\llbracket a \rrbracket + 1$.
|
|
|
29 |
\end{tabular}
|
|
577
|
30 |
\end{center}
|
|
590
|
31 |
We believe this size formalisation
|
|
|
32 |
of the algorithm is important in our context, because
|
|
|
33 |
\begin{itemize}
|
|
|
34 |
\item
|
|
|
35 |
It is a stepping stone towards an ``absence of catastrophic-backtracking''
|
|
|
36 |
guarantee. The next step would be to refine the bound $N_a$ so that it
|
|
|
37 |
is polynomial on $\llbracket a\rrbracket$.
|
|
|
38 |
\item
|
|
|
39 |
The size bound proof gives us a higher confidence that
|
|
|
40 |
our simplification algorithm $\simp$ does not ``mis-behave''
|
|
|
41 |
like $\simpsulz$ does.
|
|
|
42 |
The bound is universal, which is an advantage over work which
|
|
|
43 |
only gives empirical evidence on some test cases.
|
|
|
44 |
\end{itemize}
|
|
576
|
45 |
\section{Formalising About Size}
|
|
577
|
46 |
\noindent
|
|
576
|
47 |
In our lexer $\blexersimp$,
|
|
|
48 |
The regular expression is repeatedly being taken derivative of
|
|
|
49 |
and then simplified.
|
|
590
|
50 |
\begin{figure}[H]
|
|
593
|
51 |
\begin{tikzpicture}[scale=2,
|
|
|
52 |
every node/.style={minimum size=11mm},
|
|
|
53 |
->,>=stealth',shorten >=1pt,auto,thick
|
|
|
54 |
]
|
|
|
55 |
\node (r0) [rectangle, draw=black, thick, minimum size = 5mm, draw=blue] {$a$};
|
|
|
56 |
\node (r1) [rectangle, draw=black, thick, right=of r0, minimum size = 7mm]{$a_1$};
|
|
|
57 |
\draw[->,line width=0.2mm](r0)--(r1) node[above,midway] {$\backslash c_1$};
|
|
590
|
58 |
|
|
593
|
59 |
\node (r1s) [rectangle, draw=blue, thick, right=of r1, minimum size=6mm]{$a_{1s}$};
|
|
|
60 |
\draw[->, line width=0.2mm](r1)--(r1s) node[above, midway] {$\simp$};
|
|
590
|
61 |
|
|
593
|
62 |
\node (r2) [rectangle, draw=black, thick, right=of r1s, minimum size = 12mm]{$a_2$};
|
|
|
63 |
\draw[->,line width=0.2mm](r1s)--(r2) node[above,midway] {$\backslash c_2$};
|
|
590
|
64 |
|
|
593
|
65 |
\node (r2s) [rectangle, draw = blue, thick, right=of r2,minimum size=6mm]{$a_{2s}$};
|
|
|
66 |
\draw[->,line width=0.2mm](r2)--(r2s) node[above,midway] {$\simp$};
|
|
590
|
67 |
|
|
593
|
68 |
\node (rns) [rectangle, draw = blue, thick, right=of r2s,minimum size=6mm]{$a_{ns}$};
|
|
|
69 |
\draw[->,line width=0.2mm, dashed](r2s)--(rns) node[above,midway] {$\backslash \ldots$};
|
|
590
|
70 |
|
|
593
|
71 |
\node (v) [circle, thick, draw, right=of rns, minimum size=6mm, right=1.7cm]{$v$};
|
|
|
72 |
\draw[->, line width=0.2mm](rns)--(v) node[above, midway] {\bmkeps} node [below, midway] {\decode};
|
|
|
73 |
\end{tikzpicture}
|
|
|
74 |
\caption{Regular expression size change during our $\blexersimp$ algorithm}\label{simpShrinks}
|
|
590
|
75 |
\end{figure}
|
|
576
|
76 |
\noindent
|
|
590
|
77 |
Each time
|
|
|
78 |
a derivative is taken, a regular expression might grow a bit,
|
|
|
79 |
but simplification always takes care that
|
|
|
80 |
it stays small.
|
|
577
|
81 |
This intuition is depicted by the relative size
|
|
590
|
82 |
change between the black and blue nodes:
|
|
|
83 |
After $\simp$ the node always shrinks.
|
|
|
84 |
Our proof says that all the blue nodes
|
|
|
85 |
stay below a size bound $N_a$ determined by $a$.
|
|
576
|
86 |
|
|
590
|
87 |
\noindent
|
|
|
88 |
Sulzmann and Lu's assumed something similar about their algorithm,
|
|
|
89 |
though in fact their algorithm's size might be better depicted by the following graph:
|
|
|
90 |
\begin{figure}[H]
|
|
593
|
91 |
\begin{tikzpicture}[scale=2,
|
|
|
92 |
every node/.style={minimum size=11mm},
|
|
|
93 |
->,>=stealth',shorten >=1pt,auto,thick
|
|
|
94 |
]
|
|
|
95 |
\node (r0) [rectangle, draw=black, thick, minimum size = 5mm, draw=blue] {$a$};
|
|
|
96 |
\node (r1) [rectangle, draw=black, thick, right=of r0, minimum size = 7mm]{$a_1$};
|
|
|
97 |
\draw[->,line width=0.2mm](r0)--(r1) node[above,midway] {$\backslash c_1$};
|
|
590
|
98 |
|
|
593
|
99 |
\node (r1s) [rectangle, draw=blue, thick, right=of r1, minimum size=7mm]{$a_{1s}$};
|
|
|
100 |
\draw[->, line width=0.2mm](r1)--(r1s) node[above, midway] {$\simp'$};
|
|
590
|
101 |
|
|
593
|
102 |
\node (r2) [rectangle, draw=black, thick, right=of r1s, minimum size = 17mm]{$a_2$};
|
|
|
103 |
\draw[->,line width=0.2mm](r1s)--(r2) node[above,midway] {$\backslash c_2$};
|
|
590
|
104 |
|
|
593
|
105 |
\node (r2s) [rectangle, draw = blue, thick, right=of r2,minimum size=14mm]{$a_{2s}$};
|
|
|
106 |
\draw[->,line width=0.2mm](r2)--(r2s) node[above,midway] {$\simp'$};
|
|
590
|
107 |
|
|
593
|
108 |
\node (r3) [rectangle, draw = black, thick, right= of r2s, minimum size = 22mm]{$a_3$};
|
|
|
109 |
\draw[->,line width=0.2mm](r2s)--(r3) node[above,midway] {$\backslash c_3$};
|
|
590
|
110 |
|
|
593
|
111 |
\node (rns) [right = of r3, draw=blue, minimum size = 20mm]{$a_{3s}$};
|
|
|
112 |
\draw[->,line width=0.2mm] (r3)--(rns) node [above, midway] {$\simp'$};
|
|
590
|
113 |
|
|
593
|
114 |
\node (rnn) [right = of rns, minimum size = 1mm]{};
|
|
|
115 |
\draw[->, dashed] (rns)--(rnn) node [above, midway] {$\ldots$};
|
|
590
|
116 |
|
|
593
|
117 |
\end{tikzpicture}
|
|
|
118 |
\caption{Regular expression size change during our $\blexersimp$ algorithm}\label{sulzShrinks}
|
|
590
|
119 |
\end{figure}
|
|
|
120 |
\noindent
|
|
|
121 |
That is, on certain cases their lexer
|
|
576
|
122 |
will have an indefinite size explosion, causing the running time
|
|
590
|
123 |
of each derivative step to grow arbitrarily large (for example
|
|
|
124 |
in \ref{SulzmannLuLexerTime}).
|
|
|
125 |
The reason they made this mistake was that
|
|
|
126 |
they tested out the run time of their
|
|
|
127 |
lexer on particular examples such as $(a+b+ab)^*$
|
|
|
128 |
and generalised to all cases, which
|
|
|
129 |
cannot happen with our mecahnised proof.\\
|
|
|
130 |
We give details of the proof in the next sections.
|
|
|
131 |
|
|
577
|
132 |
\subsection{Overview of the Proof}
|
|
|
133 |
Here is a bird's eye view of how the proof of finiteness works,
|
|
|
134 |
which involves three steps:
|
|
593
|
135 |
\begin{figure}[H]
|
|
|
136 |
\begin{tikzpicture}[scale=1,font=\bf,
|
|
|
137 |
node/.style={
|
|
|
138 |
rectangle,rounded corners=3mm,
|
|
|
139 |
ultra thick,draw=black!50,minimum height=18mm,
|
|
|
140 |
minimum width=20mm,
|
|
|
141 |
top color=white,bottom color=black!20}]
|
|
543
|
142 |
|
|
|
143 |
|
|
593
|
144 |
\node (0) at (-5,0)
|
|
|
145 |
[node, text width=1.8cm, text centered]
|
|
|
146 |
{$\llbracket \bderssimp{a}{s} \rrbracket$};
|
|
|
147 |
\node (A) at (0,0)
|
|
|
148 |
[node,text width=1.6cm, text centered]
|
|
|
149 |
{$\llbracket \rderssimp{r}{s} \rrbracket_r$};
|
|
|
150 |
\node (B) at (3,0)
|
|
|
151 |
[node,text width=3.0cm, anchor=west, minimum width = 40mm]
|
|
|
152 |
{$\llbracket \textit{ClosedForm}(r, s)\rrbracket_r$};
|
|
|
153 |
\node (C) at (9.5,0) [node, minimum width=10mm] {$N_r$};
|
|
|
154 |
|
|
|
155 |
\draw [->,line width=0.5mm] (0) --
|
|
|
156 |
node [above,pos=0.45] {=} (A) node [below, pos = 0.45] {$(r = a \downarrow_r)$} (A);
|
|
|
157 |
\draw [->,line width=0.5mm] (A) --
|
|
|
158 |
node [above,pos=0.35] {$\quad =\ldots=$} (B);
|
|
|
159 |
\draw [->,line width=0.5mm] (B) --
|
|
|
160 |
node [above,pos=0.35] {$\quad \leq \ldots \leq$} (C);
|
|
|
161 |
\end{tikzpicture}
|
|
|
162 |
%\caption{
|
|
|
163 |
\end{figure}
|
|
576
|
164 |
\noindent
|
|
577
|
165 |
We explain the steps one by one:
|
|
532
|
166 |
\begin{itemize}
|
|
590
|
167 |
\item
|
|
|
168 |
We first introduce the operations such as
|
|
|
169 |
derivatives, simplification, size calculation, etc.
|
|
|
170 |
associated with $\rrexp$s, which we have given
|
|
|
171 |
a very brief introduction to in chapter \ref{Bitcoded2}.
|
|
593
|
172 |
The operations on $\rrexp$s are identical to those on
|
|
|
173 |
annotated regular expressions except that they are unaware
|
|
|
174 |
of bitcodes. This means that all proofs about size of $\rrexp$s will apply to
|
|
|
175 |
annotated regular expressions.
|
|
590
|
176 |
\item
|
|
593
|
177 |
We prove that $\rderssimp{r}{s} = \textit{ClosedForm}(r, s)$,
|
|
|
178 |
where $\textit{ClosedForm}(r, s)$ is entirely
|
|
|
179 |
written in the derivatives of their children regular
|
|
|
180 |
expressions.
|
|
|
181 |
We call the right-hand-side the \emph{Closed Form}
|
|
|
182 |
of the derivative $\rderssimp{r}{s}$.
|
|
590
|
183 |
\item
|
|
593
|
184 |
We estimate $\llbracket \textit{ClosedForm}(r, s) \rrbracket_r$.
|
|
|
185 |
The key observation is that $\distinctBy$'s output is
|
|
|
186 |
a list with a constant length bound.
|
|
532
|
187 |
\end{itemize}
|
|
594
|
188 |
We will expand on these steps in the next sections.\\
|
|
532
|
189 |
|
|
593
|
190 |
\section{The $\textit{Rrexp}$ Datatype and Its Lexing-Related Functions}
|
|
594
|
191 |
The first step is to define
|
|
|
192 |
$\textit{rrexp}$s.
|
|
|
193 |
They are without bitcodes,
|
|
|
194 |
allowing a much simpler size bound proof.
|
|
|
195 |
Of course, the bits which encode the lexing information
|
|
|
196 |
would grow linearly with respect
|
|
|
197 |
to the input, which should be taken into account when we wish to tackle the runtime comlexity.
|
|
|
198 |
But for the sake of the structural size
|
|
|
199 |
we can safely ignore them.\\
|
|
|
200 |
To recapitulate, the datatype
|
|
|
201 |
definition of the $\rrexp$, called
|
|
593
|
202 |
\emph{r-regular expressions},
|
|
594
|
203 |
was initially defined in \ref{rrexpDef}.
|
|
|
204 |
The reason for the prefix $r$ is
|
|
593
|
205 |
to make a distinction
|
|
594
|
206 |
with basic regular expressions.
|
|
576
|
207 |
\[ \rrexp ::= \RZERO \mid \RONE
|
|
593
|
208 |
\mid \RCHAR{c}
|
|
|
209 |
\mid \RSEQ{r_1}{r_2}
|
|
|
210 |
\mid \RALTS{rs}
|
|
|
211 |
\mid \RSTAR{r}
|
|
576
|
212 |
\]
|
|
593
|
213 |
The size of an r-regular expression is
|
|
|
214 |
written $\llbracket r\rrbracket_r$,
|
|
|
215 |
whose definition mirrors that of an annotated regular expression.
|
|
576
|
216 |
\begin{center}
|
|
593
|
217 |
\begin{tabular}{ccc}
|
|
|
218 |
$\llbracket _{bs}\ONE \rrbracket_r$ & $\dn$ & $1$\\
|
|
|
219 |
$\llbracket \ZERO \rrbracket_r$ & $\dn$ & $1$ \\
|
|
|
220 |
$\llbracket _{bs} r_1 \cdot r_2 \rrbracket_r$ & $\dn$ & $\llbracket r_1 \rrbracket_r + \llbracket r_2 \rrbracket_r + 1$\\
|
|
|
221 |
$\llbracket _{bs}\mathbf{c} \rrbracket_r $ & $\dn$ & $1$\\
|
|
|
222 |
$\llbracket _{bs}\sum as \rrbracket_r $ & $\dn$ & $\map \; (\llbracket \_ \rrbracket_r)\; as + 1$\\
|
|
|
223 |
$\llbracket _{bs} a^* \rrbracket_r $ & $\dn$ & $\llbracket a \rrbracket_r + 1$.
|
|
|
224 |
\end{tabular}
|
|
576
|
225 |
\end{center}
|
|
|
226 |
\noindent
|
|
593
|
227 |
The $r$ in the subscript of $\llbracket \rrbracket_r$ is to
|
|
|
228 |
differentiate with the same operation for annotated regular expressions.
|
|
|
229 |
Adding $r$ as subscript will be used in
|
|
594
|
230 |
other operations as well.\\
|
|
593
|
231 |
The transformation from an annotated regular expression
|
|
|
232 |
to an r-regular expression is straightforward.
|
|
|
233 |
\begin{center}
|
|
|
234 |
\begin{tabular}{lcl}
|
|
|
235 |
$\rerase{\ZERO}$ & $\dn$ & $\RZERO$\\
|
|
|
236 |
$\rerase{_{bs}\ONE}$ & $\dn$ & $\RONE$\\
|
|
|
237 |
$\rerase{_{bs}\mathbf{c}}$ & $\dn$ & $\RCHAR{c}$\\
|
|
|
238 |
$\rerase{_{bs}r_1\cdot r_2}$ & $\dn$ & $\RSEQ{\rerase{r_1}}{\rerase{r_2}}$\\
|
|
|
239 |
$\rerase{_{bs}\sum as}$ & $\dn$ & $\RALTS{\map \; \rerase{\_} \; as}$\\
|
|
|
240 |
$\rerase{_{bs} a ^*}$ & $\dn$ & $\rerase{a} ^*$
|
|
|
241 |
\end{tabular}
|
|
|
242 |
\end{center}
|
|
576
|
243 |
\noindent
|
|
594
|
244 |
$\textit{Rerase}$ throws away the bitcodes
|
|
|
245 |
on the annotated regular expressions,
|
|
593
|
246 |
but keeps everything else intact.
|
|
594
|
247 |
Therefore it does not change the size
|
|
|
248 |
of an annotated regular expression:
|
|
|
249 |
\begin{lemma}\label{rsizeAsize}
|
|
593
|
250 |
$\rsize{\rerase a} = \asize a$
|
|
|
251 |
\end{lemma}
|
|
|
252 |
\begin{proof}
|
|
|
253 |
By routine structural induction on $a$.
|
|
|
254 |
\end{proof}
|
|
|
255 |
\noindent
|
|
594
|
256 |
|
|
576
|
257 |
\subsection{Motivation Behind a New Datatype}
|
|
594
|
258 |
The reason we take all the trouble
|
|
|
259 |
defining a new datatype is that $\erase$ makes things harder.
|
|
576
|
260 |
We initially started by using
|
|
|
261 |
plain regular expressions and tried to prove
|
|
594
|
262 |
the lemma \ref{rsizeAsize},
|
|
|
263 |
however the $\erase$ function unavoidbly messes with the structure of the
|
|
|
264 |
annotated regular expression.
|
|
|
265 |
The $+$ constructor
|
|
|
266 |
of basic regular expressions is binary whereas $\sum$
|
|
|
267 |
takes a list, and one has to convert between them:
|
|
576
|
268 |
\begin{center}
|
|
594
|
269 |
\begin{tabular}{ccc}
|
|
|
270 |
$\erase \; _{bs}\sum [] $ & $\dn$ & $\ZERO$\\
|
|
|
271 |
$\erase \; _{bs}\sum [a]$ & $\dn$ & $a$\\
|
|
|
272 |
$\erase \; _{bs}\sum a :: as$ & $\dn$ & $a + (\erase \; _{[]} \sum as)\quad \text{if $as$ length over 1}$
|
|
|
273 |
\end{tabular}
|
|
576
|
274 |
\end{center}
|
|
594
|
275 |
\noindent
|
|
|
276 |
An alternative regular expression with an empty argument list
|
|
|
277 |
will be turned into a $\ZERO$.
|
|
|
278 |
The singleton alternative $\sum [r]$ would have $r$ during the
|
|
|
279 |
$\erase$ function.
|
|
|
280 |
The annotated regular expression $\sum[a, b, c]$ would turn into
|
|
|
281 |
$(a+(b+c))$.
|
|
|
282 |
All these operations change the size and structure of
|
|
|
283 |
an annotated regular expressions, adding unnecessary
|
|
|
284 |
complexities to the size bound proof.\\
|
|
|
285 |
For example, if we define the size of a basic regular expression
|
|
|
286 |
in the usual way,
|
|
543
|
287 |
\begin{center}
|
|
593
|
288 |
\begin{tabular}{ccc}
|
|
|
289 |
$\llbracket \ONE \rrbracket_p$ & $\dn$ & $1$\\
|
|
|
290 |
$\llbracket \ZERO \rrbracket_p$ & $\dn$ & $1$ \\
|
|
|
291 |
$\llbracket r_1 \cdot r_2 \rrbracket_p$ & $\dn$ & $\llbracket r_1 \rrbracket_p + \llbracket r_2 \rrbracket_p + 1$\\
|
|
|
292 |
$\llbracket \mathbf{c} \rrbracket_p $ & $\dn$ & $1$\\
|
|
|
293 |
$\llbracket r_1 \cdot r_2 \rrbracket_p $ & $\dn$ & $\llbracket r_1 \rrbracket_p \; + \llbracket r_2 \rrbracket_p + 1$\\
|
|
|
294 |
$\llbracket a^* \rrbracket_p $ & $\dn$ & $\llbracket a \rrbracket_p + 1$
|
|
|
295 |
\end{tabular}
|
|
532
|
296 |
\end{center}
|
|
543
|
297 |
\noindent
|
|
594
|
298 |
Then the property
|
|
532
|
299 |
\begin{center}
|
|
594
|
300 |
$\llbracket a \rrbracket = \llbracket a_\downarrow \rrbracket_p$
|
|
532
|
301 |
\end{center}
|
|
594
|
302 |
does not hold.
|
|
|
303 |
One might be able to prove an inequality such as
|
|
|
304 |
$\llbracket a \rrbracket \leq \llbracket a_\downarrow \rrbracket_p $
|
|
|
305 |
and then estimate $\llbracket a_\downarrow \rrbracket_p$,
|
|
|
306 |
but we found our approach more straightforward.\\
|
|
532
|
307 |
|
|
594
|
308 |
\subsection{Lexing Related Functions for $\rrexp$ such as $\backslash_r$, $\rdistincts$, and $\rsimp$}
|
|
|
309 |
The operations on r-regular expressions are
|
|
|
310 |
almost identical to those of the annotated regular expressions,
|
|
|
311 |
except that no bitcodes are used. For example,
|
|
|
312 |
the derivative operation becomes simpler:\\
|
|
543
|
313 |
\begin{center}
|
|
593
|
314 |
\begin{tabular}{@{}lcl@{}}
|
|
|
315 |
$(\ZERO)\,\backslash_r c$ & $\dn$ & $\ZERO$\\
|
|
|
316 |
$(\ONE)\,\backslash_r c$ & $\dn$ &
|
|
|
317 |
$\textit{if}\;c=d\; \;\textit{then}\;
|
|
|
318 |
\ONE\;\textit{else}\;\ZERO$\\
|
|
|
319 |
$(\sum \;\textit{rs})\,\backslash_r c$ & $\dn$ &
|
|
|
320 |
$\sum\;(\textit{map} \; (\_\backslash_r c) \; rs )$\\
|
|
|
321 |
$(r_1\cdot r_2)\,\backslash_r c$ & $\dn$ &
|
|
594
|
322 |
$\textit{if}\;(\textit{rnullable}\,r_1)$\\
|
|
593
|
323 |
& &$\textit{then}\;\sum\,[(r_1\,\backslash_r c)\cdot\,r_2,$\\
|
|
|
324 |
& &$\phantom{\textit{then},\;\sum\,}((r_2\,\backslash_r c))]$\\
|
|
|
325 |
& &$\textit{else}\;\,(r_1\,\backslash_r c)\cdot r_2$\\
|
|
|
326 |
$(r^*)\,\backslash_r c$ & $\dn$ &
|
|
|
327 |
$( r\,\backslash_r c)\cdot
|
|
|
328 |
(_{[]}r^*))$
|
|
|
329 |
\end{tabular}
|
|
543
|
330 |
\end{center}
|
|
|
331 |
\noindent
|
|
594
|
332 |
Similarly, $\distinctBy$ does not need
|
|
|
333 |
a function checking equivalence because
|
|
|
334 |
there are no bit annotations causing superficial differences
|
|
|
335 |
between syntactically equal terms.
|
|
532
|
336 |
\begin{center}
|
|
593
|
337 |
\begin{tabular}{lcl}
|
|
|
338 |
$\rdistinct{[]}{rset} $ & $\dn$ & $[]$\\
|
|
594
|
339 |
$\rdistinct{r :: rs}{rset}$ & $\dn$ &
|
|
|
340 |
$\textit{if}(r \in \textit{rset}) \; \textit{then} \; \rdistinct{rs}{rset}$\\
|
|
|
341 |
& & $\textit{else}\; \;
|
|
|
342 |
r::\rdistinct{rs}{(rset \cup \{r\})}$
|
|
593
|
343 |
\end{tabular}
|
|
532
|
344 |
\end{center}
|
|
|
345 |
%TODO: definition of rsimp (maybe only the alternative clause)
|
|
543
|
346 |
\noindent
|
|
595
|
347 |
We would like to make clear
|
|
|
348 |
a difference between our $\rdistincts$ and
|
|
|
349 |
the Isabelle $\textit {distinct}$ predicate.
|
|
|
350 |
In Isabelle $\textit{distinct}$ is a function that returns a boolean
|
|
|
351 |
rather than a list.
|
|
|
352 |
It tests if all the elements of a list are unique.\\
|
|
|
353 |
With $\textit{rdistinct}$,
|
|
|
354 |
and the flatten function for $\rrexp$s:
|
|
|
355 |
\begin{center}
|
|
|
356 |
\begin{tabular}{@{}lcl@{}}
|
|
|
357 |
$\textit{rflts} \; (_{bs}\sum \textit{as}) :: \textit{as'}$ & $\dn$ & $(\textit{map} \;
|
|
|
358 |
(\textit{fuse}\;bs)\; \textit{as}) \; @ \; \textit{rflts} \; as' $ \\
|
|
|
359 |
$\textit{rflts} \; \ZERO :: as'$ & $\dn$ & $ \textit{rflts} \; \textit{as'} $ \\
|
|
|
360 |
$\textit{rflts} \; a :: as'$ & $\dn$ & $a :: \textit{rflts} \; \textit{as'}$ \quad(otherwise)
|
|
|
361 |
\end{tabular}
|
|
|
362 |
\end{center}
|
|
|
363 |
\noindent
|
|
|
364 |
|
|
|
365 |
one can chain together all the other modules
|
|
543
|
366 |
of $\bsimp{\_}$ (removing the functionalities related to bit-sequences)
|
|
|
367 |
and get $\textit{rsimp}$ and $\rderssimp{\_}{\_}$.
|
|
595
|
368 |
\begin{center}
|
|
|
369 |
\begin{tabular}{@{}lcl@{}}
|
|
|
370 |
|
|
|
371 |
$\textit{rsimp} \; (_{bs}a_1\cdot a_2)$ & $\dn$ & $ \textit{rsimp}_{ASEQ} \; bs \;(\textit{rsimp} \; a_1) \; (\textit{rsimp} \; a_2) $ \\
|
|
|
372 |
$\textit{rsimp} \; (_{bs}\sum \textit{as})$ & $\dn$ & $\textit{rsimp}_{ALTS} \; \textit{bs} \; (\textit{rdistinct} \; ( \textit{rflts} ( \textit{map} \; rsimp \; as)) \; \rerases \; \varnothing) $ \\
|
|
|
373 |
$\textit{rsimp} \; a$ & $\dn$ & $\textit{a} \qquad \textit{otherwise}$
|
|
|
374 |
\end{tabular}
|
|
|
375 |
\end{center}
|
|
543
|
376 |
We omit these functions, as they are routine. Please refer to the formalisation
|
|
|
377 |
(in file BasicIdentities.thy) for the exact definition.
|
|
|
378 |
With $\rrexp$ the size caclulation of annotated regular expressions'
|
|
|
379 |
simplification and derivatives can be done by the size of their unlifted
|
|
|
380 |
counterpart with the unlifted version of simplification and derivatives applied.
|
|
564
|
381 |
\begin{lemma}\label{sizeRelations}
|
|
553
|
382 |
The following equalities hold:
|
|
543
|
383 |
\begin{itemize}
|
|
|
384 |
\item
|
|
554
|
385 |
$\asize{\bsimp{a}} = \rsize{\rsimp{\rerase{a}}}$
|
|
|
386 |
\item
|
|
|
387 |
$\asize{\bderssimp{r}{s}} = \rsize{\rderssimp{\rerase{r}}{s}}$
|
|
|
388 |
\end{itemize}
|
|
532
|
389 |
\end{lemma}
|
|
543
|
390 |
\noindent
|
|
|
391 |
In the following content, we will focus on $\rrexp$'s size bound.
|
|
|
392 |
We will piece together this bound and show the same bound for annotated regular
|
|
|
393 |
expressions in the end.
|
|
532
|
394 |
Unless stated otherwise in this chapter all $\textit{rexp}$s without
|
|
593
|
395 |
bitcodes are seen as $\rrexp$s.
|
|
|
396 |
We also use $r_1 + r_2$ and $\RALTS{[r_1, r_2]}$ interchageably
|
|
|
397 |
as the former suits people's intuitive way of stating a binary alternative
|
|
|
398 |
regular expression.
|
|
532
|
399 |
|
|
|
400 |
|
|
|
401 |
|
|
|
402 |
%-----------------------------------
|
|
|
403 |
% SECTION ?
|
|
|
404 |
%-----------------------------------
|
|
593
|
405 |
\subsection{Finiteness Proof Using $\rrexp$s}
|
|
|
406 |
Now that we have defined the $\rrexp$ datatype, and proven that its size changes
|
|
|
407 |
w.r.t derivatives and simplifications mirrors precisely those of annotated regular expressions,
|
|
|
408 |
we aim to bound the size of $r \backslash s$ for any $\rrexp$ $r$.
|
|
|
409 |
Once we have a bound like:
|
|
|
410 |
\[
|
|
|
411 |
\llbracket r \backslash_{rsimp} s \rrbracket_r \leq N_r
|
|
|
412 |
\]
|
|
|
413 |
\noindent
|
|
|
414 |
we could easily extend that to
|
|
|
415 |
\[
|
|
|
416 |
\llbracket a \backslash_{bsimps} s \rrbracket \leq N_r.
|
|
|
417 |
\]
|
|
553
|
418 |
|
|
593
|
419 |
\subsection{Roadmap to a Bound for $\textit{Rrexp}$}
|
|
553
|
420 |
|
|
|
421 |
The way we obtain the bound for $\rrexp$s is by two steps:
|
|
543
|
422 |
\begin{itemize}
|
|
|
423 |
\item
|
|
|
424 |
First, we rewrite $r\backslash s$ into something else that is easier
|
|
|
425 |
to bound. This step is especially important for the inductive case
|
|
|
426 |
$r_1 \cdot r_2$ and $r^*$, where the derivative can grow and bloat in a wild way,
|
|
|
427 |
but after simplification they will always be equal or smaller to a form consisting of an alternative
|
|
|
428 |
list of regular expressions $f \; (g\; (\sum rs))$ with some functions applied to it, where each element will be distinct after the function application.
|
|
|
429 |
\item
|
|
|
430 |
Then, for such a sum list of regular expressions $f\; (g\; (\sum rs))$, we can control its size
|
|
|
431 |
by estimation, since $\distinctBy$ and $\flts$ are well-behaved and working together would only
|
|
553
|
432 |
reduce the size of a regular expression, not adding to it.
|
|
543
|
433 |
\end{itemize}
|
|
|
434 |
|
|
553
|
435 |
\section{Step One: Closed Forms}
|
|
593
|
436 |
We transform the function application $\rderssimp{r}{s}$
|
|
|
437 |
into an equivalent
|
|
|
438 |
form $f\; (g \; (\sum rs))$.
|
|
|
439 |
The functions $f$ and $g$ can be anything from $\flts$, $\distinctBy$ and other helper functions from $\bsimp{\_}$.
|
|
|
440 |
This way we get a different but equivalent way of expressing : $r\backslash s = f \; (g\; (\sum rs))$, we call the
|
|
|
441 |
right hand side the "closed form" of $r\backslash s$.
|
|
558
|
442 |
|
|
|
443 |
\begin{quote}\it
|
|
|
444 |
Claim: For regular expressions $r_1 \cdot r_2$, we claim that
|
|
|
445 |
\begin{center}
|
|
|
446 |
$ \rderssimp{r_1 \cdot r_2}{s} =
|
|
593
|
447 |
\rsimp{(\sum (r_1 \backslash s \cdot r_2 ) \; :: \;(\map \; \rderssimp{r2}{\_} \;(\vsuf{s}{r_1})))}$
|
|
558
|
448 |
\end{center}
|
|
|
449 |
\end{quote}
|
|
|
450 |
\noindent
|
|
|
451 |
We explain in detail how we reached those claims.
|
|
543
|
452 |
\subsection{Basic Properties needed for Closed Forms}
|
|
|
453 |
|
|
|
454 |
\subsubsection{$\textit{rdistinct}$'s Deduplicates Successfully}
|
|
|
455 |
The $\textit{rdistinct}$ function, as its name suggests, will
|
|
553
|
456 |
remove duplicates in an \emph{r}$\textit{rexp}$ list,
|
|
|
457 |
according to the accumulator
|
|
543
|
458 |
and leave only one of each different element in a list:
|
|
555
|
459 |
\begin{lemma}\label{rdistinctDoesTheJob}
|
|
543
|
460 |
The function $\textit{rdistinct}$ satisfies the following
|
|
|
461 |
properties:
|
|
|
462 |
\begin{itemize}
|
|
|
463 |
\item
|
|
|
464 |
If $a \in acc$ then $a \notin (\rdistinct{rs}{acc})$.
|
|
|
465 |
\item
|
|
|
466 |
If list $rs'$ is the result of $\rdistinct{rs}{acc}$,
|
|
555
|
467 |
then $\textit{isDistinct} \; rs'$.
|
|
|
468 |
\item
|
|
|
469 |
$\rdistinct{rs}{acc} = rs - acc$
|
|
543
|
470 |
\end{itemize}
|
|
|
471 |
\end{lemma}
|
|
555
|
472 |
\noindent
|
|
|
473 |
The predicate $\textit{isDistinct}$ is for testing
|
|
|
474 |
whether a list's elements are all unique. It is defined
|
|
|
475 |
recursively on the structure of a regular expression,
|
|
|
476 |
and we omit the precise definition here.
|
|
543
|
477 |
\begin{proof}
|
|
|
478 |
The first part is by an induction on $rs$.
|
|
555
|
479 |
The second and third part can be proven by using the
|
|
543
|
480 |
induction rules of $\rdistinct{\_}{\_}$.
|
|
593
|
481 |
|
|
543
|
482 |
\end{proof}
|
|
|
483 |
|
|
|
484 |
\noindent
|
|
|
485 |
$\rdistinct{\_}{\_}$ will cancel out all regular expression terms
|
|
|
486 |
that are in the accumulator, therefore prepending a list $rs_a$ with an arbitrary
|
|
|
487 |
list $rs$ whose elements are all from the accumulator, and then call $\rdistinct{\_}{\_}$
|
|
|
488 |
on the resulting list, the output will be as if we had called $\rdistinct{\_}{\_}$
|
|
|
489 |
without the prepending of $rs$:
|
|
|
490 |
\begin{lemma}
|
|
554
|
491 |
The elements appearing in the accumulator will always be removed.
|
|
|
492 |
More precisely,
|
|
|
493 |
\begin{itemize}
|
|
|
494 |
\item
|
|
|
495 |
If $rs \subseteq rset$, then
|
|
|
496 |
$\rdistinct{rs@rsa }{acc} = \rdistinct{rsa }{acc}$.
|
|
|
497 |
\item
|
|
|
498 |
Furthermore, if $a \in rset$ and $\rdistinct{rs}{\{a\}} = []$,
|
|
|
499 |
then $\rdistinct{(rs @ rs')}{rset} = \rdistinct{rs'}{rset}$
|
|
|
500 |
\end{itemize}
|
|
543
|
501 |
\end{lemma}
|
|
554
|
502 |
|
|
543
|
503 |
\begin{proof}
|
|
|
504 |
By induction on $rs$.
|
|
|
505 |
\end{proof}
|
|
|
506 |
\noindent
|
|
|
507 |
On the other hand, if an element $r$ does not appear in the input list waiting to be deduplicated,
|
|
|
508 |
then expanding the accumulator to include that element will not cause the output list to change:
|
|
|
509 |
\begin{lemma}
|
|
|
510 |
The accumulator can be augmented to include elements not appearing in the input list,
|
|
|
511 |
and the output will not change.
|
|
|
512 |
\begin{itemize}
|
|
|
513 |
\item
|
|
593
|
514 |
If $r \notin rs$, then $\rdistinct{rs}{acc} = \rdistinct{rs}{\{r\} \cup acc}$.
|
|
543
|
515 |
\item
|
|
|
516 |
Particularly, when $acc = \varnothing$ and $rs$ de-duplicated, we have\\
|
|
|
517 |
\[ \rdistinct{rs}{\varnothing} = rs \]
|
|
|
518 |
\end{itemize}
|
|
|
519 |
\end{lemma}
|
|
|
520 |
\begin{proof}
|
|
|
521 |
The first half is by induction on $rs$. The second half is a corollary of the first.
|
|
|
522 |
\end{proof}
|
|
|
523 |
\noindent
|
|
|
524 |
The next property gives the condition for
|
|
|
525 |
when $\rdistinct{\_}{\_}$ becomes an identical mapping
|
|
|
526 |
for any prefix of an input list, in other words, when can
|
|
|
527 |
we ``push out" the arguments of $\rdistinct{\_}{\_}$:
|
|
555
|
528 |
\begin{lemma}\label{distinctRdistinctAppend}
|
|
554
|
529 |
If $\textit{isDistinct} \; rs_1$, and $rs_1 \cap acc = \varnothing$,
|
|
555
|
530 |
then
|
|
553
|
531 |
\[\textit{rdistinct}\; (rs_1 @ rsa)\;\, acc
|
|
|
532 |
= rs_1@(\textit{rdistinct} rsa \; (acc \cup rs_1))\]
|
|
543
|
533 |
\end{lemma}
|
|
554
|
534 |
\noindent
|
|
555
|
535 |
In other words, it can be taken out and left untouched in the output.
|
|
543
|
536 |
\begin{proof}
|
|
593
|
537 |
By an induction on $rs_1$, where $rsa$ and $acc$ are allowed to be arbitrary.
|
|
543
|
538 |
\end{proof}
|
|
554
|
539 |
\noindent
|
|
|
540 |
$\rdistinct{}{}$ removes any element in anywhere of a list, if it
|
|
|
541 |
had appeared previously:
|
|
|
542 |
\begin{lemma}\label{distinctRemovesMiddle}
|
|
|
543 |
The two properties hold if $r \in rs$:
|
|
|
544 |
\begin{itemize}
|
|
|
545 |
\item
|
|
555
|
546 |
$\rdistinct{rs}{rset} = \rdistinct{(rs @ [r])}{rset}$\\
|
|
|
547 |
and\\
|
|
554
|
548 |
$\rdistinct{(ab :: rs @ [ab])}{rset'} = \rdistinct{(ab :: rs)}{rset'}$
|
|
|
549 |
\item
|
|
555
|
550 |
$\rdistinct{ (rs @ rs') }{rset} = \rdistinct{rs @ [r] @ rs'}{rset}$\\
|
|
|
551 |
and\\
|
|
554
|
552 |
$\rdistinct{(ab :: rs @ [ab] @ rs'')}{rset'} =
|
|
593
|
553 |
\rdistinct{(ab :: rs @ rs'')}{rset'}$
|
|
554
|
554 |
\end{itemize}
|
|
|
555 |
\end{lemma}
|
|
|
556 |
\noindent
|
|
|
557 |
\begin{proof}
|
|
593
|
558 |
By induction on $rs$. All other variables are allowed to be arbitrary.
|
|
|
559 |
The second half of the lemma requires the first half.
|
|
|
560 |
Note that for each half's two sub-propositions need to be proven concurrently,
|
|
|
561 |
so that the induction goes through.
|
|
554
|
562 |
\end{proof}
|
|
|
563 |
|
|
555
|
564 |
\noindent
|
|
|
565 |
This allows us to prove ``Idempotency" of $\rdistinct{}{}$ of some kind:
|
|
|
566 |
\begin{lemma}\label{rdistinctConcatGeneral}
|
|
|
567 |
The following equalities involving multiple applications of $\rdistinct{}{}$ hold:
|
|
|
568 |
\begin{itemize}
|
|
|
569 |
\item
|
|
|
570 |
$\rdistinct{(rs @ rs')}{\varnothing} = \rdistinct{((\rdistinct{rs}{\varnothing})@ rs')}{\varnothing}$
|
|
|
571 |
\item
|
|
|
572 |
$\rdistinct{(rs @ rs')}{\varnothing} = \rdistinct{(\rdistinct{rs}{\varnothing} @ rs')}{\varnothing}$
|
|
|
573 |
\item
|
|
|
574 |
If $rset' \subseteq rset$, then $\rdistinct{rs}{rset} =
|
|
|
575 |
\rdistinct{(\rdistinct{rs}{rset'})}{rset}$. As a corollary
|
|
|
576 |
of this,
|
|
|
577 |
\item
|
|
|
578 |
$\rdistinct{(rs @ rs')}{rset} = \rdistinct{
|
|
|
579 |
(\rdistinct{rs}{\varnothing}) @ rs')}{rset}$. This
|
|
|
580 |
gives another corollary use later:
|
|
|
581 |
\item
|
|
|
582 |
If $a \in rset$, then $\rdistinct{(rs @ rs')}{rset} = \rdistinct{
|
|
|
583 |
(\rdistinct{(a :: rs)}{\varnothing} @ rs')}{rset} $,
|
|
|
584 |
|
|
|
585 |
\end{itemize}
|
|
|
586 |
\end{lemma}
|
|
|
587 |
\begin{proof}
|
|
|
588 |
By \ref{rdistinctDoesTheJob} and \ref{distinctRemovesMiddle}.
|
|
|
589 |
\end{proof}
|
|
|
590 |
|
|
553
|
591 |
\subsubsection{The Properties of $\backslash_r$, $\backslash_{rsimp}$, $\textit{Rflts}$ and $\textit{Rsimp}_{ALTS}$}
|
|
|
592 |
We give in this subsection some properties of how $\backslash_r$, $\backslash_{rsimp}$, $\textit{Rflts}$ and $\textit{Rsimp}_{ALTS} $ interact with each other and with $@$, the concatenation operator.
|
|
543
|
593 |
These will be helpful in later closed form proofs, when
|
|
|
594 |
we want to transform the ways in which multiple functions involving
|
|
|
595 |
those are composed together
|
|
|
596 |
in interleaving derivative and simplification steps.
|
|
|
597 |
|
|
|
598 |
When the function $\textit{Rflts}$
|
|
|
599 |
is applied to the concatenation of two lists, the output can be calculated by first applying the
|
|
|
600 |
functions on two lists separately, and then concatenating them together.
|
|
554
|
601 |
\begin{lemma}\label{rfltsProps}
|
|
543
|
602 |
The function $\rflts$ has the below properties:\\
|
|
|
603 |
\begin{itemize}
|
|
|
604 |
\item
|
|
554
|
605 |
$\rflts \; (rs_1 @ rs_2) = \rflts \; rs_1 @ \rflts \; rs_2$
|
|
|
606 |
\item
|
|
|
607 |
If $r \neq \RZERO$ and $\nexists rs_1. r = \RALTS{rs}_1$, then $\rflts \; (r::rs) = r :: \rflts \; rs$
|
|
|
608 |
\item
|
|
|
609 |
$\rflts \; (rs @ [\RZERO]) = \rflts \; rs$
|
|
|
610 |
\item
|
|
|
611 |
$\rflts \; (rs' @ [\RALTS{rs}]) = \rflts \; rs'@rs$
|
|
|
612 |
\item
|
|
|
613 |
$\rflts \; (rs @ [\RONE]) = \rflts \; rs @ [\RONE]$
|
|
|
614 |
\item
|
|
|
615 |
If $r \neq \RZERO$ and $\nexists rs'. r = \RALTS{rs'}$ then $\rflts \; (rs @ [r])
|
|
|
616 |
= (\rflts \; rs) @ [r]$
|
|
555
|
617 |
\item
|
|
|
618 |
If $r = \RALTS{rs}$ and $r \in rs'$ then for all $r_1 \in rs.
|
|
|
619 |
r_1 \in \rflts \; rs'$.
|
|
|
620 |
\item
|
|
|
621 |
$\rflts \; (rs_a @ \RZERO :: rs_b) = \rflts \; (rs_a @ rs_b)$
|
|
543
|
622 |
\end{itemize}
|
|
|
623 |
\end{lemma}
|
|
|
624 |
\noindent
|
|
|
625 |
\begin{proof}
|
|
555
|
626 |
By induction on $rs_1$ in the first sub-lemma, and induction on $r$ in the second part,
|
|
|
627 |
and induction on $rs$, $rs'$, $rs$, $rs'$, $rs_a$ in the third, fourth, fifth, sixth and
|
|
|
628 |
last sub-lemma.
|
|
543
|
629 |
\end{proof}
|
|
555
|
630 |
|
|
554
|
631 |
\subsubsection{The $RL$ Function: Language Interpretation of $\textit{Rrexp}$s}
|
|
|
632 |
Much like the definition of $L$ on plain regular expressions, one could also
|
|
|
633 |
define the language interpretation of $\rrexp$s.
|
|
|
634 |
\begin{center}
|
|
593
|
635 |
\begin{tabular}{lcl}
|
|
|
636 |
$RL \; (\ZERO)$ & $\dn$ & $\phi$\\
|
|
|
637 |
$RL \; (\ONE)$ & $\dn$ & $\{[]\}$\\
|
|
|
638 |
$RL \; (c)$ & $\dn$ & $\{[c]\}$\\
|
|
|
639 |
$RL \; \sum rs$ & $\dn$ & $ \bigcup_{r \in rs} (RL \; r)$\\
|
|
|
640 |
$RL \; (r_1 \cdot r_2)$ & $\dn$ & $ RL \; (r_1) @ RL \; (r_2)$\\
|
|
|
641 |
$RL \; (r^*)$ & $\dn$ & $ (RL(r))^*$
|
|
|
642 |
\end{tabular}
|
|
554
|
643 |
\end{center}
|
|
|
644 |
\noindent
|
|
|
645 |
The main use of $RL$ is to establish some connections between $\rsimp{}$
|
|
|
646 |
and $\rnullable{}$:
|
|
|
647 |
\begin{lemma}
|
|
|
648 |
The following properties hold:
|
|
|
649 |
\begin{itemize}
|
|
|
650 |
\item
|
|
|
651 |
If $\rnullable{r}$, then $\rsimp{r} \neq \RZERO$.
|
|
|
652 |
\item
|
|
|
653 |
$\rnullable{r \backslash s} \quad $ if and only if $\quad \rnullable{\rderssimp{r}{s}}$.
|
|
|
654 |
\end{itemize}
|
|
|
655 |
\end{lemma}
|
|
|
656 |
\begin{proof}
|
|
|
657 |
The first part is by induction on $r$.
|
|
|
658 |
The second part is true because property
|
|
|
659 |
\[ RL \; r = RL \; (\rsimp{r})\] holds.
|
|
|
660 |
\end{proof}
|
|
593
|
661 |
|
|
554
|
662 |
\subsubsection{$\rsimp{}$ is Non-Increasing}
|
|
|
663 |
In this subsection, we prove that the function $\rsimp{}$ does not
|
|
|
664 |
make the $\llbracket \rrbracket_r$ size increase.
|
|
543
|
665 |
|
|
|
666 |
|
|
554
|
667 |
\begin{lemma}\label{rsimpSize}
|
|
|
668 |
$\llbracket \rsimp{r} \rrbracket_r \leq \llbracket r \rrbracket_r$
|
|
|
669 |
\end{lemma}
|
|
|
670 |
\subsubsection{Simplified $\textit{Rrexp}$s are Good}
|
|
|
671 |
We formalise the notion of ``good" regular expressions,
|
|
|
672 |
which means regular expressions that
|
|
|
673 |
are not fully simplified. For alternative regular expressions that means they
|
|
|
674 |
do not contain any nested alternatives like
|
|
|
675 |
\[ r_1 + (r_2 + r_3) \], un-removed $\RZERO$s like \[\RZERO + r\]
|
|
|
676 |
or duplicate elements in a children regular expression list like \[ \sum [r, r, \ldots]\]:
|
|
|
677 |
\begin{center}
|
|
|
678 |
\begin{tabular}{@{}lcl@{}}
|
|
|
679 |
$\good\; \RZERO$ & $\dn$ & $\textit{false}$\\
|
|
|
680 |
$\good\; \RONE$ & $\dn$ & $\textit{true}$\\
|
|
|
681 |
$\good\; \RCHAR{c}$ & $\dn$ & $\btrue$\\
|
|
|
682 |
$\good\; \RALTS{[]}$ & $\dn$ & $\bfalse$\\
|
|
|
683 |
$\good\; \RALTS{[r]}$ & $\dn$ & $\bfalse$\\
|
|
|
684 |
$\good\; \RALTS{r_1 :: r_2 :: rs}$ & $\dn$ &
|
|
|
685 |
$\textit{isDistinct} \; (r_1 :: r_2 :: rs) \;$\\
|
|
593
|
686 |
& & $\textit{and}\; (\forall r' \in (r_1 :: r_2 :: rs).\; \good \; r'\; \, \textit{and}\; \, \textit{nonAlt}\; r')$\\
|
|
554
|
687 |
$\good \; \RSEQ{\RZERO}{r}$ & $\dn$ & $\bfalse$\\
|
|
|
688 |
$\good \; \RSEQ{\RONE}{r}$ & $\dn$ & $\bfalse$\\
|
|
|
689 |
$\good \; \RSEQ{r}{\RZERO}$ & $\dn$ & $\bfalse$\\
|
|
|
690 |
$\good \; \RSEQ{r_1}{r_2}$ & $\dn$ & $\good \; r_1 \;\, \textit{and} \;\, \good \; r_2$\\
|
|
|
691 |
$\good \; \RSTAR{r}$ & $\dn$ & $\btrue$\\
|
|
|
692 |
\end{tabular}
|
|
|
693 |
\end{center}
|
|
|
694 |
\noindent
|
|
|
695 |
The predicate $\textit{nonAlt}$ evaluates to true when the regular expression is not an
|
|
|
696 |
alternative, and false otherwise.
|
|
|
697 |
The $\good$ property is preserved under $\rsimp_{ALTS}$, provided that
|
|
|
698 |
its non-empty argument list of expressions are all good themsleves, and $\textit{nonAlt}$,
|
|
|
699 |
and unique:
|
|
|
700 |
\begin{lemma}\label{rsimpaltsGood}
|
|
|
701 |
If $rs \neq []$ and forall $r \in rs. \textit{nonAlt} \; r$ and $\textit{isDistinct} \; rs$,
|
|
|
702 |
then $\good \; (\rsimpalts \; rs)$ if and only if forall $r \in rs. \; \good \; r$.
|
|
|
703 |
\end{lemma}
|
|
|
704 |
\noindent
|
|
|
705 |
We also note that
|
|
|
706 |
if a regular expression $r$ is good, then $\rflts$ on the singleton
|
|
|
707 |
list $[r]$ will not break goodness:
|
|
|
708 |
\begin{lemma}\label{flts2}
|
|
|
709 |
If $\good \; r$, then forall $r' \in \rflts \; [r]. \; \good \; r'$ and $\textit{nonAlt} \; r'$.
|
|
|
710 |
\end{lemma}
|
|
|
711 |
\begin{proof}
|
|
|
712 |
By an induction on $r$.
|
|
|
713 |
\end{proof}
|
|
543
|
714 |
\noindent
|
|
554
|
715 |
The other observation we make about $\rsimp{r}$ is that it never
|
|
|
716 |
comes with nested alternatives, which we describe as the $\nonnested$
|
|
|
717 |
property:
|
|
|
718 |
\begin{center}
|
|
|
719 |
\begin{tabular}{lcl}
|
|
|
720 |
$\nonnested \; \, \sum []$ & $\dn$ & $\btrue$\\
|
|
|
721 |
$\nonnested \; \, \sum ((\sum rs_1) :: rs_2)$ & $\dn$ & $\bfalse$\\
|
|
|
722 |
$\nonnested \; \, \sum (r :: rs)$ & $\dn$ & $\nonnested (\sum rs)$\\
|
|
|
723 |
$\nonnested \; \, r $ & $\dn$ & $\btrue$
|
|
|
724 |
\end{tabular}
|
|
|
725 |
\end{center}
|
|
|
726 |
\noindent
|
|
|
727 |
The $\rflts$ function
|
|
|
728 |
always opens up nested alternatives,
|
|
|
729 |
which enables $\rsimp$ to be non-nested:
|
|
|
730 |
|
|
|
731 |
\begin{lemma}\label{nonnestedRsimp}
|
|
|
732 |
$\nonnested \; (\rsimp{r})$
|
|
|
733 |
\end{lemma}
|
|
|
734 |
\begin{proof}
|
|
|
735 |
By an induction on $r$.
|
|
|
736 |
\end{proof}
|
|
|
737 |
\noindent
|
|
|
738 |
With this we could prove that a regular expressions
|
|
|
739 |
after simplification and flattening and de-duplication,
|
|
|
740 |
will not contain any alternative regular expression directly:
|
|
|
741 |
\begin{lemma}\label{nonaltFltsRd}
|
|
|
742 |
If $x \in \rdistinct{\rflts\; (\map \; \rsimp{} \; rs)}{\varnothing}$
|
|
|
743 |
then $\textit{nonAlt} \; x$.
|
|
|
744 |
\end{lemma}
|
|
|
745 |
\begin{proof}
|
|
|
746 |
By \ref{nonnestedRsimp}.
|
|
|
747 |
\end{proof}
|
|
|
748 |
\noindent
|
|
|
749 |
The other thing we know is that once $\rsimp{}$ had finished
|
|
|
750 |
processing an alternative regular expression, it will not
|
|
|
751 |
contain any $\RZERO$s, this is because all the recursive
|
|
|
752 |
calls to the simplification on the children regular expressions
|
|
|
753 |
make the children good, and $\rflts$ will not take out
|
|
|
754 |
any $\RZERO$s out of a good regular expression list,
|
|
|
755 |
and $\rdistinct{}$ will not mess with the result.
|
|
|
756 |
\begin{lemma}\label{flts3Obv}
|
|
|
757 |
The following are true:
|
|
|
758 |
\begin{itemize}
|
|
|
759 |
\item
|
|
|
760 |
If for all $r \in rs. \, \good \; r $ or $r = \RZERO$,
|
|
|
761 |
then for all $r \in \rflts\; rs. \, \good \; r$.
|
|
|
762 |
\item
|
|
|
763 |
If $x \in \rdistinct{\rflts\; (\map \; rsimp{}\; rs)}{\varnothing}$
|
|
|
764 |
and for all $y$ such that $\llbracket y \rrbracket_r$ less than
|
|
|
765 |
$\llbracket rs \rrbracket_r + 1$, either
|
|
|
766 |
$\good \; (\rsimp{y})$ or $\rsimp{y} = \RZERO$,
|
|
|
767 |
then $\good \; x$.
|
|
|
768 |
\end{itemize}
|
|
|
769 |
\end{lemma}
|
|
|
770 |
\begin{proof}
|
|
|
771 |
The first part is by induction on $rs$, where the induction
|
|
|
772 |
rule is the inductive cases for $\rflts$.
|
|
|
773 |
The second part is a corollary from the first part.
|
|
|
774 |
\end{proof}
|
|
543
|
775 |
|
|
554
|
776 |
And this leads to good structural property of $\rsimp{}$,
|
|
|
777 |
that after simplification, a regular expression is
|
|
|
778 |
either good or $\RZERO$:
|
|
|
779 |
\begin{lemma}\label{good1}
|
|
|
780 |
For any r-regular expression $r$, $\good \; \rsimp{r}$ or $\rsimp{r} = \RZERO$.
|
|
|
781 |
\end{lemma}
|
|
|
782 |
\begin{proof}
|
|
|
783 |
By an induction on $r$. The inductive measure is the size $\llbracket \rrbracket_r$.
|
|
|
784 |
Lemma \ref{rsimpSize} says that
|
|
|
785 |
$\llbracket \rsimp{r}\rrbracket_r$ is smaller than or equal to
|
|
|
786 |
$\llbracket r \rrbracket_r$.
|
|
|
787 |
Therefore, in the $r_1 \cdot r_2$ and $\sum rs$ case,
|
|
|
788 |
Inductive hypothesis applies to the children regular expressions
|
|
|
789 |
$r_1$, $r_2$, etc. The lemma \ref{flts3Obv}'s precondition is satisfied
|
|
|
790 |
by that as well.
|
|
|
791 |
The lemmas \ref{nonnestedRsimp} and \ref{nonaltFltsRd} are used
|
|
|
792 |
to ensure that goodness is preserved at the topmost level.
|
|
|
793 |
\end{proof}
|
|
|
794 |
We shall prove that any good regular expression is
|
|
|
795 |
a fixed-point for $\rsimp{}$.
|
|
|
796 |
First we prove an auxiliary lemma:
|
|
|
797 |
\begin{lemma}\label{goodaltsNonalt}
|
|
|
798 |
If $\good \; \sum rs$, then $\rflts\; rs = rs$.
|
|
|
799 |
\end{lemma}
|
|
|
800 |
\begin{proof}
|
|
|
801 |
By an induction on $\sum rs$. The inductive rules are the cases
|
|
|
802 |
for $\good$.
|
|
|
803 |
\end{proof}
|
|
|
804 |
\noindent
|
|
|
805 |
Now we are ready to prove that good regular expressions are invariant
|
|
|
806 |
of $\rsimp{}$ application:
|
|
|
807 |
\begin{lemma}\label{test}
|
|
|
808 |
If $\good \;r$ then $\rsimp{r} = r$.
|
|
|
809 |
\end{lemma}
|
|
|
810 |
\begin{proof}
|
|
|
811 |
By an induction on the inductive cases of $\good$.
|
|
|
812 |
The lemma \ref{goodaltsNonalt} is used in the alternative
|
|
|
813 |
case where 2 or more elements are present in the list.
|
|
|
814 |
\end{proof}
|
|
555
|
815 |
\noindent
|
|
|
816 |
Given below is a property involving $\rflts$, $\rdistinct{}{}$, $\rsimp{}$ and $\rsimp_{ALTS}$,
|
|
|
817 |
which requires $\ref{good1}$ to go through smoothly.
|
|
|
818 |
It says that an application of $\rsimp_{ALTS}$ can be "absorbed",
|
|
|
819 |
if it its output is concatenated with a list and then applied to $\rflts$.
|
|
|
820 |
\begin{lemma}\label{flattenRsimpalts}
|
|
|
821 |
$\rflts \; ( (\rsimp_{ALTS} \;
|
|
|
822 |
(\rdistinct{(\rflts \; (\map \; \rsimp{}\; rs))}{\varnothing})) ::
|
|
|
823 |
\map \; \rsimp{} \; rs' ) =
|
|
|
824 |
\rflts \; ( (\rdistinct{(\rflts \; (\map \; \rsimp{}\; rs))}{\varnothing}) @ (
|
|
|
825 |
\map \; \rsimp{rs'}))$
|
|
554
|
826 |
|
|
593
|
827 |
|
|
555
|
828 |
\end{lemma}
|
|
|
829 |
\begin{proof}
|
|
|
830 |
By \ref{good1}.
|
|
|
831 |
\end{proof}
|
|
|
832 |
\noindent
|
|
|
833 |
|
|
|
834 |
|
|
|
835 |
|
|
|
836 |
|
|
|
837 |
|
|
|
838 |
We are also
|
|
554
|
839 |
\subsubsection{$\rsimp$ is Idempotent}
|
|
|
840 |
The idempotency of $\rsimp$ is very useful in
|
|
|
841 |
manipulating regular expression terms into desired
|
|
|
842 |
forms so that key steps allowing further rewriting to closed forms
|
|
|
843 |
are possible.
|
|
|
844 |
\begin{lemma}\label{rsimpIdem}
|
|
593
|
845 |
$\rsimp{r} = \rsimp{\rsimp{r}}$
|
|
554
|
846 |
\end{lemma}
|
|
|
847 |
|
|
|
848 |
\begin{proof}
|
|
|
849 |
By \ref{test} and \ref{good1}.
|
|
|
850 |
\end{proof}
|
|
|
851 |
\noindent
|
|
|
852 |
This property means we do not have to repeatedly
|
|
|
853 |
apply simplification in each step, which justifies
|
|
|
854 |
our definition of $\blexersimp$.
|
|
|
855 |
|
|
532
|
856 |
|
|
554
|
857 |
On the other hand, we could repeat the same $\rsimp{}$ applications
|
|
|
858 |
on regular expressions as many times as we want, if we have at least
|
|
|
859 |
one simplification applied to it, and apply it wherever we would like to:
|
|
|
860 |
\begin{corollary}\label{headOneMoreSimp}
|
|
555
|
861 |
The following properties hold, directly from \ref{rsimpIdem}:
|
|
|
862 |
|
|
|
863 |
\begin{itemize}
|
|
|
864 |
\item
|
|
|
865 |
$\map \; \rsimp{(r :: rs)} = \map \; \rsimp{} \; (\rsimp{r} :: rs)$
|
|
|
866 |
\item
|
|
|
867 |
$\rsimp{(\RALTS{rs})} = \rsimp{(\RALTS{\map \; \rsimp{} \; rs})}$
|
|
|
868 |
\end{itemize}
|
|
554
|
869 |
\end{corollary}
|
|
|
870 |
\noindent
|
|
|
871 |
This will be useful in later closed form proof's rewriting steps.
|
|
|
872 |
Similarly, we point out the following useful facts below:
|
|
|
873 |
\begin{lemma}
|
|
|
874 |
The following equalities hold if $r = \rsimp{r'}$ for some $r'$:
|
|
|
875 |
\begin{itemize}
|
|
|
876 |
\item
|
|
|
877 |
If $r = \sum rs$ then $\rsimpalts \; rs = \sum rs$.
|
|
|
878 |
\item
|
|
|
879 |
If $r = \sum rs$ then $\rdistinct{rs}{\varnothing} = rs$.
|
|
|
880 |
\item
|
|
|
881 |
$\rsimpalts \; (\rdistinct{\rflts \; [r]}{\varnothing}) = r$.
|
|
|
882 |
\end{itemize}
|
|
|
883 |
\end{lemma}
|
|
|
884 |
\begin{proof}
|
|
|
885 |
By application of \ref{rsimpIdem} and \ref{good1}.
|
|
|
886 |
\end{proof}
|
|
|
887 |
|
|
|
888 |
\noindent
|
|
|
889 |
With the idempotency of $\rsimp{}$ and its corollaries,
|
|
|
890 |
we can start proving some key equalities leading to the
|
|
|
891 |
closed forms.
|
|
|
892 |
Now presented are a few equivalent terms under $\rsimp{}$.
|
|
|
893 |
We use $r_1 \sequal r_2 $ here to denote $\rsimp{r_1} = \rsimp{r_2}$.
|
|
|
894 |
\begin{lemma}
|
|
593
|
895 |
\begin{itemize}
|
|
|
896 |
The following equivalence hold:
|
|
554
|
897 |
\item
|
|
|
898 |
$\rsimpalts \; (\RZERO :: rs) \sequal \rsimpalts\; rs$
|
|
|
899 |
\item
|
|
|
900 |
$\rsimpalts \; rs \sequal \rsimpalts (\map \; \rsimp{} \; rs)$
|
|
|
901 |
\item
|
|
|
902 |
$\RALTS{\RALTS{rs}} \sequal \RALTS{rs}$
|
|
555
|
903 |
\item
|
|
|
904 |
$\sum ((\sum rs_a) :: rs_b) \sequal \sum rs_a @ rs_b$
|
|
|
905 |
\item
|
|
|
906 |
$\RALTS{rs} = \RALTS{\map \; \rsimp{} \; rs}$
|
|
554
|
907 |
\end{itemize}
|
|
|
908 |
\end{lemma}
|
|
555
|
909 |
\begin{proof}
|
|
|
910 |
By induction on the lists involved.
|
|
|
911 |
\end{proof}
|
|
|
912 |
\noindent
|
|
|
913 |
Similarly,
|
|
|
914 |
we introduce the equality for $\sum$ when certain child regular expressions
|
|
|
915 |
are $\sum$ themselves:
|
|
|
916 |
\begin{lemma}\label{simpFlatten3}
|
|
|
917 |
One can flatten the inside $\sum$ of a $\sum$ if it is being
|
|
|
918 |
simplified. Concretely,
|
|
|
919 |
\begin{itemize}
|
|
|
920 |
\item
|
|
|
921 |
If for all $r \in rs, rs', rs''$, we have $\good \; r $
|
|
|
922 |
or $r = \RZERO$, then $\sum (rs' @ rs @ rs'') \sequal
|
|
|
923 |
\sum (rs' @ [\sum rs] @ rs'')$ holds. As a corollary,
|
|
|
924 |
\item
|
|
|
925 |
$\sum (rs' @ [\sum rs] @ rs'') \sequal \sum (rs' @ rs @ rs'')$
|
|
|
926 |
\end{itemize}
|
|
|
927 |
\end{lemma}
|
|
|
928 |
\begin{proof}
|
|
|
929 |
By rewriting steps involving the use of \ref{test} and \ref{rdistinctConcatGeneral}.
|
|
|
930 |
The second sub-lemma is a corollary of the previous.
|
|
|
931 |
\end{proof}
|
|
|
932 |
%Rewriting steps not put in--too long and complicated-------------------------------
|
|
|
933 |
\begin{comment}
|
|
|
934 |
\begin{center}
|
|
|
935 |
$\rsimp{\sum (rs' @ rs @ rs'')} \stackrel{def of bsimp}{=}$ \\
|
|
|
936 |
$\rsimpalts \; (\rdistinct{\rflts \; ((\map \; \rsimp{}\; rs') @ (\map \; \rsimp{} \; rs ) @ (\map \; \rsimp{} \; rs''))}{\varnothing})$ \\
|
|
|
937 |
$\stackrel{by \ref{test}}{=}
|
|
|
938 |
\rsimpalts \; (\rdistinct{(\rflts \; rs' @ \rflts \; rs @ \rflts \; rs'')}{
|
|
|
939 |
\varnothing})$\\
|
|
|
940 |
$\stackrel{by \ref{rdistinctConcatGeneral}}{=}
|
|
|
941 |
\rsimpalts \; (\rdistinct{\rflts \; rs'}{\varnothing} @ \rdistinct{(
|
|
|
942 |
\rflts\; rs @ \rflts \; rs'')}{\rflts \; rs'})$\\
|
|
593
|
943 |
|
|
555
|
944 |
\end{center}
|
|
|
945 |
\end{comment}
|
|
|
946 |
%Rewriting steps not put in--too long and complicated-------------------------------
|
|
554
|
947 |
\noindent
|
|
|
948 |
We need more equalities like the above to enable a closed form,
|
|
|
949 |
but to proceed we need to introduce two rewrite relations,
|
|
|
950 |
to make things smoother.
|
|
557
|
951 |
\subsubsection{The rewrite relation $\hrewrite$ , $\scfrewrites$ , $\frewrite$ and $\grewrite$}
|
|
554
|
952 |
Insired by the success we had in the correctness proof
|
|
|
953 |
in \ref{Bitcoded2}, where we invented
|
|
555
|
954 |
a term rewriting system to capture the similarity between terms,
|
|
|
955 |
we follow suit here defining simplification
|
|
|
956 |
steps as rewriting steps. This allows capturing
|
|
|
957 |
similarities between terms that would be otherwise
|
|
|
958 |
hard to express.
|
|
|
959 |
|
|
557
|
960 |
We use $\hrewrite$ for one-step atomic rewrite of
|
|
|
961 |
regular expression simplification,
|
|
555
|
962 |
$\frewrite$ for rewrite of list of regular expressions that
|
|
|
963 |
include all operations carried out in $\rflts$, and $\grewrite$ for
|
|
|
964 |
rewriting a list of regular expressions possible in both $\rflts$ and $\rdistinct{}{}$.
|
|
|
965 |
Their reflexive transitive closures are used to denote zero or many steps,
|
|
|
966 |
as was the case in the previous chapter.
|
|
554
|
967 |
The presentation will be more concise than that in \ref{Bitcoded2}.
|
|
|
968 |
To differentiate between the rewriting steps for annotated regular expressions
|
|
|
969 |
and $\rrexp$s, we add characters $h$ and $g$ below the squig arrow symbol
|
|
|
970 |
to mean atomic simplification transitions
|
|
|
971 |
of $\rrexp$s and $\rrexp$ lists, respectively.
|
|
|
972 |
|
|
555
|
973 |
|
|
|
974 |
|
|
593
|
975 |
List of one-step rewrite rules for $\rrexp$ ($\hrewrite$):
|
|
555
|
976 |
|
|
|
977 |
|
|
554
|
978 |
\begin{center}
|
|
593
|
979 |
\begin{mathpar}
|
|
|
980 |
\inferrule[RSEQ0L]{}{\RZERO \cdot r_2 \hrewrite \RZERO\\}
|
|
555
|
981 |
|
|
593
|
982 |
\inferrule[RSEQ0R]{}{r_1 \cdot \RZERO \hrewrite \RZERO\\}
|
|
555
|
983 |
|
|
593
|
984 |
\inferrule[RSEQ1]{}{(\RONE \cdot r) \hrewrite r\\}\\
|
|
555
|
985 |
|
|
593
|
986 |
\inferrule[RSEQL]{ r_1 \hrewrite r_2}{r_1 \cdot r_3 \hrewrite r_2 \cdot r_3\\}
|
|
|
987 |
|
|
|
988 |
\inferrule[RSEQR]{ r_3 \hrewrite r_4}{r_1 \cdot r_3 \hrewrite r_1 \cdot r_4\\}\\
|
|
555
|
989 |
|
|
593
|
990 |
\inferrule[RALTSChild]{r \hrewrite r'}{\sum (rs_1 @ [r] @ rs_2) \hrewrite \sum (rs_1 @ [r'] @ rs_2)\\}
|
|
555
|
991 |
|
|
593
|
992 |
\inferrule[RALTS0]{}{\sum (rs_a @ [\RZERO] @ rs_b) \hrewrite \sum (rs_a @ rs_b)}
|
|
555
|
993 |
|
|
593
|
994 |
\inferrule[RALTSNested]{}{\sum (rs_a @ [\sum rs_1] @ rs_b) \hrewrite \sum (rs_a @ rs_1 @ rs_b)}
|
|
555
|
995 |
|
|
593
|
996 |
\inferrule[RALTSNil]{}{ \sum [] \hrewrite \RZERO\\}
|
|
555
|
997 |
|
|
593
|
998 |
\inferrule[RALTSSingle]{}{ \sum [r] \hrewrite r\\}
|
|
555
|
999 |
|
|
593
|
1000 |
\inferrule[RALTSDelete]{\\ r_1 = r_2}{\sum rs_a @ [r_1] @ rs_b @ [r_2] @ rsc \hrewrite \sum rs_a @ [r_1] @ rs_b @ rs_c}
|
|
555
|
1001 |
|
|
593
|
1002 |
\end{mathpar}
|
|
555
|
1003 |
\end{center}
|
|
554
|
1004 |
|
|
557
|
1005 |
|
|
593
|
1006 |
List of rewrite rules for a list of regular expressions,
|
|
|
1007 |
where each element can rewrite in many steps to the other (scf stands for
|
|
|
1008 |
li\emph{s}t \emph{c}losed \emph{f}orm). This relation is similar to the
|
|
|
1009 |
$\stackrel{s*}{\rightsquigarrow}$ for annotated regular expressions.
|
|
557
|
1010 |
|
|
|
1011 |
\begin{center}
|
|
593
|
1012 |
\begin{mathpar}
|
|
|
1013 |
\inferrule{}{[] \scfrewrites [] }
|
|
|
1014 |
\inferrule{r \hrewrites r' \\ rs \scfrewrites rs'}{r :: rs \scfrewrites r' :: rs'}
|
|
|
1015 |
\end{mathpar}
|
|
557
|
1016 |
\end{center}
|
|
555
|
1017 |
%frewrite
|
|
593
|
1018 |
List of one-step rewrite rules for flattening
|
|
|
1019 |
a list of regular expressions($\frewrite$):
|
|
555
|
1020 |
\begin{center}
|
|
593
|
1021 |
\begin{mathpar}
|
|
|
1022 |
\inferrule{}{\RZERO :: rs \frewrite rs \\}
|
|
555
|
1023 |
|
|
593
|
1024 |
\inferrule{}{(\sum rs) :: rs_a \frewrite rs @ rs_a \\}
|
|
555
|
1025 |
|
|
593
|
1026 |
\inferrule{rs_1 \frewrite rs_2}{r :: rs_1 \frewrite r :: rs_2}
|
|
|
1027 |
\end{mathpar}
|
|
555
|
1028 |
\end{center}
|
|
|
1029 |
|
|
593
|
1030 |
Lists of one-step rewrite rules for flattening and de-duplicating
|
|
|
1031 |
a list of regular expressions ($\grewrite$):
|
|
555
|
1032 |
\begin{center}
|
|
593
|
1033 |
\begin{mathpar}
|
|
|
1034 |
\inferrule{}{\RZERO :: rs \grewrite rs \\}
|
|
532
|
1035 |
|
|
593
|
1036 |
\inferrule{}{(\sum rs) :: rs_a \grewrite rs @ rs_a \\}
|
|
555
|
1037 |
|
|
593
|
1038 |
\inferrule{rs_1 \grewrite rs_2}{r :: rs_1 \grewrite r :: rs_2}
|
|
555
|
1039 |
|
|
593
|
1040 |
\inferrule[dB]{}{rs_a @ [a] @ rs_b @[a] @ rs_c \grewrite rs_a @ [a] @ rsb @ rsc}
|
|
|
1041 |
\end{mathpar}
|
|
555
|
1042 |
\end{center}
|
|
|
1043 |
|
|
|
1044 |
\noindent
|
|
|
1045 |
The reason why we take the trouble of defining
|
|
|
1046 |
two separate list rewriting definitions $\frewrite$ and $\grewrite$
|
|
557
|
1047 |
is to separate the two stages of simplification: flattening and de-duplicating.
|
|
|
1048 |
Sometimes $\grewrites$ is slightly too powerful
|
|
|
1049 |
so we would rather use $\frewrites$ which makes certain rewriting steps
|
|
|
1050 |
more straightforward to prove.
|
|
556
|
1051 |
For example, when proving the closed-form for the alternative regular expression,
|
|
|
1052 |
one of the rewriting steps would be:
|
|
|
1053 |
\begin{lemma}
|
|
557
|
1054 |
$\sum (\rDistinct \;\; (\map \; (\_ \backslash x) \; (\rflts \; rs)) \;\; \varnothing) \sequal
|
|
593
|
1055 |
\sum (\rDistinct \;\; (\rflts \; (\map \; (\_ \backslash x) \; rs)) \;\; \varnothing)
|
|
|
1056 |
$
|
|
556
|
1057 |
\end{lemma}
|
|
|
1058 |
\noindent
|
|
|
1059 |
Proving this is by first showing
|
|
557
|
1060 |
\begin{lemma}\label{earlyLaterDerFrewrites}
|
|
556
|
1061 |
$\map \; (\_ \backslash x) \; (\rflts \; rs) \frewrites
|
|
557
|
1062 |
\rflts \; (\map \; (\_ \backslash x) \; rs)$
|
|
556
|
1063 |
\end{lemma}
|
|
|
1064 |
\noindent
|
|
|
1065 |
and then using lemma
|
|
|
1066 |
\begin{lemma}\label{frewritesSimpeq}
|
|
|
1067 |
If $rs_1 \frewrites rs_2 $, then $\sum (\rDistinct \; rs_1 \; \varnothing) \sequal
|
|
557
|
1068 |
\sum (\rDistinct \; rs_2 \; \varnothing)$.
|
|
556
|
1069 |
\end{lemma}
|
|
557
|
1070 |
\noindent
|
|
|
1071 |
is a piece of cake.
|
|
|
1072 |
But this trick will not work for $\grewrites$.
|
|
|
1073 |
For example, a rewriting step in proving
|
|
|
1074 |
closed forms is:
|
|
|
1075 |
\begin{center}
|
|
593
|
1076 |
$\rsimp{(\rsimpalts \; (\map \; (\_ \backslash x) \; (\rdistinct{(\rflts \; (\map \; (\rsimp{} \; \circ \; (\lambda r. \rderssimp{r}{xs}))))}{\varnothing})))}$\\
|
|
|
1077 |
$=$ \\
|
|
|
1078 |
$\rsimp{(\rsimpalts \; (\rdistinct{(\map \; (\_ \backslash x) \; (\rflts \; (\map \; (\rsimp{} \; \circ \; (\lambda r. \rderssimp{r}{xs})))) ) }{\varnothing}))} $
|
|
|
1079 |
\noindent
|
|
557
|
1080 |
\end{center}
|
|
|
1081 |
For this one would hope to have a rewriting relation between the two lists involved,
|
|
|
1082 |
similar to \ref{earlyLaterDerFrewrites}. However, it turns out that
|
|
556
|
1083 |
\begin{center}
|
|
593
|
1084 |
$\map \; (\_ \backslash x) \; (\rDistinct \; rs \; rset) \grewrites \rDistinct \; (\map \;
|
|
|
1085 |
(\_ \backslash x) \; rs) \; ( rset \backslash x)$
|
|
556
|
1086 |
\end{center}
|
|
|
1087 |
\noindent
|
|
557
|
1088 |
does $\mathbf{not}$ hold in general.
|
|
|
1089 |
For this rewriting step we will introduce some slightly more cumbersome
|
|
|
1090 |
proof technique in later sections.
|
|
|
1091 |
The point is that $\frewrite$
|
|
|
1092 |
allows us to prove equivalence in a straightforward two-step method that is
|
|
|
1093 |
not possible for $\grewrite$, thereby reducing the complexity of the entire proof.
|
|
555
|
1094 |
|
|
556
|
1095 |
|
|
557
|
1096 |
\subsubsection{Terms That Can Be Rewritten Using $\hrewrites$, $\grewrites$, and $\frewrites$}
|
|
|
1097 |
We present in the below lemma a few pairs of terms that are rewritable via
|
|
|
1098 |
$\grewrites$:
|
|
|
1099 |
\begin{lemma}\label{gstarRdistinctGeneral}
|
|
|
1100 |
\begin{itemize}
|
|
|
1101 |
\item
|
|
|
1102 |
$rs_1 @ rs \grewrites rs_1 @ (\rDistinct \; rs \; rs_1)$
|
|
|
1103 |
\item
|
|
|
1104 |
$rs \grewrites \rDistinct \; rs \; \varnothing$
|
|
|
1105 |
\item
|
|
|
1106 |
$rs_a @ (\rDistinct \; rs \; rs_a) \grewrites rs_a @ (\rDistinct \;
|
|
|
1107 |
rs \; (\{\RZERO\} \cup rs_a))$
|
|
|
1108 |
\item
|
|
|
1109 |
$rs \;\; @ \;\; \rDistinct \; rs_a \; rset \grewrites rs @ \rDistinct \; rs_a \;
|
|
|
1110 |
(rest \cup rs)$
|
|
|
1111 |
|
|
|
1112 |
\end{itemize}
|
|
|
1113 |
\end{lemma}
|
|
|
1114 |
\noindent
|
|
|
1115 |
If a pair of terms $rs_1, rs_2$ are rewritable via $\grewrites$ to each other,
|
|
|
1116 |
then they are equivalent under $\rsimp{}$:
|
|
|
1117 |
\begin{lemma}\label{grewritesSimpalts}
|
|
|
1118 |
If $rs_1 \grewrites rs_2$, then
|
|
|
1119 |
we have the following equivalence hold:
|
|
|
1120 |
\begin{itemize}
|
|
|
1121 |
\item
|
|
|
1122 |
$\sum rs_1 \sequal \sum rs_2$
|
|
|
1123 |
\item
|
|
|
1124 |
$\rsimpalts \; rs_1 \sequal \rsimpalts \; rs_2$
|
|
|
1125 |
\end{itemize}
|
|
|
1126 |
\end{lemma}
|
|
|
1127 |
\noindent
|
|
|
1128 |
Here are a few connecting lemmas showing that
|
|
|
1129 |
if a list of regular expressions can be rewritten using $\grewrites$ or $\frewrites $ or
|
|
|
1130 |
$\scfrewrites$,
|
|
|
1131 |
then an alternative constructor taking the list can also be rewritten using $\hrewrites$:
|
|
|
1132 |
\begin{lemma}
|
|
|
1133 |
\begin{itemize}
|
|
|
1134 |
\item
|
|
|
1135 |
If $rs \grewrites rs'$ then $\sum rs \hrewrites \sum rs'$.
|
|
|
1136 |
\item
|
|
|
1137 |
If $rs \grewrites rs'$ then $\sum rs \hrewrites \rsimpalts \; rs'$
|
|
|
1138 |
\item
|
|
|
1139 |
If $rs_1 \scfrewrites rs_2$ then $\sum (rs @ rs_1) \hrewrites \sum (rs @ rs_2)$
|
|
|
1140 |
\item
|
|
|
1141 |
If $rs_1 \scfrewrites rs_2$ then $\sum rs_1 \hrewrites \sum rs_2$
|
|
|
1142 |
|
|
|
1143 |
\end{itemize}
|
|
|
1144 |
\end{lemma}
|
|
|
1145 |
\noindent
|
|
|
1146 |
Here comes the meat of the proof,
|
|
|
1147 |
which says that once two lists are rewritable to each other,
|
|
|
1148 |
then they are equivalent under $\rsimp{}$:
|
|
|
1149 |
\begin{lemma}
|
|
|
1150 |
If $r_1 \hrewrites r_2$ then $r_1 \sequal r_2$.
|
|
|
1151 |
\end{lemma}
|
|
|
1152 |
|
|
|
1153 |
\noindent
|
|
|
1154 |
And similar to \ref{Bitcoded2} one can preserve rewritability after taking derivative
|
|
|
1155 |
of two regular expressions on both sides:
|
|
|
1156 |
\begin{lemma}\label{interleave}
|
|
|
1157 |
If $r \hrewrites r' $ then $\rder{c}{r} \hrewrites \rder{c}{r'}$
|
|
|
1158 |
\end{lemma}
|
|
|
1159 |
\noindent
|
|
|
1160 |
This allows proving more $\mathbf{rsimp}$-equivalent terms, involving $\backslash_r$ now.
|
|
|
1161 |
\begin{lemma}\label{insideSimpRemoval}
|
|
|
1162 |
$\rsimp{\rder{c}{\rsimp{r}}} = \rsimp{\rder{c}{r}} $
|
|
|
1163 |
\end{lemma}
|
|
|
1164 |
\noindent
|
|
|
1165 |
\begin{proof}
|
|
|
1166 |
By \ref{interleave} and \ref{rsimpIdem}.
|
|
|
1167 |
\end{proof}
|
|
|
1168 |
\noindent
|
|
|
1169 |
And this unlocks more equivalent terms:
|
|
|
1170 |
\begin{lemma}\label{Simpders}
|
|
|
1171 |
As corollaries of \ref{insideSimpRemoval}, we have
|
|
|
1172 |
\begin{itemize}
|
|
|
1173 |
\item
|
|
|
1174 |
If $s \neq []$ then $\rderssimp{r}{s} = \rsimp{(\rders \; r \; s)}$.
|
|
|
1175 |
\item
|
|
|
1176 |
$\rsimpalts \; (\map \; (\_ \backslash_r x) \;
|
|
593
|
1177 |
(\rdistinct{rs}{\varnothing})) \sequal
|
|
|
1178 |
\rsimpalts \; (\rDistinct \;
|
|
|
1179 |
(\map \; (\_ \backslash_r x) rs) \;\varnothing )$
|
|
|
1180 |
\end{itemize}
|
|
|
1181 |
\end{lemma}
|
|
557
|
1182 |
\noindent
|
|
|
1183 |
|
|
|
1184 |
Finally,
|
|
|
1185 |
together with
|
|
|
1186 |
\begin{lemma}\label{rderRsimpAltsCommute}
|
|
|
1187 |
$\rder{x}{(\rsimpalts \; rs)} = \rsimpalts \; (\map \; (\rder{x}{\_}) \; rs)$
|
|
|
1188 |
\end{lemma}
|
|
|
1189 |
\noindent
|
|
|
1190 |
this leads to the first closed form--
|
|
|
1191 |
\begin{lemma}\label{altsClosedForm}
|
|
593
|
1192 |
\begin{center}
|
|
|
1193 |
$\rderssimp{(\sum rs)}{s} \sequal
|
|
|
1194 |
\sum \; (\map \; (\rderssimp{\_}{s}) \; rs)$
|
|
|
1195 |
\end{center}
|
|
557
|
1196 |
\end{lemma}
|
|
593
|
1197 |
|
|
556
|
1198 |
\noindent
|
|
557
|
1199 |
\begin{proof}
|
|
|
1200 |
By a reverse induction on the string $s$.
|
|
|
1201 |
One rewriting step, as we mentioned earlier,
|
|
|
1202 |
involves
|
|
|
1203 |
\begin{center}
|
|
|
1204 |
$\rsimpalts \; (\map \; (\_ \backslash x) \;
|
|
|
1205 |
(\rdistinct{(\rflts \; (\map \; (\rsimp{} \; \circ \;
|
|
|
1206 |
(\lambda r. \rderssimp{r}{xs}))))}{\varnothing}))
|
|
|
1207 |
\sequal
|
|
|
1208 |
\rsimpalts \; (\rdistinct{(\map \; (\_ \backslash x) \;
|
|
593
|
1209 |
(\rflts \; (\map \; (\rsimp{} \; \circ \;
|
|
557
|
1210 |
(\lambda r. \rderssimp{r}{xs})))) ) }{\varnothing}) $.
|
|
|
1211 |
\end{center}
|
|
|
1212 |
This can be proven by a combination of
|
|
|
1213 |
\ref{grewritesSimpalts}, \ref{gstarRdistinctGeneral}, \ref{rderRsimpAltsCommute}, and
|
|
|
1214 |
\ref{insideSimpRemoval}.
|
|
|
1215 |
\end{proof}
|
|
|
1216 |
\noindent
|
|
|
1217 |
This closed form has a variant which can be more convenient in later proofs:
|
|
559
|
1218 |
\begin{corollary}{altsClosedForm1}
|
|
557
|
1219 |
If $s \neq []$ then
|
|
|
1220 |
$\rderssimp \; (\sum \; rs) \; s =
|
|
|
1221 |
\rsimp{(\sum \; (\map \; \rderssimp{\_}{s} \; rs))}$.
|
|
|
1222 |
\end{corollary}
|
|
|
1223 |
\noindent
|
|
|
1224 |
The harder closed forms are the sequence and star ones.
|
|
|
1225 |
Before we go on to obtain them, some preliminary definitions
|
|
|
1226 |
are needed to make proof statements concise.
|
|
556
|
1227 |
|
|
558
|
1228 |
\section{"Closed Forms" of Sequence Regular Expressions}
|
|
|
1229 |
The problem of obataining a closed-form for sequence regular expression
|
|
|
1230 |
is constructing $(r_1 \cdot r_2) \backslash_r s$
|
|
|
1231 |
if we are only allowed to use a combination of $r_1 \backslash s''$
|
|
|
1232 |
and $r_2 \backslash s''$ , where $s''$ is from $s$.
|
|
|
1233 |
First let's look at a series of derivatives steps on a sequence
|
|
|
1234 |
regular expression, assuming that each time the first
|
|
|
1235 |
component of the sequence is always nullable):
|
|
557
|
1236 |
\begin{center}
|
|
558
|
1237 |
|
|
593
|
1238 |
$r_1 \cdot r_2 \quad \longrightarrow_{\backslash c} \quad r_1 \backslash c \cdot r_2 + r_2 \backslash c \quad \longrightarrow_{\backslash c'} \quad (r_1 \backslash cc' \cdot r_2 + r_2 \backslash c') + r_2 \backslash cc' \longrightarrow_{\backslash c''} \quad$\\
|
|
|
1239 |
$((r_1 \backslash cc'c'' \cdot r_2 + r_2 \backslash c'') + r_2 \backslash c'c'') + r_2 \backslash cc'c'' \longrightarrow_{\backslash c''} \quad
|
|
|
1240 |
\ldots$
|
|
558
|
1241 |
|
|
557
|
1242 |
\end{center}
|
|
558
|
1243 |
Roughly speaking $r_1 \cdot r_2 \backslash s$ can be expresssed as
|
|
|
1244 |
a giant alternative taking a list of terms
|
|
|
1245 |
$[r_1 \backslash_r s \cdot r_2, r_2 \backslash_r s'', r_2 \backslash_r s_1'', \ldots]$,
|
|
|
1246 |
where the head of the list is always the term
|
|
|
1247 |
representing a match involving only $r_1$, and the tail of the list consisting of
|
|
|
1248 |
terms of the shape $r_2 \backslash_r s''$, $s''$ being a suffix of $s$.
|
|
557
|
1249 |
This intuition is also echoed by IndianPaper, where they gave
|
|
|
1250 |
a pencil-and-paper derivation of $(r_1 \cdot r_2)\backslash s$:
|
|
532
|
1251 |
\begin{center}
|
|
558
|
1252 |
\begin{tabular}{c}
|
|
593
|
1253 |
$(r_1 \cdot r_2) \backslash_r (c_1 :: c_2 :: \ldots c_n) \myequiv$\\
|
|
|
1254 |
\rule{0pt}{3ex} $((r_1 \backslash_r c_1) \cdot r_2 + (\delta\; (\rnullable \; r_1) \; r_2 \backslash_r c_1)) \backslash_r (c_2 :: \ldots c_n)
|
|
|
1255 |
\myequiv$\\
|
|
|
1256 |
\rule{0pt}{3ex} $((r_1 \backslash_r c_1c_2 \cdot r_2 + (\delta \; (\rnullable \; r_1) \; r_2 \backslash_r c_1c_2))
|
|
|
1257 |
+ (\delta \ (\rnullable \; r_1 \backslash_r c)\; r_2 \backslash_r c_2)) \backslash_r (c_3 \ldots c_n)
|
|
|
1258 |
$
|
|
558
|
1259 |
\end{tabular}
|
|
557
|
1260 |
\end{center}
|
|
|
1261 |
\noindent
|
|
558
|
1262 |
The equality in above should be interpretated
|
|
|
1263 |
as language equivalence.
|
|
|
1264 |
The $\delta$ function works similarly to that of
|
|
|
1265 |
a Kronecker delta function:
|
|
|
1266 |
\[ \delta \; b\; r\]
|
|
|
1267 |
will produce $r$
|
|
|
1268 |
if $b$ evaluates to true,
|
|
|
1269 |
and $\RZERO$ otherwise.
|
|
|
1270 |
Note that their formulation
|
|
|
1271 |
\[
|
|
|
1272 |
((r_1 \backslash_r \, c_1c_2 \cdot r_2 + (\delta \; (\rnullable) \; r_1, r_2 \backslash_r c_1c_2)
|
|
|
1273 |
+ (\delta \; (\rnullable \; r_1 \backslash_r c)\; r_2 \backslash_r c_2)
|
|
|
1274 |
\]
|
|
|
1275 |
does not faithfully
|
|
|
1276 |
represent what the intermediate derivatives would actually look like
|
|
|
1277 |
when one or more intermediate results $r_1 \backslash s' \cdot r_2$ are not
|
|
|
1278 |
nullable in the head of the sequence.
|
|
|
1279 |
For example, when $r_1$ and $r_1 \backslash_r c_1$ are not nullable,
|
|
|
1280 |
the regular expression would not look like
|
|
|
1281 |
\[
|
|
|
1282 |
(r_1 \backslash_r c_1c_2 + \RZERO ) + \RZERO,
|
|
|
1283 |
\]
|
|
|
1284 |
but actually $r_1 \backslash_r c_1c_2$, the redundant $\RZERO$s will not be created in the
|
|
|
1285 |
first place.
|
|
|
1286 |
In a closed-form one would want to take into account this
|
|
|
1287 |
and generate the list of
|
|
|
1288 |
regular expressions $r_2 \backslash_r s''$ with
|
|
|
1289 |
string pairs $(s', s'')$ where $s'@s'' = s$ and
|
|
|
1290 |
$r_1 \backslash s'$ nullable.
|
|
|
1291 |
We denote the list consisting of such
|
|
|
1292 |
strings $s''$ as $\vsuf{s}{r_1}$.
|
|
|
1293 |
|
|
|
1294 |
The function $\vsuf{\_}{\_}$ is defined recursively on the structure of the string:
|
|
|
1295 |
\begin{center}
|
|
593
|
1296 |
\begin{tabular}{lcl}
|
|
|
1297 |
$\vsuf{[]}{\_} $ & $=$ & $[]$\\
|
|
|
1298 |
$\vsuf{c::cs}{r_1}$ & $ =$ & $ \textit{if} (\rnullable{r_1}) \textit{then} \; (\vsuf{cs}{(\rder{c}{r_1})}) @ [c :: cs]$\\
|
|
|
1299 |
&& $\textit{else} \; (\vsuf{cs}{(\rder{c}{r_1}) }) $
|
|
|
1300 |
\end{tabular}
|
|
558
|
1301 |
\end{center}
|
|
|
1302 |
\noindent
|
|
|
1303 |
The list is sorted in the order $r_2\backslash s''$
|
|
|
1304 |
appears in $(r_1\cdot r_2)\backslash s$.
|
|
|
1305 |
In essence, $\vsuf{\_}{\_}$ is doing a
|
|
|
1306 |
"virtual derivative" of $r_1 \cdot r_2$, but instead of producing
|
|
|
1307 |
the entire result $(r_1 \cdot r_2) \backslash s$,
|
|
|
1308 |
it only stores all the strings $s''$ such that $r_2 \backslash s''$
|
|
|
1309 |
are occurring terms in $(r_1\cdot r_2)\backslash s$.
|
|
|
1310 |
|
|
|
1311 |
To make the closed form representation
|
|
|
1312 |
more straightforward,
|
|
|
1313 |
the flattetning function $\sflat{\_}$ is used to enable the transformation from
|
|
557
|
1314 |
a left-associative nested sequence of alternatives into
|
|
|
1315 |
a flattened list:
|
|
558
|
1316 |
\[
|
|
593
|
1317 |
\sum [r_1, r_2, r_3, \ldots] \stackrel{\sflat{\_}}{\rightarrow}
|
|
|
1318 |
(\ldots ((r_1 + r_2) + r_3) + \ldots)
|
|
558
|
1319 |
\]
|
|
|
1320 |
\noindent
|
|
|
1321 |
The definitions $\sflat{\_}$, $\sflataux{\_}$ are given below.
|
|
593
|
1322 |
\begin{center}
|
|
|
1323 |
\begin{tabular}{ccc}
|
|
|
1324 |
$\sflataux{\AALTS{ }{r :: rs}}$ & $=$ & $\sflataux{r} @ rs$\\
|
|
|
1325 |
$\sflataux{\AALTS{ }{[]}}$ & $ = $ & $ []$\\
|
|
|
1326 |
$\sflataux r$ & $=$ & $ [r]$
|
|
|
1327 |
\end{tabular}
|
|
532
|
1328 |
\end{center}
|
|
|
1329 |
|
|
593
|
1330 |
\begin{center}
|
|
|
1331 |
\begin{tabular}{ccc}
|
|
|
1332 |
$\sflat{(\sum r :: rs)}$ & $=$ & $\sum (\sflataux{r} @ rs)$\\
|
|
|
1333 |
$\sflat{\sum []}$ & $ = $ & $ \sum []$\\
|
|
|
1334 |
$\sflat r$ & $=$ & $ r$
|
|
|
1335 |
\end{tabular}
|
|
557
|
1336 |
\end{center}
|
|
558
|
1337 |
\noindent
|
|
576
|
1338 |
$\sflataux{\_}$ breaks up nested alternative regular expressions
|
|
557
|
1339 |
of the $(\ldots((r_1 + r_2) + r_3) + \ldots )$(left-associated) shape
|
|
558
|
1340 |
into a "balanced" list: $\AALTS{\_}{[r_1,\, r_2 ,\, r_3, \ldots]}$.
|
|
557
|
1341 |
It will return the singleton list $[r]$ otherwise.
|
|
|
1342 |
$\sflat{\_}$ works the same as $\sflataux{\_}$, except that it keeps
|
|
|
1343 |
the output type a regular expression, not a list.
|
|
558
|
1344 |
$\sflataux{\_}$ and $\sflat{\_}$ are only recursive on the
|
|
|
1345 |
first element of the list.
|
|
|
1346 |
|
|
|
1347 |
With $\sflataux{}$ a preliminary to the closed form can be stated,
|
|
|
1348 |
where the derivative of $r_1 \cdot r_2 \backslash s$ can be
|
|
|
1349 |
flattened into a list whose head and tail meet the description
|
|
|
1350 |
we gave earlier.
|
|
|
1351 |
\begin{lemma}\label{seqSfau0}
|
|
|
1352 |
$\sflataux{\rders{(r_1 \cdot r_2) \backslash s }} = (r_1 \backslash_r s) \cdot r_2
|
|
|
1353 |
:: (\map \; (r_2 \backslash_r \_) \; (\textit{Suffix} \; s \; r1))$
|
|
|
1354 |
\end{lemma}
|
|
|
1355 |
\begin{proof}
|
|
|
1356 |
By an induction on the string $s$, where the inductive cases
|
|
|
1357 |
are split as $[]$ and $xs @ [x]$.
|
|
|
1358 |
Note the key identify holds:
|
|
|
1359 |
\[
|
|
|
1360 |
\map \; (r_2 \backslash_r \_) \; (\vsuf{[x]}{(r_1 \backslash_r xs)}) \;\; @ \;\;
|
|
|
1361 |
\map \; (\_ \backslash_r x) \; (\map \; (r_2 \backslash \_) \; (\vsuf{xs}{r_1}))
|
|
|
1362 |
\]
|
|
593
|
1363 |
=
|
|
558
|
1364 |
\[
|
|
|
1365 |
\map \; (r_2 \backslash_r \_) \; (\vsuf{xs @ [x]}{r_1})
|
|
|
1366 |
\]
|
|
|
1367 |
This enables the inductive case to go through.
|
|
|
1368 |
\end{proof}
|
|
|
1369 |
\noindent
|
|
|
1370 |
Note that this lemma does $\mathbf{not}$ depend on any
|
|
|
1371 |
specific definitions we used,
|
|
|
1372 |
allowing people investigating derivatives to get an alternative
|
|
|
1373 |
view of what $r_1 \cdot r_2$ is.
|
|
532
|
1374 |
|
|
558
|
1375 |
Now we are able to use this for the intuition that
|
|
|
1376 |
the different ways in which regular expressions are
|
|
|
1377 |
nested do not matter under $\rsimp{}$:
|
|
557
|
1378 |
\begin{center}
|
|
558
|
1379 |
$\rsimp{r} \stackrel{?}{\sequal} \rsimp{r'}$ if $r = \sum [r_1, r_2, r_3, \ldots]$
|
|
593
|
1380 |
and $r' =(\ldots ((r_1 + r_2) + r_3) + \ldots)$
|
|
557
|
1381 |
\end{center}
|
|
558
|
1382 |
Simply wrap with $\sum$ constructor and add
|
|
|
1383 |
simplifications to both sides of \ref{seqSfau0}
|
|
|
1384 |
and one gets
|
|
|
1385 |
\begin{corollary}\label{seqClosedFormGeneral}
|
|
|
1386 |
$\rsimp{\sflat{(r_1 \cdot r_2) \backslash s} }
|
|
|
1387 |
=\rsimp{(\sum ( (r_1 \backslash s) \cdot r_2 ::
|
|
593
|
1388 |
\map\; (r_2 \backslash \_) \; (\vsuf{s}{r_1})))}$
|
|
558
|
1389 |
\end{corollary}
|
|
|
1390 |
Together with the idempotency property of $\rsimp{}$ (lemma \ref{rsimpIdem}),
|
|
|
1391 |
it is possible to convert the above lemma to obtain a "closed form"
|
|
|
1392 |
for derivatives nested with simplification:
|
|
|
1393 |
\begin{lemma}\label{seqClosedForm}
|
|
|
1394 |
$\rderssimp{(r_1 \cdot r_2)}{s} = \rsimp{(\sum ((r_1 \backslash s) \cdot r_2 )
|
|
|
1395 |
:: (\map \; (r_2 \backslash \_) (\vsuf{s}{r_1})))}$
|
|
|
1396 |
\end{lemma}
|
|
|
1397 |
\begin{proof}
|
|
|
1398 |
By a case analysis of string $s$.
|
|
|
1399 |
When $s$ is empty list, the rewrite is straightforward.
|
|
|
1400 |
When $s$ is a list, one could use the corollary \ref{seqSfau0},
|
|
|
1401 |
and lemma \ref{Simpders} to rewrite the left-hand-side.
|
|
|
1402 |
\end{proof}
|
|
|
1403 |
As a corollary for this closed form, one can estimate the size
|
|
|
1404 |
of the sequence derivative $r_1 \cdot r_2 \backslash_r s$ using
|
|
|
1405 |
an easier-to-handle expression:
|
|
|
1406 |
\begin{corollary}\label{seqEstimate1}
|
|
|
1407 |
\begin{center}
|
|
557
|
1408 |
|
|
593
|
1409 |
$\llbracket \rderssimp{(r_1 \cdot r_2)}{s} \rrbracket_r = \llbracket \rsimp{(\sum ((r_1 \backslash s) \cdot r_2 )
|
|
|
1410 |
:: (\map \; (r_2 \backslash \_) (\vsuf{s}{r_1})))} \rrbracket_r$
|
|
|
1411 |
|
|
558
|
1412 |
\end{center}
|
|
|
1413 |
\end{corollary}
|
|
|
1414 |
\noindent
|
|
|
1415 |
\subsection{Closed Forms for Star Regular Expressions}
|
|
564
|
1416 |
We have shown how to control the size of the sequence regular expression $r_1\cdot r_2$ using
|
|
|
1417 |
the "closed form" of $(r_1 \cdot r_2) \backslash s$ and then
|
|
|
1418 |
the property of the $\distinct$ function.
|
|
|
1419 |
Now we try to get a bound on $r^* \backslash s$ as well.
|
|
|
1420 |
Again, we first look at how a star's derivatives evolve, if they grow maximally:
|
|
|
1421 |
\begin{center}
|
|
|
1422 |
|
|
593
|
1423 |
$r^* \quad \longrightarrow_{\backslash c} \quad (r\backslash c) \cdot r^* \quad \longrightarrow_{\backslash c'} \quad
|
|
|
1424 |
r \backslash cc' \cdot r^* + r \backslash c' \cdot r^* \quad \longrightarrow_{\backslash c''} \quad
|
|
|
1425 |
(r_1 \backslash cc'c'' \cdot r^* + r \backslash c'') + (r \backslash c'c'' \cdot r^* + r \backslash c'' \cdot r^*) \quad \longrightarrow_{\backslash c'''}
|
|
|
1426 |
\quad \ldots$
|
|
564
|
1427 |
|
|
|
1428 |
\end{center}
|
|
|
1429 |
When we have a string $s = c :: c' :: c'' \ldots$ such that $r \backslash c$, $r \backslash cc'$, $r \backslash c'$,
|
|
|
1430 |
$r \backslash cc'c''$, $r \backslash c'c''$, $r\backslash c''$ etc. are all nullable,
|
|
|
1431 |
the number of terms in $r^* \backslash s$ will grow exponentially, causing the size
|
|
|
1432 |
of the derivatives $r^* \backslash s$ to grow exponentially, even if we do not
|
|
|
1433 |
count the possible size explosions of $r \backslash c$ themselves.
|
|
|
1434 |
|
|
576
|
1435 |
Thanks to $\rflts$ and $\rDistinct$, we are able to open up regular expressions like
|
|
564
|
1436 |
$(r_1 \backslash cc'c'' \cdot r^* + r \backslash c'') +
|
|
|
1437 |
(r \backslash c'c'' \cdot r^* + r \backslash c'' \cdot r^*) $
|
|
|
1438 |
into $\RALTS{[r_1 \backslash cc'c'' \cdot r^*, r \backslash c'',
|
|
|
1439 |
r \backslash c'c'' \cdot r^*, r \backslash c'' \cdot r^*]}$
|
|
|
1440 |
and then de-duplicate terms of the form $r\backslash s' \cdot r^*$ ($s'$ being a substring of $s$).
|
|
|
1441 |
This allows us to use a similar technique as $r_1 \cdot r_2$ case,
|
|
|
1442 |
where the crux is to get an equivalent form of
|
|
|
1443 |
$\rderssimp{r^*}{s}$ with shape $\rsimp{\sum rs}$.
|
|
|
1444 |
This requires generating
|
|
558
|
1445 |
all possible sub-strings $s'$ of $s$
|
|
|
1446 |
such that $r\backslash s' \cdot r^*$ will appear
|
|
|
1447 |
as a term in $(r^*) \backslash s$.
|
|
|
1448 |
The first function we define is a single-step
|
|
|
1449 |
updating function $\starupdate$, which takes three arguments as input:
|
|
|
1450 |
the new character $c$ to take derivative with,
|
|
|
1451 |
the regular expression
|
|
|
1452 |
$r$ directly under the star $r^*$, and the
|
|
|
1453 |
list of strings $sSet$ for the derivative $r^* \backslash s$
|
|
|
1454 |
up til this point
|
|
|
1455 |
such that $(r^*) \backslash s = \sum_{s' \in sSet} (r\backslash s') \cdot r^*$
|
|
|
1456 |
(the equality is not exact, more on this later).
|
|
|
1457 |
\begin{center}
|
|
|
1458 |
\begin{tabular}{lcl}
|
|
|
1459 |
$\starupdate \; c \; r \; [] $ & $\dn$ & $[]$\\
|
|
|
1460 |
$\starupdate \; c \; r \; (s :: Ss)$ & $\dn$ & \\
|
|
|
1461 |
& & $\textit{if} \;
|
|
|
1462 |
(\rnullable \; (\rders \; r \; s))$ \\
|
|
|
1463 |
& & $\textit{then} \;\; (s @ [c]) :: [c] :: (
|
|
|
1464 |
\starupdate \; c \; r \; Ss)$ \\
|
|
|
1465 |
& & $\textit{else} \;\; (s @ [c]) :: (
|
|
|
1466 |
\starupdate \; c \; r \; Ss)$
|
|
|
1467 |
\end{tabular}
|
|
|
1468 |
\end{center}
|
|
|
1469 |
\noindent
|
|
|
1470 |
As a generalisation from characters to strings,
|
|
|
1471 |
$\starupdates$ takes a string instead of a character
|
|
|
1472 |
as the first input argument, and is otherwise the same
|
|
|
1473 |
as $\starupdate$.
|
|
|
1474 |
\begin{center}
|
|
|
1475 |
\begin{tabular}{lcl}
|
|
|
1476 |
$\starupdates \; [] \; r \; Ss$ & $=$ & $Ss$\\
|
|
|
1477 |
$\starupdates \; (c :: cs) \; r \; Ss$ & $=$ & $\starupdates \; cs \; r \; (
|
|
|
1478 |
\starupdate \; c \; r \; Ss)$
|
|
|
1479 |
\end{tabular}
|
|
|
1480 |
\end{center}
|
|
|
1481 |
\noindent
|
|
|
1482 |
For the star regular expression,
|
|
|
1483 |
its derivatives can be seen as a nested gigantic
|
|
|
1484 |
alternative similar to that of sequence regular expression's derivatives,
|
|
|
1485 |
and therefore need
|
|
|
1486 |
to be ``straightened out" as well.
|
|
|
1487 |
The function for this would be $\hflat{}$ and $\hflataux{}$.
|
|
|
1488 |
\begin{center}
|
|
|
1489 |
\begin{tabular}{lcl}
|
|
|
1490 |
$\hflataux{r_1 + r_2}$ & $\dn$ & $\hflataux{r_1} @ \hflataux{r_2}$\\
|
|
|
1491 |
$\hflataux{r}$ & $\dn$ & $[r]$
|
|
|
1492 |
\end{tabular}
|
|
|
1493 |
\end{center}
|
|
557
|
1494 |
|
|
|
1495 |
\begin{center}
|
|
558
|
1496 |
\begin{tabular}{lcl}
|
|
|
1497 |
$\hflat{r_1 + r_2}$ & $\dn$ & $\sum (\hflataux {r_1} @ \hflataux {r_2}) $\\
|
|
|
1498 |
$\hflat{r}$ & $\dn$ & $r$
|
|
|
1499 |
\end{tabular}
|
|
|
1500 |
\end{center}
|
|
|
1501 |
\noindent
|
|
|
1502 |
%MAYBE TODO: introduce createdByStar
|
|
564
|
1503 |
Again these definitions are tailor-made for dealing with alternatives that have
|
|
|
1504 |
originated from a star's derivatives, so we do not attempt to open up all possible
|
|
576
|
1505 |
regular expressions of the form $\RALTS{rs}$, where $\textit{rs}$ might not contain precisely 2
|
|
564
|
1506 |
elements.
|
|
|
1507 |
We give a predicate for such "star-created" regular expressions:
|
|
|
1508 |
\begin{center}
|
|
593
|
1509 |
\begin{tabular}{lcr}
|
|
|
1510 |
& & $\createdByStar{(\RSEQ{ra}{\RSTAR{rb}}) }$\\
|
|
|
1511 |
$\createdByStar{r_1} \land \createdByStar{r_2} $ & $ \Longrightarrow$ & $\createdByStar{(r_1 + r_2)}$
|
|
|
1512 |
\end{tabular}
|
|
|
1513 |
\end{center}
|
|
|
1514 |
|
|
|
1515 |
These definitions allows us the flexibility to talk about
|
|
|
1516 |
regular expressions in their most convenient format,
|
|
|
1517 |
for example, flattened out $\RALTS{[r_1, r_2, \ldots, r_n]} $
|
|
|
1518 |
instead of binary-nested: $((r_1 + r_2) + (r_3 + r_4)) + \ldots$.
|
|
|
1519 |
These definitions help express that certain classes of syntatically
|
|
|
1520 |
distinct regular expressions are actually the same under simplification.
|
|
|
1521 |
This is not entirely true for annotated regular expressions:
|
|
|
1522 |
%TODO: bsimp bders \neq bderssimp
|
|
|
1523 |
\begin{center}
|
|
|
1524 |
$(1+ (c\cdot \ASEQ{bs}{c^*}{c} ))$
|
|
|
1525 |
\end{center}
|
|
|
1526 |
For bit-codes, the order in which simplification is applied
|
|
|
1527 |
might cause a difference in the location they are placed.
|
|
|
1528 |
If we want something like
|
|
|
1529 |
\begin{center}
|
|
|
1530 |
$\bderssimp{r}{s} \myequiv \bsimp{\bders{r}{s}}$
|
|
|
1531 |
\end{center}
|
|
|
1532 |
Some "canonicalization" procedure is required,
|
|
|
1533 |
which either pushes all the common bitcodes to nodes
|
|
|
1534 |
as senior as possible:
|
|
|
1535 |
\begin{center}
|
|
|
1536 |
$_{bs}(_{bs_1 @ bs'}r_1 + _{bs_1 @ bs''}r_2) \rightarrow _{bs @ bs_1}(_{bs'}r_1 + _{bs''}r_2) $
|
|
|
1537 |
\end{center}
|
|
|
1538 |
or does the reverse. However bitcodes are not of interest if we are talking about
|
|
|
1539 |
the $\llbracket r \rrbracket$ size of a regex.
|
|
|
1540 |
Therefore for the ease and simplicity of producing a
|
|
|
1541 |
proof for a size bound, we are happy to restrict ourselves to
|
|
|
1542 |
unannotated regular expressions, and obtain such equalities as
|
|
|
1543 |
\begin{lemma}
|
|
|
1544 |
$\rsimp{r_1 + r_2} = \rsimp{\RALTS{\hflataux{r_1} @ \hflataux{r_2}}}$
|
|
|
1545 |
\end{lemma}
|
|
|
1546 |
|
|
|
1547 |
\begin{proof}
|
|
|
1548 |
By using the rewriting relation $\rightsquigarrow$
|
|
|
1549 |
\end{proof}
|
|
|
1550 |
%TODO: rsimp sflat
|
|
564
|
1551 |
And from this we obtain a proof that a star's derivative will be the same
|
|
|
1552 |
as if it had all its nested alternatives created during deriving being flattened out:
|
|
593
|
1553 |
For example,
|
|
|
1554 |
\begin{lemma}
|
|
|
1555 |
$\createdByStar{r} \implies \rsimp{r} = \rsimp{\RALTS{\hflataux{r}}}$
|
|
|
1556 |
\end{lemma}
|
|
|
1557 |
\begin{proof}
|
|
|
1558 |
By structural induction on $r$, where the induction rules are these of $\createdByStar{_}$.
|
|
|
1559 |
\end{proof}
|
|
564
|
1560 |
% The simplification of a flattened out regular expression, provided it comes
|
|
|
1561 |
%from the derivative of a star, is the same as the one nested.
|
|
593
|
1562 |
|
|
564
|
1563 |
|
|
|
1564 |
|
|
558
|
1565 |
We first introduce an inductive property
|
|
|
1566 |
for $\starupdate$ and $\hflataux{\_}$,
|
|
|
1567 |
it says if we do derivatives of $r^*$
|
|
|
1568 |
with a string that starts with $c$,
|
|
|
1569 |
then flatten it out,
|
|
|
1570 |
we obtain a list
|
|
|
1571 |
of the shape $\sum_{s' \in sSet} (r\backslash_r s') \cdot r^*$,
|
|
|
1572 |
where $sSet = \starupdates \; s \; r \; [[c]]$.
|
|
|
1573 |
\begin{lemma}\label{starHfauInduct}
|
|
|
1574 |
$\hflataux{(\rders{( (\rder{c}{r_0})\cdot(r_0^*))}{s})} =
|
|
|
1575 |
\map \; (\lambda s_1. (r_0 \backslash_r s_1) \cdot (r_0^*)) \;
|
|
|
1576 |
(\starupdates \; s \; r_0 \; [[c]])$
|
|
|
1577 |
\end{lemma}
|
|
|
1578 |
\begin{proof}
|
|
|
1579 |
By an induction on $s$, the inductive cases
|
|
|
1580 |
being $[]$ and $s@[c]$.
|
|
|
1581 |
\end{proof}
|
|
|
1582 |
\noindent
|
|
|
1583 |
Here is a corollary that states the lemma in
|
|
|
1584 |
a more intuitive way:
|
|
|
1585 |
\begin{corollary}
|
|
|
1586 |
$\hflataux{r^* \backslash_r (c::xs)} = \map \; (\lambda s. (r \backslash_r s) \cdot
|
|
|
1587 |
(r^*))\; (\starupdates \; c\; r\; [[c]])$
|
|
|
1588 |
\end{corollary}
|
|
|
1589 |
\noindent
|
|
|
1590 |
Note that this is also agnostic of the simplification
|
|
|
1591 |
function we defined, and is therefore of more general interest.
|
|
|
1592 |
|
|
|
1593 |
Now adding the $\rsimp{}$ bit for closed forms,
|
|
|
1594 |
we have
|
|
|
1595 |
\begin{lemma}
|
|
|
1596 |
$a :: rs \grewrites \hflataux{a} @ rs$
|
|
|
1597 |
\end{lemma}
|
|
|
1598 |
\noindent
|
|
|
1599 |
giving us
|
|
|
1600 |
\begin{lemma}\label{cbsHfauRsimpeq1}
|
|
|
1601 |
$\rsimp{a+b} = \rsimp{(\sum \hflataux{a} @ \hflataux{b})}$.
|
|
|
1602 |
\end{lemma}
|
|
|
1603 |
\noindent
|
|
|
1604 |
This yields
|
|
|
1605 |
\begin{lemma}\label{hfauRsimpeq2}
|
|
593
|
1606 |
$\rsimp{r} = \rsimp{(\sum \hflataux{r})}$
|
|
558
|
1607 |
\end{lemma}
|
|
|
1608 |
\noindent
|
|
|
1609 |
Together with the rewriting relation
|
|
|
1610 |
\begin{lemma}\label{starClosedForm6Hrewrites}
|
|
|
1611 |
$\map \; (\lambda s. (\rsimp{r \backslash_r s}) \cdot (r^*)) \; Ss
|
|
|
1612 |
\scfrewrites
|
|
593
|
1613 |
\map \; (\lambda s. (\rsimp{r \backslash_r s}) \cdot (r^*)) \; Ss$
|
|
558
|
1614 |
\end{lemma}
|
|
|
1615 |
\noindent
|
|
|
1616 |
We obtain the closed form for star regular expression:
|
|
|
1617 |
\begin{lemma}\label{starClosedForm}
|
|
|
1618 |
$\rderssimp{r^*}{c::s} =
|
|
|
1619 |
\rsimp{
|
|
|
1620 |
(\sum (\map \; (\lambda s. (\rderssimp{r}{s})\cdot r^*) \;
|
|
593
|
1621 |
(\starupdates \; s\; r \; [[c]])
|
|
558
|
1622 |
)
|
|
593
|
1623 |
)
|
|
|
1624 |
}
|
|
558
|
1625 |
$
|
|
|
1626 |
\end{lemma}
|
|
|
1627 |
\begin{proof}
|
|
|
1628 |
By an induction on $s$.
|
|
|
1629 |
The lemmas \ref{rsimpIdem}, \ref{starHfauInduct}, and \ref{hfauRsimpeq2}
|
|
|
1630 |
are used.
|
|
|
1631 |
\end{proof}
|
|
|
1632 |
\section{Estimating the Closed Forms' sizes}
|
|
|
1633 |
We now summarize the closed forms below:
|
|
|
1634 |
\begin{itemize}
|
|
|
1635 |
\item
|
|
593
|
1636 |
$\rderssimp{(\sum rs)}{s} \sequal
|
|
|
1637 |
\sum \; (\map \; (\rderssimp{\_}{s}) \; rs)$
|
|
558
|
1638 |
\item
|
|
593
|
1639 |
$\rderssimp{(r_1 \cdot r_2)}{s} \sequal \sum ((r_1 \backslash s) \cdot r_2 )
|
|
|
1640 |
:: (\map \; (r_2 \backslash \_) (\vsuf{s}{r_1}))$
|
|
558
|
1641 |
\item
|
|
|
1642 |
|
|
593
|
1643 |
$\rderssimp{r^*}{c::s} =
|
|
|
1644 |
\rsimp{
|
|
|
1645 |
(\sum (\map \; (\lambda s. (\rderssimp{r}{s})\cdot r^*) \;
|
|
558
|
1646 |
(\starupdates \; s\; r \; [[c]])
|
|
593
|
1647 |
)
|
|
|
1648 |
)
|
|
|
1649 |
}
|
|
|
1650 |
$
|
|
558
|
1651 |
\end{itemize}
|
|
|
1652 |
\noindent
|
|
|
1653 |
The closed forms on the left-hand-side
|
|
|
1654 |
are all of the same shape: $\rsimp{ (\sum rs)} $.
|
|
|
1655 |
Such regular expression will be bounded by the size of $\sum rs'$,
|
|
|
1656 |
where every element in $rs'$ is distinct, and each element
|
|
|
1657 |
can be described by some inductive sub-structures
|
|
|
1658 |
(for example when $r = r_1 \cdot r_2$ then $rs'$
|
|
|
1659 |
will be solely comprised of $r_1 \backslash s'$
|
|
|
1660 |
and $r_2 \backslash s''$, $s'$ and $s''$ being
|
|
|
1661 |
sub-strings of $s$).
|
|
|
1662 |
which will each have a size uppder bound
|
|
|
1663 |
according to inductive hypothesis, which controls $r \backslash s$.
|
|
557
|
1664 |
|
|
558
|
1665 |
We elaborate the above reasoning by a series of lemmas
|
|
|
1666 |
below, where straightforward proofs are omitted.
|
|
532
|
1667 |
\begin{lemma}
|
|
558
|
1668 |
If $\forall r \in rs. \rsize{r} $ is less than or equal to $N$,
|
|
|
1669 |
and $\textit{length} \; rs$ is less than or equal to $l$,
|
|
|
1670 |
then $\rsize{\sum rs}$ is less than or equal to $l*N + 1$.
|
|
|
1671 |
\end{lemma}
|
|
|
1672 |
\noindent
|
|
|
1673 |
If we define all regular expressions with size no
|
|
|
1674 |
more than $N$ as $\sizeNregex \; N$:
|
|
|
1675 |
\[
|
|
|
1676 |
\sizeNregex \; N \dn \{r \mid \rsize{r} \leq N \}
|
|
|
1677 |
\]
|
|
|
1678 |
Then such set is finite:
|
|
|
1679 |
\begin{lemma}\label{finiteSizeN}
|
|
|
1680 |
$\textit{isFinite}\; (\sizeNregex \; N)$
|
|
|
1681 |
\end{lemma}
|
|
|
1682 |
\begin{proof}
|
|
|
1683 |
By overestimating the set $\sizeNregex \; N + 1$
|
|
|
1684 |
using union of sets like
|
|
|
1685 |
$\{r_1 \cdot r_2 \mid r_1 \in A
|
|
|
1686 |
\text{and}
|
|
593
|
1687 |
r_2 \in A\}
|
|
558
|
1688 |
$ where $A = \sizeNregex \; N$.
|
|
|
1689 |
\end{proof}
|
|
|
1690 |
\noindent
|
|
|
1691 |
From this we get a corollary that
|
|
|
1692 |
if forall $r \in rs$, $\rsize{r} \leq N$, then the output of
|
|
|
1693 |
$\rdistinct{rs}{\varnothing}$ is a list of regular
|
|
|
1694 |
expressions of finite size depending on $N$ only.
|
|
561
|
1695 |
\begin{corollary}\label{finiteSizeNCorollary}
|
|
558
|
1696 |
Assumes that for all $r \in rs. \rsize{r} \leq N$,
|
|
|
1697 |
and the cardinality of $\sizeNregex \; N$ is $c_N$
|
|
|
1698 |
then$\rsize{\rdistinct{rs}{\varnothing}} \leq c*N$.
|
|
|
1699 |
\end{corollary}
|
|
|
1700 |
\noindent
|
|
|
1701 |
We have proven that the output of $\rdistinct{rs'}{\varnothing}$
|
|
|
1702 |
is bounded by a constant $c_N$ depending only on $N$,
|
|
|
1703 |
provided that each of $rs'$'s element
|
|
|
1704 |
is bounded by $N$.
|
|
|
1705 |
We want to apply it to our setting $\rsize{\rsimp{\sum rs}}$.
|
|
|
1706 |
|
|
|
1707 |
We show how $\rdistinct$ and $\rflts$
|
|
|
1708 |
in the simplification function together is at least as
|
|
|
1709 |
good as $\rdistinct{}{}$ alone.
|
|
|
1710 |
\begin{lemma}\label{interactionFltsDB}
|
|
|
1711 |
$\llbracket \rdistinct{(\rflts \; \textit{rs})}{\varnothing} \rrbracket_r
|
|
|
1712 |
\leq
|
|
|
1713 |
\llbracket \rdistinct{rs}{\varnothing} \rrbracket_r $.
|
|
532
|
1714 |
\end{lemma}
|
|
558
|
1715 |
\noindent
|
|
|
1716 |
The intuition is that if we remove duplicates from the $\textit{LHS}$, at least the same amount of
|
|
|
1717 |
duplicates will be removed from the list $\textit{rs}$ in the $\textit{RHS}$.
|
|
|
1718 |
|
|
|
1719 |
Now this $\rsimp{\sum rs}$ can be estimated using $\rdistinct{rs}{\varnothing}$:
|
|
|
1720 |
\begin{lemma}\label{altsSimpControl}
|
|
|
1721 |
$\rsize{\rsimp{\sum rs}} \leq \rsize{\rdistinct{rs}{\varnothing}}+ 1$
|
|
532
|
1722 |
\end{lemma}
|
|
558
|
1723 |
\begin{proof}
|
|
|
1724 |
By using \ref{interactionFltsDB}.
|
|
|
1725 |
\end{proof}
|
|
|
1726 |
\noindent
|
|
|
1727 |
which says that the size of regular expression
|
|
|
1728 |
is always smaller if we apply the full simplification
|
|
|
1729 |
rather than just one component ($\rdistinct{}{}$).
|
|
|
1730 |
|
|
|
1731 |
|
|
|
1732 |
Now we are ready to control the sizes of
|
|
|
1733 |
$r_1 \cdot r_2 \backslash s$, $r^* \backslash s$.
|
|
|
1734 |
\begin{theorem}
|
|
593
|
1735 |
For any regex $r$, $\exists N_r. \forall s. \; \rsize{\rderssimp{r}{s}} \leq N_r$
|
|
558
|
1736 |
\end{theorem}
|
|
|
1737 |
\noindent
|
|
|
1738 |
\begin{proof}
|
|
593
|
1739 |
We prove this by induction on $r$. The base cases for $\RZERO$,
|
|
|
1740 |
$\RONE $ and $\RCHAR{c}$ are straightforward.
|
|
|
1741 |
In the sequence $r_1 \cdot r_2$ case,
|
|
|
1742 |
the inductive hypotheses state
|
|
|
1743 |
$\exists N_1. \forall s. \; \llbracket \rderssimp{r}{s} \rrbracket \leq N_1$ and
|
|
|
1744 |
$\exists N_2. \forall s. \; \llbracket \rderssimp{r_2}{s} \rrbracket \leq N_2$.
|
|
562
|
1745 |
|
|
593
|
1746 |
When the string $s$ is not empty, we can reason as follows
|
|
|
1747 |
%
|
|
|
1748 |
\begin{center}
|
|
|
1749 |
\begin{tabular}{lcll}
|
|
558
|
1750 |
& & $ \llbracket \rderssimp{r_1\cdot r_2 }{s} \rrbracket_r $\\
|
|
561
|
1751 |
& $ = $ & $\llbracket \rsimp{(\sum(r_1 \backslash_{rsimp} s \cdot r_2 \; \; :: \; \;
|
|
593
|
1752 |
\map \; (r_2\backslash_{rsimp} \_)\; (\vsuf{s}{r})))} \rrbracket_r $ & (1) \\
|
|
|
1753 |
& $\leq$ & $\llbracket \rdistinct{(r_1 \backslash_{rsimp} s \cdot r_2 \; \; :: \; \;
|
|
|
1754 |
\map \; (r_2\backslash_{rsimp} \_)\; (\vsuf{s}{r}))}{\varnothing} \rrbracket_r + 1$ & (2) \\
|
|
|
1755 |
& $\leq$ & $2 + N_1 + \rsize{r_2} + (N_2 * (card\;(\sizeNregex \; N_2)))$ & (3)\\
|
|
558
|
1756 |
\end{tabular}
|
|
|
1757 |
\end{center}
|
|
561
|
1758 |
\noindent
|
|
|
1759 |
(1) is by the corollary \ref{seqEstimate1}.
|
|
|
1760 |
(2) is by \ref{altsSimpControl}.
|
|
|
1761 |
(3) is by \ref{finiteSizeNCorollary}.
|
|
562
|
1762 |
|
|
|
1763 |
|
|
|
1764 |
Combining the cases when $s = []$ and $s \neq []$, we get (4):
|
|
|
1765 |
\begin{center}
|
|
|
1766 |
\begin{tabular}{lcll}
|
|
|
1767 |
$\rsize{(r_1 \cdot r_2) \backslash_r s}$ & $\leq$ &
|
|
|
1768 |
$max \; (2 + N_1 +
|
|
|
1769 |
\llbracket r_2 \rrbracket_r +
|
|
|
1770 |
N_2 * (card\; (\sizeNregex \; N_2))) \; \rsize{r_1\cdot r_2}$ & (4)
|
|
|
1771 |
\end{tabular}
|
|
|
1772 |
\end{center}
|
|
558
|
1773 |
|
|
562
|
1774 |
We reason similarly for $\STAR$.
|
|
|
1775 |
The inductive hypothesis is
|
|
|
1776 |
$\exists N. \forall s. \; \llbracket \rderssimp{r}{s} \rrbracket \leq N$.
|
|
564
|
1777 |
Let $n_r = \llbracket r^* \rrbracket_r$.
|
|
562
|
1778 |
When $s = c :: cs$ is not empty,
|
|
|
1779 |
\begin{center}
|
|
593
|
1780 |
\begin{tabular}{lcll}
|
|
562
|
1781 |
& & $ \llbracket \rderssimp{r^* }{c::cs} \rrbracket_r $\\
|
|
|
1782 |
& $ = $ & $\llbracket \rsimp{(\sum (\map \; (\lambda s. (r \backslash_{rsimp} s) \cdot r^*) \; (\starupdates\;
|
|
593
|
1783 |
cs \; r \; [[c]] )) )} \rrbracket_r $ & (5) \\
|
|
|
1784 |
& $\leq$ & $\llbracket
|
|
|
1785 |
\rdistinct{
|
|
|
1786 |
(\map \;
|
|
|
1787 |
(\lambda s. (r \backslash_{rsimp} s) \cdot r^*) \;
|
|
|
1788 |
(\starupdates\; cs \; r \; [[c]] )
|
|
|
1789 |
)}
|
|
562
|
1790 |
{\varnothing} \rrbracket_r + 1$ & (6) \\
|
|
|
1791 |
& $\leq$ & $1 + (\textit{card} (\sizeNregex \; (N + n_r)))
|
|
|
1792 |
* (1 + (N + n_r)) $ & (7)\\
|
|
|
1793 |
\end{tabular}
|
|
|
1794 |
\end{center}
|
|
|
1795 |
\noindent
|
|
|
1796 |
(5) is by the lemma \ref{starClosedForm}.
|
|
|
1797 |
(6) is by \ref{altsSimpControl}.
|
|
|
1798 |
(7) is by \ref{finiteSizeNCorollary}.
|
|
|
1799 |
Combining with the case when $s = []$, one gets
|
|
|
1800 |
\begin{center}
|
|
593
|
1801 |
\begin{tabular}{lcll}
|
|
|
1802 |
$\rsize{r^* \backslash_r s}$ & $\leq$ & $max \; n_r \; 1 + (\textit{card} (\sizeNregex \; (N + n_r)))
|
|
|
1803 |
* (1 + (N + n_r)) $ & (8)\\
|
|
|
1804 |
\end{tabular}
|
|
562
|
1805 |
\end{center}
|
|
|
1806 |
\noindent
|
|
|
1807 |
|
|
|
1808 |
The alternative case is slightly less involved.
|
|
|
1809 |
The inductive hypothesis
|
|
|
1810 |
is equivalent to $\exists N. \forall r \in (\map \; (\_ \backslash_r s) \; rs). \rsize{r} \leq N$.
|
|
|
1811 |
In the case when $s = c::cs$, we have
|
|
|
1812 |
\begin{center}
|
|
593
|
1813 |
\begin{tabular}{lcll}
|
|
562
|
1814 |
& & $ \llbracket \rderssimp{\sum rs }{c::cs} \rrbracket_r $\\
|
|
|
1815 |
& $ = $ & $\llbracket \rsimp{(\sum (\map \; (\_ \backslash_{rsimp} s) \; rs) )} \rrbracket_r $ & (9) \\
|
|
|
1816 |
& $\leq$ & $\llbracket (\sum (\map \; (\_ \backslash_{rsimp} s) \; rs) ) \rrbracket_r $ & (10) \\
|
|
|
1817 |
& $\leq$ & $1 + N * (length \; rs) $ & (11)\\
|
|
593
|
1818 |
\end{tabular}
|
|
562
|
1819 |
\end{center}
|
|
|
1820 |
\noindent
|
|
|
1821 |
(9) is by \ref{altsClosedForm}, (10) by \ref{rsimpSize} and (11) by inductive hypothesis.
|
|
|
1822 |
|
|
|
1823 |
Combining with the case when $s = []$, one gets
|
|
|
1824 |
\begin{center}
|
|
593
|
1825 |
\begin{tabular}{lcll}
|
|
|
1826 |
$\rsize{\sum rs \backslash_r s}$ & $\leq$ & $max \; \rsize{\sum rs} \; 1+N*(length \; rs)$
|
|
|
1827 |
& (12)\\
|
|
|
1828 |
\end{tabular}
|
|
562
|
1829 |
\end{center}
|
|
|
1830 |
(4), (8), and (12) are all the inductive cases proven.
|
|
558
|
1831 |
\end{proof}
|
|
|
1832 |
|
|
564
|
1833 |
|
|
|
1834 |
\begin{corollary}
|
|
593
|
1835 |
For any regex $a$, $\exists N_r. \forall s. \; \rsize{\bderssimp{a}{s}} \leq N_r$
|
|
564
|
1836 |
\end{corollary}
|
|
|
1837 |
\begin{proof}
|
|
|
1838 |
By \ref{sizeRelations}.
|
|
|
1839 |
\end{proof}
|
|
558
|
1840 |
\noindent
|
|
|
1841 |
|
|
|
1842 |
%-----------------------------------
|
|
|
1843 |
% SECTION 2
|
|
|
1844 |
%-----------------------------------
|
|
|
1845 |
|
|
532
|
1846 |
|
|
557
|
1847 |
%----------------------------------------------------------------------------------------
|
|
|
1848 |
% SECTION 3
|
|
|
1849 |
%----------------------------------------------------------------------------------------
|
|
|
1850 |
|
|
532
|
1851 |
|
|
554
|
1852 |
\subsection{A Closed Form for the Sequence Regular Expression}
|
|
|
1853 |
\noindent
|
|
|
1854 |
|
|
|
1855 |
Before we get to the proof that says the intermediate result of our lexer will
|
|
|
1856 |
remain finitely bounded, which is an important efficiency/liveness guarantee,
|
|
|
1857 |
we shall first develop a few preparatory properties and definitions to
|
|
|
1858 |
make the process of proving that a breeze.
|
|
|
1859 |
|
|
|
1860 |
We define rewriting relations for $\rrexp$s, which allows us to do the
|
|
|
1861 |
same trick as we did for the correctness proof,
|
|
|
1862 |
but this time we will have stronger equalities established.
|
|
|
1863 |
|
|
532
|
1864 |
|
|
|
1865 |
|
|
|
1866 |
What guarantee does this bound give us?
|
|
|
1867 |
|
|
|
1868 |
Whatever the regex is, it will not grow indefinitely.
|
|
|
1869 |
Take our previous example $(a + aa)^*$ as an example:
|
|
|
1870 |
\begin{center}
|
|
593
|
1871 |
\begin{tabular}{@{}c@{\hspace{0mm}}c@{\hspace{0mm}}c@{}}
|
|
|
1872 |
\begin{tikzpicture}
|
|
|
1873 |
\begin{axis}[
|
|
|
1874 |
xlabel={number of $a$'s},
|
|
|
1875 |
x label style={at={(1.05,-0.05)}},
|
|
|
1876 |
ylabel={regex size},
|
|
|
1877 |
enlargelimits=false,
|
|
|
1878 |
xtick={0,5,...,30},
|
|
|
1879 |
xmax=33,
|
|
|
1880 |
ymax= 40,
|
|
|
1881 |
ytick={0,10,...,40},
|
|
|
1882 |
scaled ticks=false,
|
|
|
1883 |
axis lines=left,
|
|
|
1884 |
width=5cm,
|
|
|
1885 |
height=4cm,
|
|
|
1886 |
legend entries={$(a + aa)^*$},
|
|
|
1887 |
legend pos=north west,
|
|
|
1888 |
legend cell align=left]
|
|
|
1889 |
\addplot[red,mark=*, mark options={fill=white}] table {a_aa_star.data};
|
|
|
1890 |
\end{axis}
|
|
|
1891 |
\end{tikzpicture}
|
|
|
1892 |
\end{tabular}
|
|
532
|
1893 |
\end{center}
|
|
|
1894 |
We are able to limit the size of the regex $(a + aa)^*$'s derivatives
|
|
593
|
1895 |
with our simplification
|
|
532
|
1896 |
rules very effectively.
|
|
|
1897 |
|
|
|
1898 |
|
|
|
1899 |
In our proof for the inductive case $r_1 \cdot r_2$, the dominant term in the bound
|
|
|
1900 |
is $l_{N_2} * N_2$, where $N_2$ is the bound we have for $\llbracket \bderssimp{r_2}{s} \rrbracket$.
|
|
|
1901 |
Given that $l_{N_2}$ is roughly the size $4^{N_2}$, the size bound $\llbracket \bderssimp{r_1 \cdot r_2}{s} \rrbracket$
|
|
|
1902 |
inflates the size bound of $\llbracket \bderssimp{r_2}{s} \rrbracket$ with the function
|
|
|
1903 |
$f(x) = x * 2^x$.
|
|
|
1904 |
This means the bound we have will surge up at least
|
|
|
1905 |
tower-exponentially with a linear increase of the depth.
|
|
|
1906 |
For a regex of depth $n$, the bound
|
|
|
1907 |
would be approximately $4^n$.
|
|
|
1908 |
|
|
|
1909 |
Test data in the graphs from randomly generated regular expressions
|
|
|
1910 |
shows that the giant bounds are far from being hit.
|
|
|
1911 |
%a few sample regular experessions' derivatives
|
|
|
1912 |
%size change
|
|
576
|
1913 |
%TODO: giving regex1_size_change.data showing a few regular expressions' size changes
|
|
532
|
1914 |
%w;r;t the input characters number, where the size is usually cubic in terms of original size
|
|
|
1915 |
%a*, aa*, aaa*, .....
|
|
576
|
1916 |
%randomly generated regular expressions
|
|
532
|
1917 |
\begin{center}
|
|
593
|
1918 |
\begin{tabular}{@{}c@{\hspace{0mm}}c@{\hspace{0mm}}c@{}}
|
|
|
1919 |
\begin{tikzpicture}
|
|
|
1920 |
\begin{axis}[
|
|
|
1921 |
xlabel={number of $a$'s},
|
|
|
1922 |
x label style={at={(1.05,-0.05)}},
|
|
|
1923 |
ylabel={regex size},
|
|
|
1924 |
enlargelimits=false,
|
|
|
1925 |
xtick={0,5,...,30},
|
|
|
1926 |
xmax=33,
|
|
|
1927 |
ymax=1000,
|
|
|
1928 |
ytick={0,100,...,1000},
|
|
|
1929 |
scaled ticks=false,
|
|
|
1930 |
axis lines=left,
|
|
|
1931 |
width=5cm,
|
|
|
1932 |
height=4cm,
|
|
|
1933 |
legend entries={regex1},
|
|
|
1934 |
legend pos=north west,
|
|
|
1935 |
legend cell align=left]
|
|
|
1936 |
\addplot[red,mark=*, mark options={fill=white}] table {regex1_size_change.data};
|
|
|
1937 |
\end{axis}
|
|
|
1938 |
\end{tikzpicture}
|
|
532
|
1939 |
&
|
|
593
|
1940 |
\begin{tikzpicture}
|
|
|
1941 |
\begin{axis}[
|
|
|
1942 |
xlabel={$n$},
|
|
|
1943 |
x label style={at={(1.05,-0.05)}},
|
|
|
1944 |
%ylabel={time in secs},
|
|
|
1945 |
enlargelimits=false,
|
|
|
1946 |
xtick={0,5,...,30},
|
|
|
1947 |
xmax=33,
|
|
|
1948 |
ymax=1000,
|
|
|
1949 |
ytick={0,100,...,1000},
|
|
|
1950 |
scaled ticks=false,
|
|
|
1951 |
axis lines=left,
|
|
|
1952 |
width=5cm,
|
|
|
1953 |
height=4cm,
|
|
|
1954 |
legend entries={regex2},
|
|
|
1955 |
legend pos=north west,
|
|
|
1956 |
legend cell align=left]
|
|
|
1957 |
\addplot[blue,mark=*, mark options={fill=white}] table {regex2_size_change.data};
|
|
|
1958 |
\end{axis}
|
|
|
1959 |
\end{tikzpicture}
|
|
532
|
1960 |
&
|
|
593
|
1961 |
\begin{tikzpicture}
|
|
|
1962 |
\begin{axis}[
|
|
|
1963 |
xlabel={$n$},
|
|
|
1964 |
x label style={at={(1.05,-0.05)}},
|
|
|
1965 |
%ylabel={time in secs},
|
|
|
1966 |
enlargelimits=false,
|
|
|
1967 |
xtick={0,5,...,30},
|
|
|
1968 |
xmax=33,
|
|
|
1969 |
ymax=1000,
|
|
|
1970 |
ytick={0,100,...,1000},
|
|
|
1971 |
scaled ticks=false,
|
|
|
1972 |
axis lines=left,
|
|
|
1973 |
width=5cm,
|
|
|
1974 |
height=4cm,
|
|
|
1975 |
legend entries={regex3},
|
|
|
1976 |
legend pos=north west,
|
|
|
1977 |
legend cell align=left]
|
|
|
1978 |
\addplot[cyan,mark=*, mark options={fill=white}] table {regex3_size_change.data};
|
|
|
1979 |
\end{axis}
|
|
|
1980 |
\end{tikzpicture}\\
|
|
|
1981 |
\multicolumn{3}{c}{Graphs: size change of 3 randomly generated regular expressions $w.r.t.$ input string length.}
|
|
|
1982 |
\end{tabular}
|
|
532
|
1983 |
\end{center}
|
|
|
1984 |
\noindent
|
|
|
1985 |
Most of the regex's sizes seem to stay within a polynomial bound $w.r.t$ the
|
|
|
1986 |
original size.
|
|
591
|
1987 |
We will discuss improvements to this bound in the next chapter.
|
|
532
|
1988 |
|
|
|
1989 |
|
|
|
1990 |
|
|
|
1991 |
%----------------------------------------------------------------------------------------
|
|
|
1992 |
% SECTION ??
|
|
|
1993 |
%----------------------------------------------------------------------------------------
|
|
|
1994 |
|
|
|
1995 |
%-----------------------------------
|
|
|
1996 |
% SECTION syntactic equivalence under simp
|
|
|
1997 |
%-----------------------------------
|
|
|
1998 |
\section{Syntactic Equivalence Under $\simp$}
|
|
|
1999 |
We prove that minor differences can be annhilated
|
|
|
2000 |
by $\simp$.
|
|
|
2001 |
For example,
|
|
|
2002 |
\begin{center}
|
|
593
|
2003 |
$\simp \;(\simpALTs\; (\map \;(\_\backslash \; x)\; (\distinct \; \mathit{rs}\; \phi))) =
|
|
|
2004 |
\simp \;(\simpALTs \;(\distinct \;(\map \;(\_ \backslash\; x) \; \mathit{rs}) \; \phi))$
|
|
532
|
2005 |
\end{center}
|
|
|
2006 |
|
|
|
2007 |
|
|
|
2008 |
%----------------------------------------------------------------------------------------
|
|
|
2009 |
% SECTION ALTS CLOSED FORM
|
|
|
2010 |
%----------------------------------------------------------------------------------------
|
|
|
2011 |
\section{A Closed Form for \textit{ALTS}}
|
|
|
2012 |
Now we prove that $rsimp (rders\_simp (RALTS rs) s) = rsimp (RALTS (map (\lambda r. rders\_simp r s) rs))$.
|
|
|
2013 |
|
|
|
2014 |
|
|
|
2015 |
There are a few key steps, one of these steps is
|
|
556
|
2016 |
|
|
532
|
2017 |
|
|
|
2018 |
|
|
|
2019 |
One might want to prove this by something a simple statement like:
|
|
|
2020 |
|
|
|
2021 |
For this to hold we want the $\textit{distinct}$ function to pick up
|
|
|
2022 |
the elements before and after derivatives correctly:
|
|
|
2023 |
$r \in rset \equiv (rder x r) \in (rder x rset)$.
|
|
|
2024 |
which essentially requires that the function $\backslash$ is an injective mapping.
|
|
|
2025 |
|
|
|
2026 |
Unfortunately the function $\backslash c$ is not an injective mapping.
|
|
|
2027 |
|
|
|
2028 |
\subsection{function $\backslash c$ is not injective (1-to-1)}
|
|
|
2029 |
\begin{center}
|
|
593
|
2030 |
The derivative $w.r.t$ character $c$ is not one-to-one.
|
|
|
2031 |
Formally,
|
|
532
|
2032 |
$\exists r_1 \;r_2. r_1 \neq r_2 \mathit{and} r_1 \backslash c = r_2 \backslash c$
|
|
|
2033 |
\end{center}
|
|
|
2034 |
This property is trivially true for the
|
|
|
2035 |
character regex example:
|
|
|
2036 |
\begin{center}
|
|
|
2037 |
$r_1 = e; \; r_2 = d;\; r_1 \backslash c = \ZERO = r_2 \backslash c$
|
|
|
2038 |
\end{center}
|
|
|
2039 |
But apart from the cases where the derivative
|
|
|
2040 |
output is $\ZERO$, are there non-trivial results
|
|
|
2041 |
of derivatives which contain strings?
|
|
|
2042 |
The answer is yes.
|
|
|
2043 |
For example,
|
|
|
2044 |
\begin{center}
|
|
|
2045 |
Let $r_1 = a^*b\;\quad r_2 = (a\cdot a^*)\cdot b + b$.\\
|
|
|
2046 |
where $a$ is not nullable.\\
|
|
|
2047 |
$r_1 \backslash c = ((a \backslash c)\cdot a^*)\cdot c + b \backslash c$\\
|
|
|
2048 |
$r_2 \backslash c = ((a \backslash c)\cdot a^*)\cdot c + b \backslash c$
|
|
|
2049 |
\end{center}
|
|
576
|
2050 |
We start with two syntactically different regular expressions,
|
|
532
|
2051 |
and end up with the same derivative result.
|
|
|
2052 |
This is not surprising as we have such
|
|
|
2053 |
equality as below in the style of Arden's lemma:\\
|
|
|
2054 |
\begin{center}
|
|
|
2055 |
$L(A^*B) = L(A\cdot A^* \cdot B + B)$
|
|
|
2056 |
\end{center}
|
|
|
2057 |
|
|
590
|
2058 |
There are two problems with this finiteness result, though.
|
|
|
2059 |
\begin{itemize}
|
|
|
2060 |
\item
|
|
593
|
2061 |
First, It is not yet a direct formalisation of our lexer's complexity,
|
|
|
2062 |
as a complexity proof would require looking into
|
|
|
2063 |
the time it takes to execute {\bf all} the operations
|
|
|
2064 |
involved in the lexer (simp, collect, decode), not just the derivative.
|
|
|
2065 |
\item
|
|
|
2066 |
Second, the bound is not yet tight, and we seek to improve $N_a$ so that
|
|
|
2067 |
it is polynomial on $\llbracket a \rrbracket$.
|
|
590
|
2068 |
\end{itemize}
|
|
|
2069 |
Still, we believe this contribution is fruitful,
|
|
|
2070 |
because
|
|
|
2071 |
\begin{itemize}
|
|
|
2072 |
\item
|
|
|
2073 |
|
|
|
2074 |
The size proof can serve as a cornerstone for a complexity
|
|
|
2075 |
formalisation.
|
|
|
2076 |
Derivatives are the most important phases of our lexer algorithm.
|
|
|
2077 |
Size properties about derivatives covers the majority of the algorithm
|
|
|
2078 |
and is therefore a good indication of complexity of the entire program.
|
|
|
2079 |
\item
|
|
|
2080 |
The bound is already a strong indication that catastrophic
|
|
|
2081 |
backtracking is much less likely to occur in our $\blexersimp$
|
|
|
2082 |
algorithm.
|
|
|
2083 |
We refine $\blexersimp$ with $\blexerStrong$ in the next chapter
|
|
|
2084 |
so that the bound becomes polynomial.
|
|
|
2085 |
\end{itemize}
|
|
593
|
2086 |
|
|
532
|
2087 |
%----------------------------------------------------------------------------------------
|
|
|
2088 |
% SECTION 4
|
|
|
2089 |
%----------------------------------------------------------------------------------------
|
|
593
|
2090 |
|
|
|
2091 |
|
|
|
2092 |
|
|
|
2093 |
|
|
|
2094 |
|
|
|
2095 |
|
|
|
2096 |
|
|
|
2097 |
|
|
532
|
2098 |
One might wonder the actual bound rather than the loose bound we gave
|
|
|
2099 |
for the convenience of an easier proof.
|
|
|
2100 |
How much can the regex $r^* \backslash s$ grow?
|
|
|
2101 |
As earlier graphs have shown,
|
|
|
2102 |
%TODO: reference that graph where size grows quickly
|
|
593
|
2103 |
they can grow at a maximum speed
|
|
|
2104 |
exponential $w.r.t$ the number of characters,
|
|
532
|
2105 |
but will eventually level off when the string $s$ is long enough.
|
|
|
2106 |
If they grow to a size exponential $w.r.t$ the original regex, our algorithm
|
|
|
2107 |
would still be slow.
|
|
|
2108 |
And unfortunately, we have concrete examples
|
|
576
|
2109 |
where such regular expressions grew exponentially large before levelling off:
|
|
532
|
2110 |
$(a ^ * + (aa) ^ * + (aaa) ^ * + \ldots +
|
|
|
2111 |
(\underbrace{a \ldots a}_{\text{n a's}})^*$ will already have a maximum
|
|
593
|
2112 |
size that is exponential on the number $n$
|
|
532
|
2113 |
under our current simplification rules:
|
|
|
2114 |
%TODO: graph of a regex whose size increases exponentially.
|
|
|
2115 |
\begin{center}
|
|
593
|
2116 |
\begin{tikzpicture}
|
|
|
2117 |
\begin{axis}[
|
|
|
2118 |
height=0.5\textwidth,
|
|
|
2119 |
width=\textwidth,
|
|
|
2120 |
xlabel=number of a's,
|
|
|
2121 |
xtick={0,...,9},
|
|
|
2122 |
ylabel=maximum size,
|
|
|
2123 |
ymode=log,
|
|
|
2124 |
log basis y={2}
|
|
|
2125 |
]
|
|
|
2126 |
\addplot[mark=*,blue] table {re-chengsong.data};
|
|
|
2127 |
\end{axis}
|
|
|
2128 |
\end{tikzpicture}
|
|
532
|
2129 |
\end{center}
|
|
|
2130 |
|
|
|
2131 |
For convenience we use $(\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*)^*$
|
|
|
2132 |
to express $(a ^ * + (aa) ^ * + (aaa) ^ * + \ldots +
|
|
|
2133 |
(\underbrace{a \ldots a}_{\text{n a's}})^*$ in the below discussion.
|
|
|
2134 |
The exponential size is triggered by that the regex
|
|
|
2135 |
$\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*$
|
|
|
2136 |
inside the $(\ldots) ^*$ having exponentially many
|
|
|
2137 |
different derivatives, despite those difference being minor.
|
|
|
2138 |
$(\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*)^*\backslash \underbrace{a \ldots a}_{\text{m a's}}$
|
|
|
2139 |
will therefore contain the following terms (after flattening out all nested
|
|
|
2140 |
alternatives):
|
|
|
2141 |
\begin{center}
|
|
593
|
2142 |
$(\oplus_{i = 1]{n} (\underbrace{a \ldots a}_{\text{((i - (m' \% i))\%i) a's}})\cdot (\underbrace{a \ldots a}_{\text{i a's}})^* })\cdot (\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*)$\\
|
|
|
2143 |
$(1 \leq m' \leq m )$
|
|
532
|
2144 |
\end{center}
|
|
|
2145 |
These terms are distinct for $m' \leq L.C.M.(1, \ldots, n)$ (will be explained in appendix).
|
|
593
|
2146 |
With each new input character taking the derivative against the intermediate result, more and more such distinct
|
|
|
2147 |
terms will accumulate,
|
|
532
|
2148 |
until the length reaches $L.C.M.(1, \ldots, n)$.
|
|
|
2149 |
$\textit{distinctBy}$ will not be able to de-duplicate any two of these terms
|
|
|
2150 |
$(\oplus_{i = 1}^{n} (\underbrace{a \ldots a}_{\text{((i - (m' \% i))\%i) a's}})\cdot (\underbrace{a \ldots a}_{\text{i a's}})^* )\cdot (\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*)^*$\\
|
|
|
2151 |
|
|
|
2152 |
$(\oplus_{i = 1}^{n} (\underbrace{a \ldots a}_{\text{((i - (m'' \% i))\%i) a's}})\cdot (\underbrace{a \ldots a}_{\text{i a's}})^* )\cdot (\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*)^*$\\
|
|
593
|
2153 |
where $m' \neq m''$ \\
|
|
|
2154 |
as they are slightly different.
|
|
|
2155 |
This means that with our current simplification methods,
|
|
|
2156 |
we will not be able to control the derivative so that
|
|
|
2157 |
$\llbracket \bderssimp{r}{s} \rrbracket$ stays polynomial %\leq O((\llbracket r\rrbacket)^c)$
|
|
|
2158 |
as there are already exponentially many terms.
|
|
|
2159 |
These terms are similar in the sense that the head of those terms
|
|
|
2160 |
are all consisted of sub-terms of the form:
|
|
|
2161 |
$(\underbrace{a \ldots a}_{\text{j a's}})\cdot (\underbrace{a \ldots a}_{\text{i a's}})^* $.
|
|
|
2162 |
For $\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*$, there will be at most
|
|
|
2163 |
$n * (n + 1) / 2$ such terms.
|
|
|
2164 |
For example, $(a^* + (aa)^* + (aaa)^*) ^*$'s derivatives
|
|
|
2165 |
can be described by 6 terms:
|
|
|
2166 |
$a^*$, $a\cdot (aa)^*$, $ (aa)^*$,
|
|
|
2167 |
$aa \cdot (aaa)^*$, $a \cdot (aaa)^*$, and $(aaa)^*$.
|
|
532
|
2168 |
The total number of different "head terms", $n * (n + 1) / 2$,
|
|
593
|
2169 |
is proportional to the number of characters in the regex
|
|
532
|
2170 |
$(\oplus_{i=1}^{n} (\underbrace{a \ldots a}_{\text{i a's}})^*)^*$.
|
|
|
2171 |
This suggests a slightly different notion of size, which we call the
|
|
|
2172 |
alphabetic width:
|
|
|
2173 |
%TODO:
|
|
|
2174 |
(TODO: Alphabetic width def.)
|
|
|
2175 |
|
|
593
|
2176 |
|
|
532
|
2177 |
Antimirov\parencite{Antimirov95} has proven that
|
|
|
2178 |
$\textit{PDER}_{UNIV}(r) \leq \textit{awidth}(r)$.
|
|
|
2179 |
where $\textit{PDER}_{UNIV}(r)$ is a set of all possible subterms
|
|
|
2180 |
created by doing derivatives of $r$ against all possible strings.
|
|
|
2181 |
If we can make sure that at any moment in our lexing algorithm our
|
|
|
2182 |
intermediate result hold at most one copy of each of the
|
|
|
2183 |
subterms then we can get the same bound as Antimirov's.
|
|
|
2184 |
This leads to the algorithm in the next chapter.
|
|
|
2185 |
|
|
|
2186 |
|
|
|
2187 |
|
|
|
2188 |
|
|
|
2189 |
|
|
|
2190 |
%----------------------------------------------------------------------------------------
|
|
|
2191 |
% SECTION 1
|
|
|
2192 |
%----------------------------------------------------------------------------------------
|
|
|
2193 |
|
|
|
2194 |
|
|
|
2195 |
%-----------------------------------
|
|
|
2196 |
% SUBSECTION 1
|
|
|
2197 |
%-----------------------------------
|
|
|
2198 |
\subsection{Syntactic Equivalence Under $\simp$}
|
|
|
2199 |
We prove that minor differences can be annhilated
|
|
|
2200 |
by $\simp$.
|
|
|
2201 |
For example,
|
|
|
2202 |
\begin{center}
|
|
593
|
2203 |
$\simp \;(\simpALTs\; (\map \;(\_\backslash \; x)\; (\distinct \; \mathit{rs}\; \phi))) =
|
|
|
2204 |
\simp \;(\simpALTs \;(\distinct \;(\map \;(\_ \backslash\; x) \; \mathit{rs}) \; \phi))$
|
|
532
|
2205 |
\end{center}
|
|
|
2206 |
|