682 research outputs found
Completeness and Incompleteness of Synchronous Kleene Algebra
Synchronous Kleene algebra (SKA), an extension of Kleene algebra (KA), was
proposed by Prisacariu as a tool for reasoning about programs that may execute
synchronously, i.e., in lock-step. We provide a countermodel witnessing that
the axioms of SKA are incomplete w.r.t. its language semantics, by exploiting a
lack of interaction between the synchronous product operator and the Kleene
star. We then propose an alternative set of axioms for SKA, based on Salomaa's
axiomatisation of regular languages, and show that these provide a sound and
complete characterisation w.r.t. the original language semantics.Comment: Accepted at MPC 201
Symbolic Algorithms for Language Equivalence and Kleene Algebra with Tests
We first propose algorithms for checking language equivalence of finite
automata over a large alphabet. We use symbolic automata, where the transition
function is compactly represented using a (multi-terminal) binary decision
diagrams (BDD). The key idea consists in computing a bisimulation by exploring
reachable pairs symbolically, so as to avoid redundancies. This idea can be
combined with already existing optimisations, and we show in particular a nice
integration with the disjoint sets forest data-structure from Hopcroft and
Karp's standard algorithm. Then we consider Kleene algebra with tests (KAT), an
algebraic theory that can be used for verification in various domains ranging
from compiler optimisation to network programming analysis. This theory is
decidable by reduction to language equivalence of automata on guarded strings,
a particular kind of automata that have exponentially large alphabets. We
propose several methods allowing to construct symbolic automata out of KAT
expressions, based either on Brzozowski's derivatives or standard automata
constructions. All in all, this results in efficient algorithms for deciding
equivalence of KAT expressions
Certification of Compiler Optimizations using Kleene Algebra with Tests
We use Kleene algebra with tests to verify a wide assortment of common compiler optimizations, including dead code elimination, common subexpression elimination, copy propagation, loop hoisting, induction variable elimination, instruction scheduling, algebraic simplification, loop unrolling, elimination of redundant instructions, array bounds check elimination, and introduction of sentinels. In each of these cases, we give a formal equational proof of the correctness of the optimizing transformation
Left-handed completeness
We give a new proof of the completeness of the left-handed star rule of Kleene algebra. The proof is significantly shorter than previous proofs and exposes the rich interaction of algebra and coalgebra in the theory of Kleene algebra
Formalizing Moessner's theorem and generalizations in Nuprl
Moessner's theorem describes a procedure for generating a sequence of n integer sequences that lead unexpectedly to the sequence of nth powers 1^{n}, 2^{n}, 3^{n},...Several generalizations of Moessner's theorem exist. Recently, Kozen and Silva gave an algebraic proof of a general theorem that subsumes Moessner's original theorem and its known generalizations. In this note, we describe the formalization of this theorem that the first author did in Nuprl. On the one hand, the formalization remains remarkably close to the original proof. On the other hand, it leads to new insights in the proof, pointing to small gaps and ambiguities that would never raise any objections in pen and pencil proofs, but which must be resolved in machine formalization
On the generation of equational dynamic logics for weighted imperative programs
Dynamic logic is a powerful framework for reasoning about
imperative programs. This paper extends previous work [9] on the systematic
generation of dynamic logics from the propositional to the equational
case, to capture `full-
edged' imperative programs. The generation
process is parametric on a structure specifying a notion of `weight' assigned
to programs. The paper introduces also a notion of bisimilarity
on models of the generated logics, which is shown to entail modal equivalence
with respect to the latter.POCI-01-0145-FEDER-030947. ERDF—European Regional Development Fund through the Operational Programme for Competitiveness and Internationalisation - COMPETE 2020 Programme and by National Funds through the Portuguese funding agency, FCT - Fundação para a Ciência e a Tecnologia, within project POCI-01-0145-FEDER-030947. The second author is supported in the scope of the framework contract foreseen in the numbers 4, 5 and 6 of the article 23, of the Decree-Law 57/2016, of August 29, changed by Portuguese Law 57/2017, of July 19 and by UID/MAT/04106/2019 at CIDM
CoCaml: Functional Programming with Regular Coinductive Types
Functional languages offer a high level of abstraction, which results in programs that are elegant and easy to understand. Central to the development of functional programming are inductive and coinductive types and associated programming constructs, such as pattern-matching. Whereas inductive types have a long tradition and are well supported in most languages, coinductive types are subject of more recent research and are less mainstream.
We present CoCaml, a functional programming language extending OCaml, which allows us to define recursive functions on regular coinductive datatypes. These functions are defined like usual recursive functions, but parameterized by an equation solver. We present a full implementation of all the constructs and solvers and show how these can be used in a variety of examples, including operations on infinite lists, infinitary Îł-terms, and p-adic numbers
A dynamic logic for every season
This paper introduces a method to build dynamic logics with a graded semantics. The construction is parametrized by a structure to support both the spaces of truth and of the domain of computations. Possible instantiations of the method range from classical assertional) dynamic logic to less common graded logics suitable to deal with programs whose transitional semantics exhibits fuzzy or weighted behaviour.This leads to the systematic derivation of program logics tailored to specific program classes
Language Constructs for Non-Well-Founded Computation
Recursive functions defined on a coalgebraic datatype C may not
converge if there are cycles in the input, that is, if the input object
is not well-founded. Even so, there is often a useful solution; for
example, the free variables of an infinitary λ-term, or the expected
running time of a finite-state probabilistic protocol.
Theoretical models of recursion schemes have been well studied
RankPL: A Qualitative Probabilistic Programming Language
In this paper we introduce RankPL, a modeling language that can be thought of
as a qualitative variant of a probabilistic programming language with a
semantics based on Spohn's ranking theory. Broadly speaking, RankPL can be used
to represent and reason about processes that exhibit uncertainty expressible by
distinguishing "normal" from" surprising" events. RankPL allows (iterated)
revision of rankings over alternative program states and supports various types
of reasoning, including abduction and causal inference. We present the
language, its denotational semantics, and a number of practical examples. We
also discuss an implementation of RankPL that is available for download
- …