Intersection DFA dans l'espace sub-quadratique?

25

L'intersection de deux DFA (minimes) avec n états peut être calculée en utilisant O (n ² ) temps et espace. Ceci est optimal en général, car le DFA résultant (minimal) peut avoir n ² états. Cependant, si le DFA minimal résultant a z états, où z = O (n), peut-il être calculé dans l'espace n ^2-eps , pour un eps constant> 0? Je serais intéressé par un tel résultat même pour le cas spécial où les DFA d'entrée sont acycliques.

automata-theory dfa

— Rasmus Pagh
source

3

Um ... si deux DFA à n états sont acycliques, alors chacun accepte simplement un ensemble fini de mots de longueur au plus n, auquel cas leur intersection est juste l'intersection des deux graphes de transition étiquetés, qui auront n états et peut être calculé en temps et en espace linéaires. Ou est-ce que je manque quelque chose?

— Joshua Grochow

4

Oui, les DFA acycliques n'acceptent qu'un ensemble fini de mots. Mais il existe des exemples de DFA acycliques dont l'intersection a la taille n ^ 2. Par exemple, pensez à un DFA qui accepte des chaînes de la forme AABC (où ABC sont des chaînes de longueur k) et à un autre qui accepte des chaînes de la forme ABCC.

— Rasmus Pagh du

1

retagging: cs.cc est une désignation arxiv, donc les balises données n'ont pas besoin du préfixe cs.cc.

— Suresh Venkat

15

La réponse est oui sans aucune exigence sur la taille de l'automate. Il peut être calculé dans l' espace $O(\log^2 n)$ même pour $k$ DFA où $k$ est une constante.

Soit ( soient DFA. Nous montrons que, compte tenu , le calcul du DFA minimal reconnaissant peut être fait en $A_i = (Q_i, \Sigma_i, \delta_i, z_i, F_i)$ $i \in [k])$ $k$ $\langle A_1, \ldots, A_k \rangle$ $\text{L}(A_1) \cap \cdots \cap\text{L}(A_k)$ espace. Nous prouvons d'abord quelques résultats techniques. $O(\log^2 n)$

Définition 1 : Soit deux états puis ssi , $q, r$ $q \equiv r$ $\forall w \in \Sigma^*$ $q . w \in F \Leftrightarrow r . w \in F$

Nous considérons maintenant l'automate donné par la construction classique du produit cartésien. Que et soit des états de . $A$ $q = (q_1, \ldots, q_k)$ $r = (r_1, \ldots, r_k)$ $A$

Lemme 1 : Décider si est en NL. $q \equiv r$

Preuve (esquisse): Nous montrons que le test de l'inéquivalence est en NL et utilisons NL = coNL. Devinez un mot (une lettre à la fois) tel que est un état final et ne l'est pas. Ceci peut être réalisé en calculant dans l'espace logarithmique pour et en utilisant le fait que est final ssi $w \in \Sigma^*$ $q . w$ $r . w$ $q_i . w, r_i . w$ $i \in [k]$ $q$ . On peut montrer que implique l'existence d'un de poly-taille. $q_i \in F_i \, \forall i \in [k]$ $q \not\equiv r$ $w$

Lemme 2 : Décider si est (in) accessible est en NL. $q$

Preuve (esquisse): devinez (poly-taille) les chemins de à ( ). $z_i$ $q_i$ $i \in [k]$

Définition 2 : Considérons les états de dans l'ordre lexicographique. Définissez comme étant le premier état accessible et le premier état accessible suivant qui n'est équivalent à aucun état précédent. Nous définissons comme l'unique tel que . $A$ $s(1)$ $s(i)$ $s(i-1)$ $c(q)$ $i$ $q \equiv s(i)$

Lemme 3 : peut être calculé dans l' espace . $s(i)$ $O(\log^2 n)$

