GA and ILS for optimizing the size of NFA models

This simple model has been presented in [9]. It is based on 3 sets of equations:

1. 1.

   If the empty word is in $S^{+}$ or $S^{-}$, we can fix whether the first state is final or not:

   	$\displaystyle\textrm{if }\lambda\in S^{+},~{}~{}~{}~{}~{}~{}f_{1}$		(1)
   	$\displaystyle\textrm{if }\lambda\in S^{-},~{}~{}~{}~{}\neg f_{1}$		(2)

2. 2.

   For each word $w\in S^{+}$, there is at least a path from $q_{1}$ to a final state $q_{j}$:

   $\displaystyle\bigvee_{j\in K}\bigvee_{~{}d\in D_{{w},\vv{q_{1}q_{j}}}}\big{(}d\wedge f_{j}\big{)}$

   (3)

   With the Tseitin transformations [14], we create one auxiliary variable for each combination of a word $w$, a state $j\in K$, and a c_path $d\in D_{{w},\vv{q_{1}q_{j}}}$: $aux_{w,j,d}\leftrightarrow d\wedge f_{j}$. Hence, we obtain a formula in CNF for each $w$:

   	$\displaystyle\bigwedge_{j\in K}\bigwedge_{~{}d\in D_{{w},\vv{q_{1}q_{j}}}}\left[(\neg aux_{w,j,d}\vee(d\wedge f_{j}))\right]$		(4)
   	$\displaystyle\bigwedge_{j\in K}\bigwedge_{~{}d\in D_{{w},\vv{q_{1}q_{j}}}}(aux_{w,j,d}\vee\neg d\vee\neg f_{j})$		(5)
   	$\displaystyle\bigvee_{j\in K}\bigvee_{~{}d\in D_{{w},\vv{q_{1}q_{j}}}}aux_{w,j,d}$		(6)

3. 3.

   For each $w\in S^{-}$ and each $q_{j}$, either there is no path state $q_{1}$ to $q_{j}$, or $q_{j}$ is not final:

   $\displaystyle\neg\left[\bigvee_{j\in K}\bigvee_{~{}d\in D_{{w},\vv{q_{1}q_{j}}}}\big{(}d\wedge f_{j}\big{)}\right]$

   (7)

Thus, the direct constraint model $DM_{k}$ for building a NFA of size $k$ is:

and is possibly completed by $(\ref{lambda1})$ or $(\ref{lambda2})$ if $\lambda\in S^{+}$ or $\lambda\in S^{-}$.

Let $Pref(w)$ be the set of all the non-empty prefixes of the word $w$ and, by extension, $Pref(W)=\cup_{w\in W}Pref(w)$ the set of prefixes of the words of the set $W$. For each $w\in Pref(S)$, we add a Boolean variable $p_{w,\vv{q_{1}q_{i}}}$ which determines whether there is or not a c_path for $w$ from state $q_{1}$ to $q_{i}$. Note that these variables can be seen as labels of the Prefix Tree Acceptor (PTA) for $S$ [3]. The problem can be modeled with the following constraints:

1. 1.

   For all prefix $w=a$ with $w\in Pref(S)$, and $a\in\Sigma$, there is a c_path of size 1 for $w$:

   $\displaystyle\bigvee_{i\in K}\delta_{a,\vv{q_{1}q_{i}}}\leftrightarrow p_{a,\vv{q_{1}q_{i}}}$

   (8)

   With the Tseitin transformations, we can derive a CNF formula. It is also possible to directly encode $\delta_{a,\vv{q_{1}q_{i}}}$ and $p_{a,\vv{q_{1}q_{i}}}$ as the same variable. Thus, no clause is required.

2. 2.

   For all words $w\in S^{+}-\{\lambda\}$:

   $\displaystyle\bigvee_{i\in K}p_{w,\vv{q_{1}q_{i}}}\wedge f_{i}$

   (9)

   With the Tseitin transformations [14], we create one auxiliary variable for each combination of $p_{w,\vv{q_{1}q_{i}}}$ and the status (final or not) of the state $q_{i}$: $aux_{w,i}\leftrightarrow p_{w,\vv{q_{1}q_{i}}}\wedge f_{i}$. Hence, for each $w$, we obtain a formula in CNF:

   	$\displaystyle\bigwedge_{i\in K}((\neg aux_{w,i}\vee p_{w,\vv{q_{1}q_{i}}})\wedge(\neg aux_{w,i}\vee f_{i}))$		(10)
   	$\displaystyle\bigwedge_{i\in K}(aux_{w,i}\vee\neg p_{w,\vv{q_{1}q_{i}}}\vee\neg f_{i})$		(11)
   	$\displaystyle\bigvee_{i\in K}aux_{w,i}$		(12)

3. 3.

   For all words $w\in S^{-}-\{\lambda\}$, we obtain the following CNF constraint:

   $\displaystyle\bigwedge_{i\in K}(\neg p_{w,\vv{q_{1}q_{i}}}\vee\neg f_{i})$

   (13)

