42,476 research outputs found
On cascade products of answer set programs
Describing complex objects by elementary ones is a common strategy in
mathematics and science in general. In their seminal 1965 paper, Kenneth Krohn
and John Rhodes showed that every finite deterministic automaton can be
represented (or "emulated") by a cascade product of very simple automata. This
led to an elegant algebraic theory of automata based on finite semigroups
(Krohn-Rhodes Theory). Surprisingly, by relating logic programs and automata,
we can show in this paper that the Krohn-Rhodes Theory is applicable in Answer
Set Programming (ASP). More precisely, we recast the concept of a cascade
product to ASP, and prove that every program can be represented by a product of
very simple programs, the reset and standard programs. Roughly, this implies
that the reset and standard programs are the basic building blocks of ASP with
respect to the cascade product. In a broader sense, this paper is a first step
towards an algebraic theory of products and networks of nonmonotonic reasoning
systems based on Krohn-Rhodes Theory, aiming at important open issues in ASP
and AI in general.Comment: Appears in Theory and Practice of Logic Programmin
Finite Computational Structures and Implementations
What is computable with limited resources? How can we verify the correctness
of computations? How to measure computational power with precision? Despite the
immense scientific and engineering progress in computing, we still have only
partial answers to these questions. In order to make these problems more
precise, we describe an abstract algebraic definition of classical computation,
generalizing traditional models to semigroups. The mathematical abstraction
also allows the investigation of different computing paradigms (e.g. cellular
automata, reversible computing) in the same framework. Here we summarize the
main questions and recent results of the research of finite computation.Comment: 12 pages, 3 figures, will be presented at CANDAR'16 and final version
published by IEEE Computer Societ
Formal Verification of Security Protocol Implementations: A Survey
Automated formal verification of security protocols has been mostly focused on analyzing high-level abstract models which, however, are significantly different from real protocol implementations written in programming languages. Recently, some researchers have started investigating techniques that bring automated formal proofs closer to real implementations. This paper surveys these attempts, focusing on approaches that target the application code that implements protocol logic, rather than the libraries that implement cryptography. According to these approaches, libraries are assumed to correctly implement some models. The aim is to derive formal proofs that, under this assumption, give assurance about the application code that implements the protocol logic. The two main approaches of model extraction and code generation are presented, along with the main techniques adopted for each approac
Probabilistic Programming Concepts
A multitude of different probabilistic programming languages exists today,
all extending a traditional programming language with primitives to support
modeling of complex, structured probability distributions. Each of these
languages employs its own probabilistic primitives, and comes with a particular
syntax, semantics and inference procedure. This makes it hard to understand the
underlying programming concepts and appreciate the differences between the
different languages. To obtain a better understanding of probabilistic
programming, we identify a number of core programming concepts underlying the
primitives used by various probabilistic languages, discuss the execution
mechanisms that they require and use these to position state-of-the-art
probabilistic languages and their implementation. While doing so, we focus on
probabilistic extensions of logic programming languages such as Prolog, which
have been developed since more than 20 years
Validity-Guided Synthesis of Reactive Systems from Assume-Guarantee Contracts
Automated synthesis of reactive systems from specifications has been a topic
of research for decades. Recently, a variety of approaches have been proposed
to extend synthesis of reactive systems from proposi- tional specifications
towards specifications over rich theories. We propose a novel, completely
automated approach to program synthesis which reduces the problem to deciding
the validity of a set of forall-exists formulas. In spirit of IC3 / PDR, our
problem space is recursively refined by blocking out regions of unsafe states,
aiming to discover a fixpoint that describes safe reactions. If such a fixpoint
is found, we construct a witness that is directly translated into an
implementation. We implemented the algorithm on top of the JKind model checker,
and exercised it against contracts written using the Lustre specification
language. Experimental results show how the new algorithm outperforms JKinds
already existing synthesis procedure based on k-induction and addresses
soundness issues in the k-inductive approach with respect to unrealizable
results.Comment: 18 pages, 5 figures, 2 table
- …