190,050 research outputs found
Programming and Reasoning with Partial Observability
Computer programs are increasingly being deployed in partially-observable
environments. A partially observable environment is an environment whose state
is not completely visible to the program, but from which the program receives
partial observations. Developers typically deal with partial observability by
writing a state estimator that, given observations, attempts to deduce the
hidden state of the environment. In safety-critical domains, to formally verify
safety properties developers may write an environment model. The model captures
the relationship between observations and hidden states and is used to prove
the software correct.
In this paper, we present a new methodology for writing and verifying
programs in partially observable environments. We present belief programming, a
programming methodology where developers write an environment model that the
program runtime automatically uses to perform state estimation. A belief
program dynamically updates and queries a belief state that captures the
possible states the environment could be in. To enable verification, we present
Epistemic Hoare Logic that reasons about the possible belief states of a belief
program the same way that classical Hoare logic reasons about the possible
states of a program. We develop these concepts by defining a semantics and a
program logic for a simple core language called BLIMP. In a case study, we show
how belief programming could be used to write and verify a controller for the
Mars Polar Lander in BLIMP. We present an implementation of BLIMP called CBLIMP
and evaluate it to determine the feasibility of belief programming
Threads and Or-Parallelism Unified
One of the main advantages of Logic Programming (LP) is that it provides an
excellent framework for the parallel execution of programs. In this work we
investigate novel techniques to efficiently exploit parallelism from real-world
applications in low cost multi-core architectures. To achieve these goals, we
revive and redesign the YapOr system to exploit or-parallelism based on a
multi-threaded implementation. Our new approach takes full advantage of the
state-of-the-art fast and optimized YAP Prolog engine and shares the underlying
execution environment, scheduler and most of the data structures used to
support YapOr's model. Initial experiments with our new approach consistently
achieve almost linear speedups for most of the applications, proving itself as
a good alternative for exploiting implicit parallelism in the currently
available low cost multi-core architectures.Comment: 17 pages, 21 figures, International Conference on Logic Programming
(ICLP 2010
Recommended from our members
Logic Programming Using Parallel Associative Operations
In order to provide performance improvements in the execution of large logic programs, it is highly desirable to investigate the relationships between logic, data-base systems and knowledge-based systems in the context of massively parallel architectures. This paper presents a model for the interpretation of logic programs in this type of environment and overviews the algorithms under development. An interpreter that implements the model has been demonstrated in simulations on a number of small programs. Implementation requires that only a small set of hardware primitives be available, these have been successfully implemented on a working prototype machine, DADO. Current research aims to develop the model into a practical and efficient logic programming system for use on the machine
A Logic Programming Approach to Reaction Systems
Reaction systems (RS) are a computational framework inspired by the functioning of living cells, suitable to model the main mechanisms of biochemical reactions. RS have shown to be useful also for computer science applications, e.g. to model circuits or transition systems. Since their introduction about 10 years ago, RS matured into a fruitful and dynamically evolving research area. They have become a popular novel model of interactive computation. RS can be seen as a rewriting system interacting with the environment represented by the context. RS pose some problems of implementation, as it is a relatively recent computation model, and several extensions of the basic model have been designed. In this paper we present some preliminary work on how to implement this formalism in a logic programming language (Prolog). To the best of our knowledge this is the first approach to RS in logic programming. Our prototypical implementation does not aim to be highly performing, but has the advantage of being high level and easily modifiable. So it is suitable as a rapid prototyping tool for implementing several extensions of reaction systems in the literature as well as new ones. We also make a preliminary implementation of a kind of memoization mechanism for stopping potentially infinite and repetitive computations. Then we show how to implement in our interpreter an extension of RS for modeling a nondeterministic context and interaction between components of a (biological) system. We then present an extension of the interpreter for implementing the recently introduced networks of RS
Implementation of Model Predictive Control in Programmable Logic Controllers
In this article, we present an implementation of a low-memory footprint model predictive control (MPC)-based controller in programmable logic controllers (PLCs). Automatic code generation of standardized IEC 61131-3 PLC programming languages is used to solve the MPC's optimization problem online. The implementation is designed for its application in a realistic industrial environment, including timing considerations and accounting for the possibility of the PLC not being exclusively dedicated to the MPC controller. We describe the controller architecture and algorithm, show the results of its memory footprint with regard to the problem dimensions, and present the results of its implementation to control a hardware-in-the-loop multivariable chemical plant.MINERCOFEDER DPI2016-76493-C3-1-
A CHR-based Implementation of Known Arc-Consistency
In classical CLP(FD) systems, domains of variables are completely known at
the beginning of the constraint propagation process. However, in systems
interacting with an external environment, acquiring the whole domains of
variables before the beginning of constraint propagation may cause waste of
computation time, or even obsolescence of the acquired data at the time of use.
For such cases, the Interactive Constraint Satisfaction Problem (ICSP) model
has been proposed as an extension of the CSP model, to make it possible to
start constraint propagation even when domains are not fully known, performing
acquisition of domain elements only when necessary, and without the need for
restarting the propagation after every acquisition.
In this paper, we show how a solver for the two sorted CLP language, defined
in previous work, to express ICSPs, has been implemented in the Constraint
Handling Rules (CHR) language, a declarative language particularly suitable for
high level implementation of constraint solvers.Comment: 22 pages, 2 figures, 1 table To appear in Theory and Practice of
Logic Programming (TPLP
An Interleaving Semantics of the Timed Concurrent Language for Argumentation to Model Debates and Dialogue Games
Time is a crucial factor in modelling dynamic behaviours of intelligent
agents: activities have a determined temporal duration in a real-world
environment, and previous actions influence agents' behaviour. In this paper,
we propose a language for modelling concurrent interaction between agents that
also allows the specification of temporal intervals in which particular actions
occur. Such a language exploits a timed version of Abstract Argumentation
Frameworks to realise a shared memory used by the agents to communicate and
reason on the acceptability of their beliefs with respect to a given time
interval. An interleaving model on a single processor is used for basic
computation steps, with maximum parallelism for time elapsing. Following this
approach, only one of the enabled agents is executed at each moment. To
demonstrate the capabilities of language, we also show how it can be used to
model interactions such as debates and dialogue games taking place between
intelligent agents. Lastly, we present an implementation of the language that
can be accessed via a web interface. Under consideration in Theory and Practice
of Logic Programming (TPLP).Comment: Under consideration in Theory and Practice of Logic Programming
(TPLP
- …