4. 4.

   For all prefix $w=va$, $w\in Pref(S)$, $v\in Pref(S)$ and $a\in\Sigma$:

   $\displaystyle\bigwedge_{i\in K}(p_{w,\vv{q_{1}q_{i}}}\leftrightarrow(\bigvee_{j\in K}p_{v,\vv{q_{1}q_{j}}}\wedge\delta_{a,\vv{q_{j}q_{i}}}))$

   (14)

   Applying the Tseitin transformations, we create one auxiliary variable for each combination of existence of a c_path from $q_{1}$ to $q_{i}$ ($p_{v,\vv{q_{1}q_{j}}}$) and the transition $\delta_{a,\vv{q_{j}q_{i}}}$: $aux_{v,a,j,i}\leftrightarrow p_{v,\vv{q_{1}q_{j}}}\wedge\delta_{a,\vv{q_{j}q_{i}}}$. Then, (14) becomes:

   $\displaystyle\bigwedge_{i\in K}(p_{w,\vv{q_{1}q_{i}}}\leftrightarrow(\bigvee_{j\in K}aux_{v,a,j,i}))$

   For each $w\in Pref(S)$, we obtain constraints in CNF:

   	$\displaystyle\bigwedge_{(i,j)\in K^{2}}\ (\neg aux_{v,a,j,i}\vee p_{w,\vv{q_{1}q_{i}}})$		(15)
   	$\displaystyle\bigwedge_{(i,j)\in K^{2}}(\neg aux_{v,a,j,i}\vee\delta_{a,\vv{q_{j}q_{i}}})$		(16)
   	$\displaystyle\bigwedge_{(i,j)\in K^{2}}(aux_{v,a,j,i}\vee\neg p_{w,\vv{q_{1}q_{i}}}\vee\neg\delta_{a,\vv{q_{j}q_{i}}})$		(17)
   	$\displaystyle\bigwedge_{i\in K}(\neg p_{w,\vv{q_{1}q_{i}}}\vee(\bigvee_{j\in K}aux_{v,a,j,i}))$		(18)
   	$\displaystyle\bigwedge_{(i,j)\in K^{2}}(p_{w,\vv{q_{1}q_{i}}}\vee\neg aux_{v,a,j,i}))$		(19)

Thus, the constraint prefix model $PM_{k}$ for building a NFA of size $k$ is:

and is possibly completed by $(\ref{lambda1})$ or $(\ref{lambda2})$ if $\lambda\in S^{+}$ or $\lambda\in S^{-}$.

We now propose a suffix model ($SM_{k}$), based on $Suf(S)$, the set of all the non-empty suffixes of all the words in $S$. The main difference is that the construction starts from every state and terminates in state $q_{1}$. For each $w\in Suf(S)$, we add a Boolean variable $p_{w,\vv{q_{i}q_{j}}}$ which determines whether there is or not a c_path for $w$ from state $q_{i}$ to $q_{j}$. To model the problem, Constraints (10), (11), (12), and (13) remain unchanged and creation of the corresponding auxiliary variables $aux_{w,i}$ as well.

For each suffix $w=a$ with $w\in Suf(S)$, and $a\in\Sigma$, there is a c_path of size 1 for $w$:

We can directly encode $\delta_{a,\vv{q_{i}q_{j}}}$ and $p_{a,\vv{q_{i}q_{j}}}$ as the same variable. Thus, no clause is required.

For all suffix $w=av$, $w\in Suf(S)$, $v\in Suf(S)$ and $a\in\Sigma$:

We create one auxiliary variable for each combination of existence of a c_path from $q_{k}$ to $q_{j}$ ($p_{v,\vv{q_{k}q_{j}}}$) and the transition $\delta_{a,\vv{q_{i}q_{k}}}$: $aux_{v,a,i,k,j}\leftrightarrow\delta_{a,\vv{q_{i}q_{k}}}\wedge p_{v,\vv{q_{k}q_{j}}}$

For each $w=av$, we obtain the following constraints (CNF formulas):

Note that some clauses are not worth being generated. Indeed, it is useless to generate paths starting in states different from the initial state $q_{1}$, except when the $w$ is in $S$, and $w$ is also the suffix of another word from $S$. Removing these constraints does not change the complexity of the model. This can easily be done at generation time, or we can leave it to the solver, which will detect it and remove the useless constraints.

Thus, the constraint prefix model $PM_{k}$ for building a NFA of size $k$ is:

and is possibly completed by $(\ref{lambda1})$ or $(\ref{lambda2})$ if $\lambda\in S^{+}$ or $\lambda\in S^{-}$.

The search space $\cal X$ of this problem corresponds to all the hybrid models: for each word $w$ of $S$, we have to determine a $n$ such that $w=p.s$ with $|p|=n$ and $|s|=|w|-n$. The size of the search space is thus: $|{\cal X}|=\Pi_{w\in S}|w|+1$.

