Encontrando o menor DFA que separa duas palavras sem usar a pesquisa de força bruta?

Dadas duas seqüências xey, eu quero criar um DFA de tamanho mínimo que aceite xe rejeite y. Uma maneira de fazer isso é a busca por força bruta. Você enumera o DFA começando pelo menor. Você tenta cada DFA até encontrar um que aceite xe rejeite y.

Quero saber se existe outra maneira conhecida de encontrar ou criar um DFA de tamanho mínimo que aceite xe rejeite y. Em outras palavras, podemos vencer a busca por força bruta?

Mais detalhes:

(1) Eu realmente quero que um algoritmo encontre um DFA de tamanho mínimo, não um DFA de tamanho mínimo.

(2) Não quero apenas saber quão grande ou pequeno é o DFA mínimo.

(3) Bem aqui, estou focado apenas no caso de você ter duas cadeias x e y.

Editar :

Informações adicionais para o leitor interessado:

Suponhamos que e são as cadeias binárias de comprimento no máximo . É um resultado conhecido que existe um DFA que aceita e rejeita com no máximo $x$ $y$ $n$ $x$ $y$ estados. Observe que existem cerca de $\sqrt{n}$ DFAs com um alfabeto binário e no máximo $n^{\sqrt{n}}$ estados. Portanto, a abordagem da força bruta não exigiria que enumerássemos mais de $\sqrt{n}$ DFA's. Daqui resulta que a abordagem da força bruta não pode demorar muito mais que $n^{\sqrt{n}}$ tempo. $n^{\sqrt{n}}$

Slides que achei úteis: https://cs.uwaterloo.ca/~shallit/Talks/sep2.pdf

automata-theory dfa fsm

— Michael Wehar
fonte

@ AndrásSalamon Ainda é NP-completo se os conjuntos a serem distinguidos consistem em apenas uma sequência? Parece-me que isso deve ser razoavelmente tratável.

— Mhum

@ humm, o problema é que existem muitos idiomas regulares diferentes que separam as duas strings - a minimização do DFA encontrará o melhor autômato para qualquer um desses idiomas, mas não fará nada para compará-lo aos autômatos dos outros idiomas de separação.

— David Eppstein

tiverem comprimentos diferentes, com o maior comprimento

, é fácil encontrar rapidamente um DFA com os estados

que os separam: basta usar um ciclo de comprimento

, onde

não se divide

. Encontre

tentando

em ordem até encontrar a

apropriada . Se

têm o mesmo comprimento, então

x

$x$

y

$y$

n

$n$

O (\log n)

$O(\log n)$

p

$p$

p

$p$

| x | - | y |

$|x|-|y|$

p

$p$

2, 3, 5, \dots

$2, 3, 5,\ldots$

p

$p$

x

$x$

y

$y$

construção de Robson, em um artigo de 1996, fornece uma máquina simples que pode ser encontrada por uma pesquisa do tamanho

. Nenhuma construção é garantida como o menor DFA.

O (\sqrt{n})

$O(\sqrt{n})$

O (n)

$O(n)$

— Jeffrey Shallit

As anotações de Shallit, vinculadas acima, incluem a observação útil de que o pior caso para o problema de separação é quando o alfabeto é binário: sempre é possível particionar alfabetos maiores em dois subconjuntos que ainda distinguem as duas palavras de entrada e procurar um autômato binário que trate letras em um subconjunto como zeros e letras no outro subconjunto como zeros. Mas, para procurar o autômato de separação mínimo, isso não parece ajudar, porque você pode usar as informações extras do alfabeto original para obter um desempenho melhor do que com um mapeamento para um alfabeto binário.

— David Eppstein

um caso especial dessa outra pergunta recente em que os tamanhos de entrada e saída são iguais a 1. autômatos finitos mínimos dados em palavras e palavras em saída . Essa resposta lista algumas literaturas de aprendizado, incluindo algumas heurísticas.

— precisa saber é

Se eu tivesse que fazer isso na prática, usaria um solucionador SAT.

A questão de saber se existe um DFA com estados que aceita e rejeita pode ser facilmente expressa como uma instância SAT. Por exemplo, uma maneira é ter variáveis booleanas: é verdadeiro se o DFA fizer a transição do estado para o estado no bit de entrada . Em seguida, adicione algumas cláusulas para impor que este é um DFA e algumas variáveis e cláusulas para impor que ele aceita $k$ $x$ $y$ $2k^2$ $z_{s,b,t}$ $s$ $t$ $b$ rejeita $x$ $y$ .

Agora use a pesquisa binária em para encontrar o menor modo que exista um DFA desse tipo. Com base no que li em artigos sobre problemas relacionados, eu esperaria que isso fosse razoavelmente eficaz na prática. $k$ $k$

Outras codificações como SAT são possíveis. Por exemplo, podemos usar uma codificação de rastreamento:

Se é de comprimento , você poderia adicionar variáveis booleanas: Let ser a seqüência de estados atravessados na entrada , e representam cada um usando variáveis booleanas. $x$ $m$ $m\lg k$ $s_0,s_1,\dots,s_m$ $x$ $s_i$ $\lceil \lg k \rceil$
Agora, para cada modo que , você tem a restrição de que $i,j$ $x_i=x_j$ . $s_{i-1}=s_{j-1} \implies s_i=s_j$
Em seguida, estenda-o para manipular : seja a sequência de estados percorridos na entrada e represente cada usando variáveis booleanas . Para cada modo que , adicione a restrição de que $y$ $t_0,\dots,t_n$ $y$ $t_j$ $\lg k$ $i,j$ $y_i=y_j$ . $t_{i-1}=t_{j-1} \implies t_i=t_j$
Da mesma forma, para cada tal que $i,j$ , adicione a restrição de que $x_i=y_j$ . $s_{i-1}=t_{j-1} \implies s_i=t_j$
Ambos os rastreios devem começar a partir do mesmo ponto inicial, portanto, adicione o requisito que (WLOG você pode solicitar ). $s_0=t_0$ $s_0=t_0=0$
Para garantir que o DFA usa apenas estados, exigem que e para todos . $k$ $0 \le s_i < k$ $0 \le t_j <k$ $i,j$
Finalmente, para codificar o requisito de que é aceito e é rejeitado, exija que . $x$ $y$ $s_m \ne t_n$

Todos esses requisitos podem ser codificados como cláusulas SAT.

Como antes, você usaria a pesquisa binária em para encontrar o menor para o qual esse DFA existe. $k$ $k$

— DW
fonte

observe que, na verdade, isso será superior à pesquisa de força bruta se houver certas simetrias no problema e elas forem reconhecidas pelo solucionador, mas atualmente pode ser difícil identificar / isolar essas (seja humana ou máquina). há também alguma "tecnologia" mais recente / relacionada, de teorias de módulos de satisfação e programação de conjuntos de respostas, algumas das quais têm predicados de gráfico "embutidos" ou podem suportar suas definições.

— vzn