Trouver le plus petit DFA qui sépare deux mots sans utiliser la recherche par force brute?

Étant donné deux chaînes x et y, je veux créer une taille minimale DFA qui accepte x et rejette y. Une façon de le faire est la recherche par force brute. Vous énumérez les DFA en commençant par le plus petit. Vous essayez chaque DFA jusqu'à ce que vous en trouviez un qui accepte x et rejette y.

Je veux savoir s'il existe un autre moyen connu de trouver ou de créer un DFA de taille minimale qui accepte x et rejette y. En d'autres termes, pouvons-nous battre la recherche par force brute?

Plus de détails:

(1) Je veux vraiment qu'un algorithme trouve une taille minimale DFA, pas une taille DFA proche de la taille minimale.

(2) Je ne veux pas seulement savoir quelle est la taille du DFA minimum.

(3) Ici, je ne me concentre que sur le cas où vous avez deux chaînes x et y.

Modifier :

Informations supplémentaires pour le lecteur intéressé:

Supposons que $x$ et $y$ sont des chaînes binaires de longueur au plus $n$ . C'est un résultat connu qu'il existe un DFA qui accepte $x$ et rejette $y$ avec au plus $\sqrt{n}$ états. Notez qu'il y a environ $n^{\sqrt{n}}$ DFA avec un alphabet binaire et au plus $\sqrt{n}$ états. Par conséquent, l'approche par force brute ne nous obligerait pas à énumérer plus de $n^{\sqrt{n}}$ DFA. Il s'ensuit que l'approche par force brute ne pouvait pas prendre beaucoup plus que $n^{\sqrt{n}}$ temps.

Diapositives que j'ai trouvées utiles: https://cs.uwaterloo.ca/~shallit/Talks/sep2.pdf

automata-theory dfa fsm

— Michael Wehar
source

@ AndrásSalamon Est-il toujours NP-complet si les ensembles à distinguer se composent chacun d'une seule chaîne? Il me semble que cela devrait être raisonnablement réalisable.

— mhum

@mhum le problème qu'il existe de nombreuses langues régulières différentes qui séparent les deux chaînes - la minimisation DFA trouvera le meilleur automate pour l'une de ces langues mais ne fera rien pour le comparer aux automates pour les autres langues de séparation.

— David Eppstein

sont de longueurs différentes, avec la plus grande de longueur

, il est facile de trouver rapidement un DFA avec des états

qui les sépare: utilisez simplement un cycle de longueur

, où

ne se divise pas

. Trouvez

en essayant

dans l'ordre jusqu'à ce que vous trouviez le

approprié

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$ . Si

ont la même longueur, alors le

x

$x$

y

$y$

construction de Robson, dans un article de 1996, donne une machine simple que l'on peut trouver par une recherche de taille

. Aucune construction n'est garantie comme étant la plus petite DFA.

O (\sqrt{n})

$O(\sqrt{n})$

O (n)

$O(n)$

— Jeffrey Shallit

Les notes de Shallit, liées ci-dessus, incluent l'observation utile que le pire cas pour le problème de séparation est lorsque l'alphabet est binaire: il est toujours possible de partitionner des alphabets plus grands en deux sous-ensembles qui distinguent toujours les deux mots d'entrée et de rechercher un automate binaire qui traite lettres dans un sous-ensemble comme 0 et lettres dans l'autre sous-ensemble comme 1. Mais pour rechercher l'automate de séparation minimum, cela ne semble pas aider, car vous pourriez être en mesure d'utiliser les informations supplémentaires de l'alphabet d'origine pour faire mieux que vous ne le pourriez avec un mappage vers un alphabet binaire.

— David Eppstein

un cas particulier de cette autre question récente où les tailles d'entrée et de sortie sont égales à 1. des automates finis minimaux donnés en mots et en mots . cette réponse énumère de la littérature d'apprentissage, y compris des heuristiques.

— vzn

Si je devais le faire dans la pratique, j'utiliserais un solveur SAT.

La question de savoir s'il existe un DFA avec états qui accepte et rejette peut être facilement exprimée comme une instance SAT. Par exemple, une façon consiste à avoir variables booléennes: est vrai si le DFA passe de l'état à l'état sur le bit d'entrée . Ajoutez ensuite quelques clauses pour faire en sorte qu'il s'agisse d'un DFA, et quelques variables et clauses pour faire en sorte qu'il accepte et rejette . $k$ $x$ $y$ $2k^2$ $z_{s,b,t}$ $s$ $t$ $b$ $x$ $y$

Utilisez maintenant la recherche binaire sur pour trouver le plus petit tel qu'il existe un DFA de ce type. Sur la base de ce que j'ai lu dans des articles sur un problème connexe, je m'attendrais à ce que cela soit raisonnablement efficace dans la pratique. $k$ $k$

D'autres codages de cela comme SAT sont possibles. Par exemple, nous pouvons utiliser un encodage de trace:

Si est de longueur , vous pouvez ajouter variables booléennes: soit soit la séquence d'états traversés sur l'entrée , et représenter chaque aide de variables booléennes. $x$ $m$ $m\lg k$ $s_0,s_1,\dots,s_m$ $x$ $s_i$ $\lceil \lg k \rceil$
Maintenant, pour chaque tel que , vous avez la contrainte que $i,j$ $x_i=x_j$ . $s_{i-1}=s_{j-1} \implies s_i=s_j$
Ensuite, étendez ceci pour gérer : soit la séquence d'états traversés sur l'entrée , et représentez chaque aide de variables booléennes. Pour chaque tel que , ajoutez la contrainte 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$
De même, pour chaque tel que , ajoutez la contrainte que $i,j$ $x_i=y_j$ . $s_{i-1}=t_{j-1} \implies s_i=t_j$
Les deux traces doivent commencer à partir du même point de départ, donc ajoutez l'exigence que (WLOG vous pouvez exiger ). $s_0=t_0$ $s_0=t_0=0$
Pour garantir que le DFA n'utilise que états, exigez que et pour tout . $k$ $0 \le s_i < k$ $0 \le t_j <k$ $i,j$
Enfin, pour coder l'exigence selon laquelle est accepté et est rejeté, il faut que . $x$ $y$ $s_m \ne t_n$

Toutes ces exigences peuvent être codées en tant que clauses SAT.

Comme précédemment, vous utiliseriez la recherche binaire sur pour trouver le plus petit pour lequel un tel DFA existe. $k$ $k$

— DW
source

notez que cela sera en fait supérieur à la recherche par force brute s'il y a certaines symétries dans le problème et qu'elles sont reconnues par le solveur, mais il peut actuellement être difficile d'identifier / d'isoler celles-ci (que ce soit pour l'homme ou la machine). il existe également des "technologies" plus récentes / apparentées de théories de module de satisfiabilité et de programmation d'ensembles de réponses dont certaines ont des prédicats de graphes "intégrés" ou peuvent prendre en charge leurs définitions.

— vzn