Algoritmo para reduzir um DFA introduzindo o não-determinismo?

Isso está um pouco relacionado a outra pergunta que fiz , mas acho que é diferente o suficiente para justificar sua própria pergunta.

Estou pesquisando onde estou tentando encontrar a estrutura de complementos de uma determinada classe de linguagens finitas. É fácil para mim conseguir o mínimo de DFAs aceitando essas linguagens, mas eu gostaria de examinar que tipo de estrutura os NFAs que aceitam esses idiomas têm, particularmente como o não-determinismo ajuda no tamanho do estado dos autômatos (os DFAs são exponencialmente grandes).

O problema é que a principal técnica de redução de NFA usa equivalências, que não produzirão nenhuma redução se eu começar com um DFA mínimo (já que é basicamente usando a mesma técnica). Se eu começar com um DFA não mínimo, ele apenas cuspirá o DFA mínimo.

O que eu quero saber é: existem algoritmos que podem começar com um DFA e reduzi-lo a um NFA menor, introduzindo o não determinismo? Existem "técnicas padrão" para fazer isso?

Encontrei reduções de pré-encomenda , que parecem promissoras, mas difíceis de implementar. Estou aberto a muitas sugestões.

Para heurísticas eficientes, sugiro examinar a literatura CAD sobre o problema de codificação de estado (atribuir identificadores binários aos estados de um DFA para minimizar a quantidade de lógica para a função de transição de estado). Devadas e Newton, "Decomposição e fatoração de finito seqüencial máquinas de estado ", IEEE TCAD , 8 (11): 1206-1217, 1989 aponta que existe uma estreita relação entre codificação de estado e decomposição de máquina de estado.

Se para um DFA com $N$ afirma que você atribui um único $M$ identificador de estado de bit para cada estado ($\lg_2N < M\leq N$), decompôs o DFA essencialmente em uma rede de $M$máquinas de dois estados em interação. Equivalentemente: você definiu um conjunto$S$ com $M$ elementos e atribuiu um subconjunto exclusivo de $S$para cada estado no seu DFA original. Isso também é o que o algoritmo de construção de conjuntos de potências Rabin-Scott faz. Portanto, ao fazer uma codificação de estado no DFA, estamos tentando fazer engenharia reversa do conjunto do qual o algoritmo de construção do conjunto de energia começou.

No problema tradicional de codificação de estado, todas as codificações são legais e há alguma função objetiva (relacionada à quantidade de lógica na função de transição de estado) que você está tentando minimizar. Para gerar um NFA, você precisa resolver uma versão restrita do problema de encadeamento em que:

uma codificação de $M$identificadores de bits para os estados do DFA representam um if de NFA para cada símbolo no alfabeto, a função de transição para cada bit é uma simples disjunção de bits. (Nenhuma conjunção ou negação é permitida.)