Even though we are aware that smaller instances are not necessarily easier to solve, we choose to define the first evaluation function as the number of generated SAT variables. However, this number cannot be computed a priori: first, the instance has to be generated, before counting the variables. This function being too costly, we propose an alternative evaluation function for approximating the number of variables. This fitness function is based on the number of prefixes in $Pref(S_{p})$ and suffixes in $Suf(S_{s})$. Since the complexity of $SM_{k}$ is in ${\cal O}(k^{3})$ whereas the complexity of $PM_{k}$ is in ${\cal O}(k^{2})$, suffixes are penalized by a coefficient corresponding to the number of states.

Empirically, we observe that the results of this $fitness$ function are proportional to the actual number of generated SAT variables. This approximation of the number of variables will thus be the fitness function in our ILS and GA algorithms.

We propose an Iterated Local Search (ILS) [15] for optimizing our hybrid model. Classically, a best improvement or a first improvement neighborhood is used in ILS to select the next move. In our case, a first improvement provides very poor results. Moreover, it is clearly impossible to evaluate all the neighbors at each step due to the computing cost. We thus decide to randomly choose a word in $S$ with a roulette wheel selection based on the word weights. Each word $w$ has a weight corresponding for 75% to a characteristic of $S$, and 25% to the length of the word:

The search starts generating a random couple of prefixes and suffixes sets ($S_{p}$,$S_{s}$), i.e., for each word $w$ of $S$ an integer is selected for splitting $w$ into a prefix $p$ and a suffix $s$ such that $w=p.s$. Hence, at each iteration, the best couple $(p,s)$ is found for the selected word $w$. This process is iterated until a maximum number of iterations is reached.

In our ILS, it is not necessary to introduce noise with random walks or restarts because our process of selection of word naturally ensures diversification.

We propose a classical genetic algorithm (GA) based on the search space and fitness function presented in Section 3.1. A population of individuals, represented by a couple of prefixes and suffixes sets, is improved generation after generation. Each generation keeps a portion of individuals as parents and creates children by crossing the selected parents. Crossover operator used in our GA is the well-known uniform crossover. For each word, children inherit the prefix and the suffix of one of their parents randomly chosen. Since the population size is the same during all the search, we have a steady-state GA. A mutation process is applied over all individuals with a probability $p_{mut}$. For each word $w$, each prefix and suffix are randomly mutated by generating an integer $n$ between 0 and $|w|$ splitting $w$ into a new prefix of size $n$ and a new suffix $|w|-n$. The search stops when the maximum number of generations is reached or when no improvement is observed in the population during $max\_gen\_without\_improv$ generations.

All our algorithms are implemented in Python using specific libraries such as Pysat. The experiments were carried out on a computing cluster with Intel-E5-2695 CPUs, and a limit of 10 GB of memory was fixed. Running times were limited to 10 minutes, including generation of the model and solving time. We used the Glucose [13] SAT solver with the default options. For stochastic methods (ILS and GA), 30 runs are realized to exploit the results statistically.

Parameters used for our hybrid models are:

Our experiments are reported in Table 7. The first column ($Instance$) corresponds to the official name of the instance, and the second one ($k$) to the number of states of the expected NFA. Then, we have in sequence the model name ($Model$), the number of SAT variables ($Var.$), the number of clauses ($Cl.$), and the instance generation time ($t_{M}$). The right part of the table corresponds to the solving part with the satisfiability of the generated instance ($SAT$), the decisions number ($Dec.$), and the solving time ($t_{S}$) with Glucose. Finally, the last column ($t_{T}$) corresponds to the total time (modeling time + solving time). Results for hybrid models based on ILS ($HM\_ILS_{k}$) and GA ($HM\_GA_{k}$) correspond to average values over 30 runs. We have decided to only provide the average since the standard deviation values are very small.

The last lines of the table correspond to the cumulative values for each column and each model. When an instance is not solved (time-out), the maximum value needed for solving the other model instances is considered. For the instance generation time ($t_{M}$), a credit of $600$ seconds is applied when generation did not succeed before the time-out.

We can clearly confirm that the direct model is not usable in practice, and that instances cannot be generated in less than $600s.$ The prefix model allows the fastest generation when it terminates before the time out (on these benchmarks, it did not succeed once and was thus penalize for cumulative values). It also provides instances that are solved quite fast. As expected, the instances optimized with GA are the smallest ones. However, the generation is too costly: the gain in solving time is not sufficient to compensate the long generation time. In total, in terms of solving+generation time, GA based model is close to prefix model. As planned with its space complexity (in ${\cal{O}}(k^{3})$), suffix based instances are huge and long to solve. However, we were surprised for 2 benchmarks (ww-10-40 and ww-10-50) for which the generated instances are relatively big (5 times the size of the GA optimized instances), but their solving is the fastest. We still cannot explain what made these instances easy to solve, and we are still investigating their structure. The better balance is given with the ILS model: instances are relatively small, the generation time is fast, and the solving time as well. This is thus the best option of this work.

It is very difficult to compare our results with the results of [2]. First of all, in [2], they try to minimize $k$, the number of states. Moreover, they use parallel algorithms. Finally, they do not detail the results for each instance and each $k$, except for st-2-30 and st-5-50. For the first one, with $k=9$ we are much faster. But for the second one, with $k=5$ we are slower.