551 research outputs found
Generalizing input-driven languages: theoretical and practical benefits
Regular languages (RL) are the simplest family in Chomsky's hierarchy. Thanks
to their simplicity they enjoy various nice algebraic and logic properties that
have been successfully exploited in many application fields. Practically all of
their related problems are decidable, so that they support automatic
verification algorithms. Also, they can be recognized in real-time.
Context-free languages (CFL) are another major family well-suited to
formalize programming, natural, and many other classes of languages; their
increased generative power w.r.t. RL, however, causes the loss of several
closure properties and of the decidability of important problems; furthermore
they need complex parsing algorithms. Thus, various subclasses thereof have
been defined with different goals, spanning from efficient, deterministic
parsing to closure properties, logic characterization and automatic
verification techniques.
Among CFL subclasses, so-called structured ones, i.e., those where the
typical tree-structure is visible in the sentences, exhibit many of the
algebraic and logic properties of RL, whereas deterministic CFL have been
thoroughly exploited in compiler construction and other application fields.
After surveying and comparing the main properties of those various language
families, we go back to operator precedence languages (OPL), an old family
through which R. Floyd pioneered deterministic parsing, and we show that they
offer unexpected properties in two fields so far investigated in totally
independent ways: they enable parsing parallelization in a more effective way
than traditional sequential parsers, and exhibit the same algebraic and logic
properties so far obtained only for less expressive language families
Interacting via the Heap in the Presence of Recursion
Almost all modern imperative programming languages include operations for
dynamically manipulating the heap, for example by allocating and deallocating
objects, and by updating reference fields. In the presence of recursive
procedures and local variables the interactions of a program with the heap can
become rather complex, as an unbounded number of objects can be allocated
either on the call stack using local variables, or, anonymously, on the heap
using reference fields. As such a static analysis is, in general, undecidable.
In this paper we study the verification of recursive programs with unbounded
allocation of objects, in a simple imperative language for heap manipulation.
We present an improved semantics for this language, using an abstraction that
is precise. For any program with a bounded visible heap, meaning that the
number of objects reachable from variables at any point of execution is
bounded, this abstraction is a finitary representation of its behaviour, even
though an unbounded number of objects can appear in the state. As a
consequence, for such programs model checking is decidable.
Finally we introduce a specification language for temporal properties of the
heap, and discuss model checking these properties against heap-manipulating
programs.Comment: In Proceedings ICE 2012, arXiv:1212.345
Beyond Language Equivalence on Visibly Pushdown Automata
We study (bi)simulation-like preorder/equivalence checking on the class of
visibly pushdown automata and its natural subclasses visibly BPA (Basic Process
Algebra) and visibly one-counter automata. We describe generic methods for
proving complexity upper and lower bounds for a number of studied preorders and
equivalences like simulation, completed simulation, ready simulation, 2-nested
simulation preorders/equivalences and bisimulation equivalence. Our main
results are that all the mentioned equivalences and preorders are
EXPTIME-complete on visibly pushdown automata, PSPACE-complete on visibly
one-counter automata and P-complete on visibly BPA. Our PSPACE lower bound for
visibly one-counter automata improves also the previously known DP-hardness
results for ordinary one-counter automata and one-counter nets. Finally, we
study regularity checking problems for visibly pushdown automata and show that
they can be decided in polynomial time.Comment: Final version of paper, accepted by LMC
Towards a Uniform Theory of Effectful State Machines
Using recent developments in coalgebraic and monad-based semantics, we
present a uniform study of various notions of machines, e.g. finite state
machines, multi-stack machines, Turing machines, valence automata, and weighted
automata. They are instances of Jacobs' notion of a T-automaton, where T is a
monad. We show that the generic language semantics for T-automata correctly
instantiates the usual language semantics for a number of known classes of
machines/languages, including regular, context-free, recursively-enumerable and
various subclasses of context free languages (e.g. deterministic and real-time
ones). Moreover, our approach provides new generic techniques for studying the
expressivity power of various machine-based models.Comment: final version accepted by TOC
A Complete Axiomatization of Quantified Differential Dynamic Logic for Distributed Hybrid Systems
We address a fundamental mismatch between the combinations of dynamics that
occur in cyber-physical systems and the limited kinds of dynamics supported in
analysis. Modern applications combine communication, computation, and control.
They may even form dynamic distributed networks, where neither structure nor
dimension stay the same while the system follows hybrid dynamics, i.e., mixed
discrete and continuous dynamics. We provide the logical foundations for
closing this analytic gap. We develop a formal model for distributed hybrid
systems. It combines quantified differential equations with quantified
assignments and dynamic dimensionality-changes. We introduce a dynamic logic
for verifying distributed hybrid systems and present a proof calculus for this
logic. This is the first formal verification approach for distributed hybrid
systems. We prove that our calculus is a sound and complete axiomatization of
the behavior of distributed hybrid systems relative to quantified differential
equations. In our calculus we have proven collision freedom in distributed car
control even when an unbounded number of new cars may appear dynamically on the
road
Proving the power of postselection
It is a widely believed, though unproven, conjecture that the capability of
postselection increases the language recognition power of both probabilistic
and quantum polynomial-time computers. It is also unknown whether
polynomial-time quantum machines with postselection are more powerful than
their probabilistic counterparts with the same resource restrictions. We
approach these problems by imposing additional constraints on the resources to
be used by the computer, and are able to prove for the first time that
postselection does augment the computational power of both classical and
quantum computers, and that quantum does outperform probabilistic in this
context, under simultaneous time and space bounds in a certain range. We also
look at postselected versions of space-bounded classes, as well as those
corresponding to error-free and one-sided error recognition, and provide
classical characterizations. It is shown that would equal
if the randomized machines had the postselection capability.Comment: 26 pages. This is a heavily improved version of arXiv:1102.066
Conformance Testing with Labelled Transition Systems: Implementation Relations and Test Generation
This paper studies testing based on labelled transition systems, presenting two test generation algorithms with their corresponding implementation relations. The first algorithm assumes that implementations communicate with their environment via symmetric, synchronous interactions. It is based on the theory of testing equivalence and preorder, as is most of the testing theory for labelled transition systems, and it is found in the literature in some slightly different variations. The second algorithm is based on the assumption that implementations communicate with their environment via inputs and outputs. Such implementations are formalized by restricting the class of labelled transition systems to those systems that can always accept input actions. For these implementations a testing theory is developed, analogous to the theory of testing equivalence and preorder. It consists of implementation relations formalizing the notion of conformance of these implementations with respect to labelled transition system specifications, test cases and test suites, test execution, the notion of passing a test suite, and the test generation algorithm, which is proved to produce sound test suites for one of the implementation relations
Communication in concurrent dynamic logic
AbstractCommunication mechanisms are introduced into the program schemes of Concurrent Dynamic Logic, on both the propositional and the first-order levels. The effects of these mechanisms (particularly, channels, shared variables, and âmessage collectorsâ) on issues of expressiveness and decidability are investigated. In general, we find that both respects are dominated by the extent to which the capabilities of synchronization and (unbounded counting are enabled in the communication scheme
- âŠ