Então você pode enumerar todas as $M$ codificações de bits para todos $\lg_2N < M\leq N$e verifique se cada um satisfaz a restrição. (Observe que para$M=N$ a trivial codificação "quente" sempre satisfaz as restrições e fornece o DFA.) A enumeração é ridiculamente grande, porém (o livro de Di Micheli a apresenta como algo como $\frac{2^M !}{(2^M - N)!M!}$.) A razão pela qual estou sugerindo a literatura CAD é que existem técnicas para fazer essa pesquisa implicitamente, em vez de enumerar (por exemplo, usando BDDs, consulte Lin, Touati e Newton: "Não se importe com a minimização de sequências multiníveis redes lógicas ", Dsgn ICCAD-90: Comp Confided Int'l ICCAD-90: 414-417, 1990 .

Exemplo

Pegue o DFA a seguir (com um código de estado derivado por trapaça (gere o DFA a partir de um NFA usando Rabin-Scott, e a codificação representa os subconjuntos escolhidos por Rabin-Scott))

Se chamarmos os bits na atribuição de estado ABCD, quando o símbolo de entrada for 1, a função de transição será A = A, B = A, C = B, D = C. Quando o símbolo de entrada é 0, a função de transição é A = A, C = B, D = C. Esta é uma função de transição puramente disjuntiva, sem conjunção ou negação, portanto, essa codificação de estado nos fornece um NFA. Os estados no NFA correspondem um a um aos bits na codificação e a função de transição é a seguinte:

Formulação como problema de satisfação booleana

A descrição informal acima leva diretamente a uma codificação como um problema de satisfação booleana. Há um conjunto de variáveis ​​que descreve as transições na NFA e um conjunto de variáveis ​​para a codificação do estado DFA que seria derivada de Rabin-Scott para a NFA escolhida. As transições do DFA específico que você está tentando decompor são usadas para colocar restrições nas transições do NFA.

Suponha que recebamos um DFA com $N$ estados para um idioma com $S$ símbolos e gostaríamos de derivar uma $M$ AFN estadual, com $\lg_2N<M\leq N$. Nós vamos usar as variáveis$y_{sft}$ para representar as possíveis transições no NFA. $y_{sft}$será verdadeiro se houver uma transição na NFA do estado da NFA$f$ para o estado NFA$t$no símbolo $s$. No exemplo acima NFA, o alfabeto é do tamanho 2 e há 4 estados NFA, portanto, existem$SM^2=32$ $y$ variáveis ​​e $y_{0AA}, y_{1AA}$e $y_{1AB}$ são todos verdadeiros enquanto $y_{1DA}$ é falso.

Nós vamos usar as variáveis $x_{dn}$ para indicar se o algoritmo de Rabin-Scott deve ou não incluir o estado da NFA $n$ no conjunto de estados que rotula o estado do DFA $d$. No exemplo acima, temos$N=8$ Estados do DFA e $M=4$ Estados NFA então existem 32 $x$variáveis. No exemplo acima, suponha que o estado mais inferior (o rotulado "1011") seja o estado$k$, então $x_{kA}$, $x_{kC}$e $x_{kD}$ são verdadeiras enquanto $x_{kB}$ é falso.

Agora as restrições. Antes de tudo, Rabin-Scott deve encontrar uma codificação diferente para cada estado do DFA, portanto, para os estados do DFA$i < j$ e todos os estados da NFA $\{A,B,\cdots, D\}$:

$$(x_{iA} \neq x_{jA}) + (x_{iB} \neq x_{jB}) + \cdots + (x_{iD} \neq x_{jD}).$$

Em seguida, deve ser o caso em que Rabin-Scott encontrou uma transição do estado do DFA $i$ para o estado DFA $j$ no símbolo $s$ então para cada estado da NFA $k$ incluído na codificação de $j$ deve haver um estado NFA $l$ da codificação do estado DFA $j$ de tal forma que a NFA original teve uma transição de $l$ para $k$. No exemplo acima, no símbolo "1", há uma transição do DFA do estado do DFA "1000" para o estado do DFA "1100", portanto, deve haver uma transição do NFA do estado do NFA A para os estados do NFA A e B e nenhuma transição do NFA do NFA estado A para NFA, estado C ou D. Portanto, para cada um dos$o(SN^2)$ arestas no DFA, temos as restrições:

$$\begin{eqnarray*} x_{jA} & = & y_{sAA} x_{iA} + y_{sBA} x_{iB} + \cdots + y_{sDA} x_{iD} \\ x_{jB} & = & y_{sAB} x_{iA} + y_{sBB} x_{iB} + \cdots + y_{sDB} x_{iD} \\ & & \cdots \\ x_{jD} & = & y_{sAD} x_{iA} + y_{sBD} x_{iB} + \cdots + y_{sDD} x_{iD}. \end{eqnarray*}$$

Finalmente, precisamos lidar com o início e aceitar os estados. O estado inicial do DFA é codificado com a união dos estados iniciais da NFA; portanto, é melhor que o estado inicial do DFA não seja codificado com o conjunto vazio;$x_0A + x_0B + \cdots + x_0D$. E, finalmente, precisamos de um conjunto de variáveis$f_n$para indicar se cada estado da NFA é um estado de aceitação da NFA. Deve ser o caso de que a codificação para cada estado de aceitação do DFA contenha pelo menos um estado de aceitação do NFA e que a codificação para cada estado de não aceitação do DFA não contenha estados de aceitação do NFA, portanto:$x_{iA}f_A + x_{iB}f_B + \cdots + x_{iD}f_D$ para DFA aceitar estados $i$ e $\neg (x_{jA}f_A + x_{jB}f_B + \cdots + x_{jD}f_D)$ para estados não aceitos do DFA $j$.

Minimizar NFAs é difícil, tão difícil que até a aproximação é difícil; veja Minimizando NFA e expressões regulares de Gramlich e Schnitger (2005). Este artigo também parece ter algumas referências úteis, por exemplo, algoritmos de redução de NFA por meio de desigualdades regulares de Champarnaud e Coulon (2002), que contêm técnicas de minimização.

Existem algumas noções de FSAs canônicos que não são necessariamente determinísticas e, portanto, podem ser menores que o DFA mínimo. Um exemplo são os FSAs "residuais", para os quais é possível calcular FSAs residuais canônicos diretamente, veja F. Denis, A. Lemay e A. Terlutte. "Autômatos residuais de estado finito", Fundamenta Informaticae 51 (4): 339-368, 2002 . Existem várias alternativas.