13,962 research outputs found
Learning to Prove Safety over Parameterised Concurrent Systems (Full Version)
We revisit the classic problem of proving safety over parameterised
concurrent systems, i.e., an infinite family of finite-state concurrent systems
that are represented by some finite (symbolic) means. An example of such an
infinite family is a dining philosopher protocol with any number n of processes
(n being the parameter that defines the infinite family). Regular model
checking is a well-known generic framework for modelling parameterised
concurrent systems, where an infinite set of configurations (resp. transitions)
is represented by a regular set (resp. regular transducer). Although verifying
safety properties in the regular model checking framework is undecidable in
general, many sophisticated semi-algorithms have been developed in the past
fifteen years that can successfully prove safety in many practical instances.
In this paper, we propose a simple solution to synthesise regular inductive
invariants that makes use of Angluin's classic L* algorithm (and its variants).
We provide a termination guarantee when the set of configurations reachable
from a given set of initial configurations is regular. We have tested L*
algorithm on standard (as well as new) examples in regular model checking
including the dining philosopher protocol, the dining cryptographer protocol,
and several mutual exclusion protocols (e.g. Bakery, Burns, Szymanski, and
German). Our experiments show that, despite the simplicity of our solution, it
can perform at least as well as existing semi-algorithms.Comment: Full version of FMCAD'17 pape
Bounds in Query Learning
We introduce new combinatorial quantities for concept classes, and prove
lower and upper bounds for learning complexity in several models of query
learning in terms of various combinatorial quantities. Our approach is flexible
and powerful enough to enough to give new and very short proofs of the
efficient learnability of several prominent examples (e.g. regular languages
and regular -languages), in some cases also producing new bounds on the
number of queries. In the setting of equivalence plus membership queries, we
give an algorithm which learns a class in polynomially many queries whenever
any such algorithm exists.
We also study equivalence query learning in a randomized model, producing new
bounds on the expected number of queries required to learn an arbitrary
concept. Many of the techniques and notions of dimension draw inspiration from
or are related to notions from model theory, and these connections are
explained. We also use techniques from query learning to mildly improve a
result of Laskowski regarding compression schemes
Learning Residual Finite-State Automata Using Observation Tables
We define a two-step learner for RFSAs based on an observation table by using
an algorithm for minimal DFAs to build a table for the reversal of the language
in question and showing that we can derive the minimal RFSA from it after some
simple modifications. We compare the algorithm to two other table-based ones of
which one (by Bollig et al. 2009) infers a RFSA directly, and the other is
another two-step learner proposed by the author. We focus on the criterion of
query complexity.Comment: In Proceedings DCFS 2010, arXiv:1008.127
Quantum Algorithms for Learning and Testing Juntas
In this article we develop quantum algorithms for learning and testing
juntas, i.e. Boolean functions which depend only on an unknown set of k out of
n input variables. Our aim is to develop efficient algorithms:
- whose sample complexity has no dependence on n, the dimension of the domain
the Boolean functions are defined over;
- with no access to any classical or quantum membership ("black-box")
queries. Instead, our algorithms use only classical examples generated
uniformly at random and fixed quantum superpositions of such classical
examples;
- which require only a few quantum examples but possibly many classical
random examples (which are considered quite "cheap" relative to quantum
examples).
Our quantum algorithms are based on a subroutine FS which enables sampling
according to the Fourier spectrum of f; the FS subroutine was used in earlier
work of Bshouty and Jackson on quantum learning. Our results are as follows:
- We give an algorithm for testing k-juntas to accuracy that uses
quantum examples. This improves on the number of examples used
by the best known classical algorithm.
- We establish the following lower bound: any FS-based k-junta testing
algorithm requires queries.
- We give an algorithm for learning -juntas to accuracy that
uses quantum examples and
random examples. We show that this learning algorithms is close to optimal by
giving a related lower bound.Comment: 15 pages, 1 figure. Uses synttree package. To appear in Quantum
Information Processin
Learning Moore Machines from Input-Output Traces
The problem of learning automata from example traces (but no equivalence or
membership queries) is fundamental in automata learning theory and practice. In
this paper we study this problem for finite state machines with inputs and
outputs, and in particular for Moore machines. We develop three algorithms for
solving this problem: (1) the PTAP algorithm, which transforms a set of
input-output traces into an incomplete Moore machine and then completes the
machine with self-loops; (2) the PRPNI algorithm, which uses the well-known
RPNI algorithm for automata learning to learn a product of automata encoding a
Moore machine; and (3) the MooreMI algorithm, which directly learns a Moore
machine using PTAP extended with state merging. We prove that MooreMI has the
fundamental identification in the limit property. We also compare the
algorithms experimentally in terms of the size of the learned machine and
several notions of accuracy, introduced in this paper. Finally, we compare with
OSTIA, an algorithm that learns a more general class of transducers, and find
that OSTIA generally does not learn a Moore machine, even when fed with a
characteristic sample
Query learning of derived -tree languages in polynomial time
We present the first polynomial time algorithm to learn nontrivial classes of
languages of infinite trees. Specifically, our algorithm uses membership and
equivalence queries to learn classes of -tree languages derived from
weak regular -word languages in polynomial time. The method is a
general polynomial time reduction of learning a class of derived -tree
languages to learning the underlying class of -word languages, for any
class of -word languages recognized by a deterministic B\"{u}chi
acceptor. Our reduction, combined with the polynomial time learning algorithm
of Maler and Pnueli [1995] for the class of weak regular -word
languages yields the main result. We also show that subset queries that return
counterexamples can be implemented in polynomial time using subset queries that
return no counterexamples for deterministic or non-deterministic finite word
acceptors, and deterministic or non-deterministic B\"{u}chi -word
acceptors.
A previous claim of an algorithm to learn regular -trees due to
Jayasrirani, Begam and Thomas [2008] is unfortunately incorrect, as shown in
Angluin [2016]
Synthesizing Program Input Grammars
We present an algorithm for synthesizing a context-free grammar encoding the
language of valid program inputs from a set of input examples and blackbox
access to the program. Our algorithm addresses shortcomings of existing grammar
inference algorithms, which both severely overgeneralize and are prohibitively
slow. Our implementation, GLADE, leverages the grammar synthesized by our
algorithm to fuzz test programs with structured inputs. We show that GLADE
substantially increases the incremental coverage on valid inputs compared to
two baseline fuzzers
- …