Lecture Notes in Computer Science 3472

594 Therese Berg and Harald Raffelt
Using this observation, one can show that it suffices to compare L1 and L2 for
all strings up to some length linearly bounded by the sizes of the two automata.
Vasilevskii and Chow further show that if one automaton is given explicitly, the
number of comparisons can be slightly improved.
Details can be found in Chapter 4.7.
A Probabilistic Approach Angluin [Ang87] proposes an equivalence check
that yields a correct answer up to some given failure probability.
An Oracle can be realized as a function picking strings randomly and comparing
the machine and the hypothesis for those. If a mismatch is found, the
corresponding string is a counterexample. If no mismatch is found, the two systems
are classified as identical. This conclusion might be wrong with a certain
probability. However, if we know the probability distribution of strings being
accepted, one can compute the number of comparisons needed to guarantee that
this failure probability is below a given limit. See [Ang87] for details.
19.4.6 Query Complexity of the Algorithms
We discuss only the query complexity of the algorithms, i.e., the number of
queries needed to construct a correct model of the SUT’s regular language. Their
time complexity can be estimated with similar arguments.
In this subsection, let n, m, andk be the number of states of M, the length
of the longest counterexample returned in a counterexample, and the size of Σ,
respectively.
For all algorithms discussed, the number of equivalence queries is at most n:
each counterexample processed immediately adds at least one new state to the
current hypothesis. Note however, that this number is an upper bound and can
be expected to vary in practice for the different algorithms. For example, in the
discrimination tree algorithm one needs exactly n equivalence queries, since a
new state can only be found with such a query. In Angluin’s algorithm, on the
other hand, the consistency check that is based on membership queries might
give rise to new states as well.
The algorithms differ in the number of membership queries. We first discuss
the complexity of the algorithm based on observation packs.
In the observation pack algorithm membership queries are performed for two
different purposes: to check for closedness and to process a counterexample.
Consider the first type of membership queries. The observation pack is closed
when, for every access string si and letter a, sia is like some other access string.
This is easily determined with membership queries. If the check fails, it provides
a witness of non-closedness. If it succeeds, a DFA can be built from the answers
of the queries.
Each component contains an access string plus at most n − 1 strings used to
separate it from the other at most n−1 components. Therefore, in the worst case,
checking for closedness means asking at most n queries for each of (n) strings
si and (n) queriesforeachof(kn) stringssia, giving a total of O((k +1)n 2 )