Learning Nominal Automata

Abstract

We present an Angluin-style algorithm to learn nominal automata, which are
acceptors of languages over infinite (structured) alphabets. The abstract
approach we take allows us to seamlessly extend known variations of the
algorithm to this new setting. In particular we can learn a subclass of nominal
non-deterministic automata. An implementation using a recently developed Haskell
library for nominal computation is provided for preliminary experiments.

Links

Note (during rebuttal phase)

During the rebuttal one of the reviewers asked whether the problem of query
learning can be solved polynomially or not. We settled the issue positively,
but did not have the room to fit it in the paper. We added the proof in the
rebuttal (so it's not really peer reviewed). The original copy is found online
on Matteo's website.
(The following is not properly typeset yet.)

The problem of learning a nominal automaton is polynomial (in the number of
orbits) for the equality symmetry.
Proof (sketch)
The problem can in fact be proven to be polynomial (in the number of orbits, it
will not be polynomial in the dimension of the nominal automaton). In order to
see this we need to alter the algorithm slightly. In a way this can be seen as
an optimization. Note that the paper already states that the number of cells is
polynomial, so it remains to show that filling them with membership queries can
be done polynomially.
We will use the same notation as in the paper (n is number of orbits, k is
dimension and p is the dimension of the alphabet). As noted in the paper, the
support for a row will grow during the execution of the algorithm, until it hits
the bound k. Let's say that at a current stage of the algorithm the size of the
support for a particular row is k' (<= k). We consider the same rows as we
would normally do (without the optimization). Now to fill the cells for such an
extension, we only have to consider a support of at most k'+p (the k' comes from
the original row and p comes from the alphabet). Suppose the column has at most
length q(n,k) for some polynomial q (as proven in the paper), then the number of
data values is at most p * q(n, k). Thus the number of orbits of such a product
is at most f_A(k' + p, p * q(n, k)), which is polynomial in n (and not
polynomial in k). Some more details for the function f_A are given below (be
aware that this function depends on the symmetry).
If we now do the above throughout the algorithm (meaning that we carefully keep
track of the supports of rows, and also propagate this information to the
extensions), then the relevant data values for each row are bounded by k+p.
Indeed, all the cells in the table will have polynomially many orbits (in n).
Combined with the fact that there are polynomially many cells in total, this
proves that the number of membership queries is polynomial in n.
Note that the soundness for this optimization follows from consistency: the
possibility of having too small support is ruled out as the same extensions are
considered, so if a data value matters, the extensions will have different rows
(maybe after several steps). Each inconsistency will lead to new columns (just
as before), which will show at some point that a data value is in the support.
The number of equivalence queries was already proven to be polynomial. So the
number of queries in total is polynomial in n (but not in k).
End of proof.
Bonus: One may question whether we can do something similar to the columns,
bounding their support to k. The answer is no, because the reverse of a regular
nominal language is not necessarily accepted by an orbit-finite nominal automaton
(and by reversing a language one reverses the roles of the rows and columns).
Additional notes on f_A (where A is the countably infinite set of names with
permutations).
As defined in the paper f_A(n, m) defines the number of orbits in A^(n) x A^(m),
that is the product of distinct n-tuples with distinct m-tuples. An orbit in
this product possibly matches some of the first n values with some of the next m
values. We can compute the number of orbits where such a match has size i with
the following formula. With n and i fixed, it gives a polynomial bound in m:
matchings_i = (n choose i) * (m choose i) * i!
<= (n choose i) * i! * m^i
The equality is explained as such: we may choose i values of either set
independently, and then choose how to match them (i!). Now f_A(n, m) is the sum
of matchings_i for i = 0 to n. This gives the formula and bound
f_A(n, m) = Sum_{i = 0}^{n} matchings_i
<= constant_n * m^{n+1}
where constant_n is some constant depending on n. In particular this expression
is polynomial in m. Furthermore, we have a symmetry f_A(n, m) = f_A(m, n),
meaning that it is also polynomial in n (if m is fixed). Note, however, that
f_A(n, n) is not polynomial in n. In the above proof, n (the number of orbits),
occurs in only one of the two places, making it polynomial in n.
In this counting argument we used the fact that these orbits correspond to
matchings. This does not hold in other symmetries. For example the structure (Q,