生成随机确定性有限自动机的算法是什么？

Question

The DFA must have the following four properties:

• The DFA has N nodes

• Each node has 2 outgoing transitions.

• Each node is reachable from every other node.

• The DFA is chosen with perfectly uniform randomness from all possibilities

This is what I have so far:

1. Start with a collection of N nodes.
2. Choose a node that has not already been chosen.
3. Connect its output to 2 other randomly selected nodes
4. Label one transition 1 and the other transition 0.
5. Go to 2, unless all nodes have been chosen.
6. Determine if there is a node with no incoming connections.
7. If so, steal an incoming connection from a node with more than 1 incoming connection.
8. Go to 6, unless there are no nodes with no incoming connections

However, this is algorithm is not correct. Consider the graph where node 1 has its two connections going to node 2 (and vice versa), while node 3 has its two connection going to node 4 (and vice versa). That is something like:

1 <==> 2

3 <==> 4

Where, by <==> I mean two outgoing connections both ways (so a total of 4 connections). This seems to form 2 cliques, which means that not every state is reachable from every other state.

Does anyone know how to complete the algorithm? Or, does anyone know another algorithm? I seem to vaguely recall that a binary tree can be used to construct this, but I am not sure about that.

Answer 1

Strong connectivity is a difficult constraint. Let's generate uniform random surjective transition functions and then test them with eg Tarjan's linear-time SCC algorithm until we get one that's strongly connected. This process has the right distribution, but it's not clear that it's efficient; my researcher's intuition is that the limiting probability of strong connectivity is less than 1 but greater than 0, which would imply only O(1) iterations are necessary in expectation.

Generating surjective transition functions is itself nontrivial. Unfortunately, without that constraint it is exponentially unlikely that every state has an incoming transition. Use the algorithm described in the answers to this question to sample a uniform random partition of {(1, a), (1, b), (2, a), (2, b), …, (N, a), (N, b)} with N parts. Permute the nodes randomly and assign them to parts.

For example, let N = 3 and suppose that the random partition is

{{(1, a), (2, a), (3, b)}, {(2, b)}, {(1, b), (3, a)}}.

We choose a random permutation 2, 3, 1 and derive a transition function

(1, a) |-> 2
(1, b) |-> 1
(2, a) |-> 2
(2, b) |-> 3
(3, a) |-> 1
(3, b) |-> 2

Answer 2

There is a expected running time O(n^{3/2}) algorithm.

If you generate a uniform random digraph with m vertices such that each vertex has k labelled out-arcs (a k-out digraph), then with high probability the largest SCC (strongly connected component) in this digraph is of size around c_k m, where c_k is a constant depending on k. Actually, there is about 1/\\sqrt{m} probability that the size of this SCC is exactly c_k m (rounded to an integer).

So you can generate a uniform random 2-out digraph of size n/c_k, and check the size of the largest SCC. If its size is not exactly n, just try again until success. The expected number of trials needed is \\sqrt{n}. And generating each digraph should be done in O(n) time. So in total the algorithm has expected running time O(n^{3/2}). See this paper for more details.

Answer 3

In what follows I'll use the basic terminology of graph theory .

You could:

1. Start with a directed graph with N vertices and no arcs.
2. Generate a random permutation of the N vertices to produce a random Hamiltonian cycle, and add it to the graph.
3. For each vertex add one outgoing arc to a randomly chosen vertex.

The result will satisfy all three requirements.

Answer 4

The following references seem to be relevant to your question:

F. Bassino, J. David and C. Nicaud, Enumeration and random generation of possibly incomplete deterministic automata, Pure Mathematics and Applications 19 (2-3) (2009) 1-16.

F. Bassino and C. Nicaud. Enumeration and Random Generation of Accessible Automata. Theor. Comp. Sc. . 381 (2007) 86-104.

Answer 5

Just keep growing a set of nodes which are all reachable. Once they're all reachable, fill in the blanks.

Start with a set of N nodes called A.
Choose a node from A and put it in set B.
While there are nodes left in set A
    Choose a node x from set A
    Choose a node y from set B with less than two outgoing transitions.
    Choose a node z from set B
    Add a transition from y to x.
    Add a transition from x to z
    Move x to set B
For each node n in B
    While n has less than two outgoing transitions
         Choose a node m in B
         Add a transition from n to m
Choose a node to be the start node.
Choose some number of nodes to be accepting nodes.

Every node in set B can reach every node in set B. As long as a node can be reached from a node in set B and that node can reach a node in set B, it can be added to the set.

Answer 6

The simplest way that I can think of is to (uniformly) generate a random DFA with N nodes and two outgoing edges per node, ignoring the other constraints, and then throw away any that are not strongly connected (which is easy to test using a strongly connected components algorithm). Generating uniform DFAs should be straightforward without the reachability constraint. The one thing that could be problematic performance-wise is how many DFAs you would need to skip before you found one with the reachability property. You should try this algorithm first, though, and see how long it ends up taking to generate an acceptable DFA.

Answer 7

We can start with a random number of states N1 between N and 2N.

Assume the initial state the as the state number 1. For each state, for each character in the input alphabet we generate a random transition (between 1 and N1).

We take the connex automaton starting from the initial state. We check the number of states, and after few tries we get one with N states.

If we wish a minimal automaton too, remains only the assignment of final states, however there are great chances that a random assignment gets a minimal automaton as well.