Preuve (esquisse): la définition 2 donne un algorithme. Nous utilisons compteurs pour parcourir les états. Soit et l'état actuel. À chaque état, nous utilisons le lemme 2 pour vérifier si est accessible. Si c'est le cas, nous bouclons sur tous les états précédents et nous vérifions si l'un d'eux est équivalent à . S'il n'y en a pas, on incrémente et on sort si . Sinon, nous stockons comme étant et nous continuons. Étant donné que nous ne stockons qu'un nombre constant de compteurs et que nos tests peuvent être effectués en $k$ $j \leftarrow 0$ $q$ $q$ $q$ $j$ $q$ $j = i$ $q$ $s(j)$ , ceci complète la preuve. $\text{NL} \subseteq \text{DSPACE}(\log^2 n)$

Corollaire 1 : peut être calculé dans l' espace . $c(q)$ $O(\log^2 n)$

Théorème : La minimisation de peut être effectuée dans l' espace . $A$ $O(\log^2 n)$

Preuve (esquisse): Soit être le plus grand tel que soit défini (c'est-à-dire le nombre de classes de ). Nous donnons un algorithme produisant un automate où $1 \leq m \leq |Q_0| \cdots |Q_1|$ $i$ $s(i)$ $\equiv$ $A' = (Q', \Sigma, \delta', z', F')$

; $Q' = \lbrace s(i) : i \in [m] \rbrace$
; $F' = \lbrace q \in Q' : q_i \in F_i \, \forall i \in [k] \rbrace$
où . $z' = s(c(q))$ $q = (z_0, \ldots, z_k)$

Nous montrons maintenant comment calculer . Pour chaque , calculez et sortir la transition . Par le lemme 3 et le corollaire 1, cet algorithme s'exécute dans l' espace . On peut vérifier que $\delta'$ $i \in [m], a \in \Sigma$ $q \leftarrow s(i) . a$ $\left(s(i), a, s(c(q))\right)$ $O(\log^2 n)$ $A'$ est minimale et . $\text{L}(A') = \text{L}(A)$

— Michael Blondin
source

3

Bel algorithme! Voici une façon légèrement différente de voir cet algorithme. Son noyau est que la minimisation d'état de n'importe quel DFA donné peut être effectuée dans le temps polynomial et l' espace

. Après cela, il est facile de construire un DFA représentant l'intersection dans l'espace logarithmique (donc dans le temps polynomial et l'espace

), et nous pouvons composer deux fonctions calculables en temps polynomial et espace

(d'une manière similaire à la composition de deux réductions d'espace logarithmique), produisant l'algorithme entier en temps polynomial et

O (\log^{2} n)

$O(\log^2 n)$

O (\log^{2} n)

$O(\log^2 n)$

O (\log^{2} n)

$O(\log^2 n)$

espace.

O (\log^{2} n)

$O(\log^2 n)$

— Tsuyoshi Ito

2

I just saw this answer... I don't see why the algorithm runs in polytime and

O (\log^{2} n)

$O(\log^2 n)$ space simultaneously. Yes,

N L \subseteq P \cap D S P A C E [\log^{2} n]

$NL \subseteq P \cap DSPACE[\log^2 n]$ , but it is not known if

N L \subseteq T I S P [n^{O (1)}, \log^{2} n]

$NL \subseteq TISP[n^{O(1)}, \log^2 n]$ -- that is, we can get an algorithm running in polytime, and we can get another algorithm running in

, mais je ne sais pas comment résoudre les problèmes de

en polytemps et

avec un seul algorithme.

O (\log^{2} n)

$O(\log^2 n)$

N L

$NL$

O (\log^{2} n)

$O(\log^2 n)$

— Ryan Williams

Vous avez raison, je ne sais pas non plus. Je l'ai posté il y a longtemps, donc je ne sais pas pourquoi je l'ai écrit de cette façon, mais peut-être que je voulais dire "temps polynomial ou O (log² n)". Je vais le modifier car il est trompeur. Merci!

— Michael Blondin

14

Dick Lipton et ses collègues ont récemment travaillé sur ce problème, et Lipton en a parlé ici:

http://rjlipton.wordpress.com/2009/08/17/on-the-intersection-of-finite-automata/

It appears that doing better than O(n^2) is open even for the very-special case of determining if the DFA intersection defines the empty language.
The paper gives complexity consequences that would result from a much-improved algorithm handling not just 2 DFAs in the intersection, but larger numbers as well.

— Andy Drucker
source

1

and what about lower bounds?

— Marcos Villagra

1

Juste pour clarifier les questions: je suis heureux de passer O (n ^ 2) de temps (ou peut-être même n ^ O (1) de temps) pour améliorer l'espace lié.

— Rasmus Pagh

13

Si vous disposez de k DFA (k fait partie de l'entrée) et que vous souhaitez savoir si leur intersection est vide, ce problème est PSPACE-complete en général:

Dexter Kozen: limites inférieures pour les systèmes de preuve naturels FOCS 1977: 254-266

Peut-être que si vous étudiez attentivement cette preuve (et les constructions similaires de Lipton et de ses co-auteurs), vous pourriez trouver une sorte d'espace limite inférieure même pour k fixe.

— Ryan Williams
source

Thanks for this pointer. I'm guessing that this could possibly lead to an n^Omega(1) space lower bound on the additional space needed, apart from the input. But could it possibly lead to a super-linear space lower bound?

— Rasmus Pagh

1

@user124864 Given

k

$k$ DFA's with

n

$n$ states each, the product automaton will have

n^{k}

$n^k$ states. Now, there are two tricks you can do to reduce its size. The first is that you just consider the reachable component of the product graph. Second, you could minimize the product DFA. At the end of the day, figuring out what language is recognized by this product automaton is hard.

— Michael Wehar

1

@user124864 Even just trying to determine if the product DFA recognizes a non-empty language is hard. This is the intersection non-emptiness problem. By hard, I mean that it is

X N L

$XNL$ complete in a strong sense.

— Michael Wehar

1

@user124864 If you can solve it in less than

n^{k}

$n^k$ time, then we get faster algorithms for PSPACE complete problems. It is not solvable in

o (1) \cdot k \cdot \log (n)

$o(1) \cdot k \cdot \log(n)$ non-deterministic binary space. It's not known if we can solve it in less than

k^{2} \log^{2} (n)

$k^2 \log^2(n)$ deterministic binary space. It's not known if we can solve it in simultaneous deterministic polynomial time and

f (k) \cdot \log^{2} (n)

$f(k) \cdot \log^2(n)$ binary space for any function

f

$f$ (doing so would improve Savitch's theorem).

— Michael Wehar

1

@user124864 Note: we have both of the following. (1) Beating

n^{k}

$n^k$ time deterministically implies faster deterministic algorithms for PSPACE complete problems and (2) beating

n^{k}

$n^k$ time non-deterministically implies faster non-deterministic algorithms for PSPACE complete problems.

— Michael Wehar

7

Given two automata $A$ , $B$ accepting finite languages (acyclic automata), the state complexity of $L(A) \cap L(B)$ is in $\Theta(|A| \cdot |B|)$ (1). This result also holds for unary DFAs (not necessarily acyclic) (2). However, you seem to be talking about the space required to compute the intersection of two automata. I don't see how the classic construction using the Cartesian product uses $O(n^2)$ space. All you need is a constant number of counters of logarithmic size. When you compute the transition function for the new state $(q,r)$ you only have to scan the input without looking to any previously generated data.

Perhaps you want to output the minimal automaton? If this is the case, then I have no clue whether it can be achieved. The state complexity of the intersection for finite languages doesn't seem encouraging. However, unary DFAs have the same state complexity and I think it can be achieved with such automata. By using results from (2), you can get the exact size of the automaton recognizing the intersection. This size is described by the length of the tail and the cycle, thus the transition function can be easily computed with very few space since the structure is entirely described by those two sizes. Then, all you have to do is to generate the set of final states. Let $n$ be the number of states in the resulting automaton, then for all $1 \leq i \leq n$ , state $i$ est un état final ssi $a^i$ est accepté par les deux $A$ et $B$ . Ce test peut être effectué avec peu d'espace.

— Michael Blondin
source

1

Yes, I am interested in the minimal automaton, or at least an automaton of similar size. Thanks for the pointers to unary DFAs. However, this does not seem to help much for the general case.

— Rasmus Pagh