250,726 research outputs found
Representing First-Order Causal Theories by Logic Programs
Nonmonotonic causal logic, introduced by Norman McCain and Hudson Turner,
became a basis for the semantics of several expressive action languages.
McCain's embedding of definite propositional causal theories into logic
programming paved the way to the use of answer set solvers for answering
queries about actions described in such languages. In this paper we extend this
embedding to nondefinite theories and to first-order causal logic.Comment: 29 pages. To appear in Theory and Practice of Logic Programming
(TPLP); Theory and Practice of Logic Programming, May, 201
SMT Solving for Functional Programming over Infinite Structures
We develop a simple functional programming language aimed at manipulating
infinite, but first-order definable structures, such as the countably infinite
clique graph or the set of all intervals with rational endpoints. Internally,
such sets are represented by logical formulas that define them, and an external
satisfiability modulo theories (SMT) solver is regularly run by the interpreter
to check their basic properties.
The language is implemented as a Haskell module.Comment: In Proceedings MSFP 2016, arXiv:1604.0038
Generating Non-Linear Interpolants by Semidefinite Programming
Interpolation-based techniques have been widely and successfully applied in
the verification of hardware and software, e.g., in bounded-model check- ing,
CEGAR, SMT, etc., whose hardest part is how to synthesize interpolants. Various
work for discovering interpolants for propositional logic, quantifier-free
fragments of first-order theories and their combinations have been proposed.
However, little work focuses on discovering polynomial interpolants in the
literature. In this paper, we provide an approach for constructing non-linear
interpolants based on semidefinite programming, and show how to apply such
results to the verification of programs by examples.Comment: 22 pages, 4 figure
Functional Choreographic Programming
Choreographic programming is an emerging programming paradigm for concurrent
and distributed systems, whereby developers write the communications that
should be enacted and then a distributed implementation is automatically
obtained by means of a compiler. Theories of choreographic programming
typically come with strong theoretical guarantees about the compilation
process, most notably: the generated implementations operationally correspond
to their source choreographies and are deadlock-free.
Currently, the most advanced incarnation of the paradigm is Choral, an
object-oriented choreographic programming language that targets Java. Choral
deviated significantly from known theories of choreographies, and introduced
the possibility of expressing higher-order choreographies (choreographies
parameterised over choreographies) that are fully distributed. As a
consequence, it is unclear if the usual guarantees of choreographies can still
hold in the more general setting of higher-order ones.
We introduce Chor{\lambda}, the first functional choreographic programming
language: it introduces a new formulation of the standard communication
primitive found in choreographies as a function, and it is based upon the
{\lambda}-calculus. Chor{\lambda} is the first theory that explains the core
ideas of higher-order choreographic programming (as in Choral). Bridging the
gap between practice and theory requires developing a new evaluation strategy
and typing discipline for {\lambda} terms that accounts for the distributed
nature of computation in choreographies. We illustrate the expressivity of
Chor{\lambda} with a series of examples, which include reconstructions of the
key examples from the original presentation of Choral. Our theory supports the
expected properties of choreographic programming and bridges the gap between
the communities of functional and choreographic programming
SkILL - a Stochastic Inductive Logic Learner
Probabilistic Inductive Logic Programming (PILP) is a rel- atively unexplored
area of Statistical Relational Learning which extends classic Inductive Logic
Programming (ILP). This work introduces SkILL, a Stochastic Inductive Logic
Learner, which takes probabilistic annotated data and produces First Order
Logic theories. Data in several domains such as medicine and bioinformatics
have an inherent degree of uncer- tainty, that can be used to produce models
closer to reality. SkILL can not only use this type of probabilistic data to
extract non-trivial knowl- edge from databases, but it also addresses
efficiency issues by introducing a novel, efficient and effective search
strategy to guide the search in PILP environments. The capabilities of SkILL
are demonstrated in three dif- ferent datasets: (i) a synthetic toy example
used to validate the system, (ii) a probabilistic adaptation of a well-known
biological metabolism ap- plication, and (iii) a real world medical dataset in
the breast cancer domain. Results show that SkILL can perform as well as a
deterministic ILP learner, while also being able to incorporate probabilistic
knowledge that would otherwise not be considered
- …