24,181 research outputs found
Building and Refining Abstract Planning Cases by Change of Representation Language
ion is one of the most promising approaches to improve the performance of
problem solvers. In several domains abstraction by dropping sentences of a
domain description -- as used in most hierarchical planners -- has proven
useful. In this paper we present examples which illustrate significant
drawbacks of abstraction by dropping sentences. To overcome these drawbacks, we
propose a more general view of abstraction involving the change of
representation language. We have developed a new abstraction methodology and a
related sound and complete learning algorithm that allows the complete change
of representation language of planning cases from concrete to abstract.
However, to achieve a powerful change of the representation language, the
abstract language itself as well as rules which describe admissible ways of
abstracting states must be provided in the domain model. This new abstraction
approach is the core of Paris (Plan Abstraction and Refinement in an Integrated
System), a system in which abstract planning cases are automatically learned
from given concrete cases. An empirical study in the domain of process planning
in mechanical engineering shows significant advantages of the proposed
reasoning from abstract cases over classical hierarchical planning.Comment: See http://www.jair.org/ for an online appendix and other files
accompanying this articl
Data Abstraction Mechanisms in Sina/st
This paper describes a new data abstraction mechanism in an object-oriented model of computing. The data abstraction mechanism described here has been devised in the context of the design of Sina/st language. In Sina/st no language constructs have been adopted for specifying inheritance or delegation, but rather, we introduce simpler mechanisms that can support a wide range of code sharing strategies without selecting one among them as a language feature. Sina/st also provides a stronger data encapsulation than most of the existing object-oriented languages. This language has been implemented on the SUN 3 workstation using Smalltalk
On Verifying Complex Properties using Symbolic Shape Analysis
One of the main challenges in the verification of software systems is the
analysis of unbounded data structures with dynamic memory allocation, such as
linked data structures and arrays. We describe Bohne, a new analysis for
verifying data structures. Bohne verifies data structure operations and shows
that 1) the operations preserve data structure invariants and 2) the operations
satisfy their specifications expressed in terms of changes to the set of
objects stored in the data structure. During the analysis, Bohne infers loop
invariants in the form of disjunctions of universally quantified Boolean
combinations of formulas. To synthesize loop invariants of this form, Bohne
uses a combination of decision procedures for Monadic Second-Order Logic over
trees, SMT-LIB decision procedures (currently CVC Lite), and an automated
reasoner within the Isabelle interactive theorem prover. This architecture
shows that synthesized loop invariants can serve as a useful communication
mechanism between different decision procedures. Using Bohne, we have verified
operations on data structures such as linked lists with iterators and back
pointers, trees with and without parent pointers, two-level skip lists, array
data structures, and sorted lists. We have deployed Bohne in the Hob and Jahob
data structure analysis systems, enabling us to combine Bohne with analyses of
data structure clients and apply it in the context of larger programs. This
report describes the Bohne algorithm as well as techniques that Bohne uses to
reduce the ammount of annotations and the running time of the analysis
Embodied Active Learning of Relational State Abstractions for Bilevel Planning
State abstraction is an effective technique for planning in robotics
environments with continuous states and actions, long task horizons, and sparse
feedback. In object-oriented environments, predicates are a particularly useful
form of state abstraction because of their compatibility with symbolic planners
and their capacity for relational generalization. However, to plan with
predicates, the agent must be able to interpret them in continuous environment
states (i.e., ground the symbols). Manually programming predicate
interpretations can be difficult, so we would instead like to learn them from
data. We propose an embodied active learning paradigm where the agent learns
predicate interpretations through online interaction with an expert. For
example, after taking actions in a block stacking environment, the agent may
ask the expert: "Is On(block1, block2) true?" From this experience, the agent
learns to plan: it learns neural predicate interpretations, symbolic planning
operators, and neural samplers that can be used for bilevel planning. During
exploration, the agent plans to learn: it uses its current models to select
actions towards generating informative expert queries. We learn predicate
interpretations as ensembles of neural networks and use their entropy to
measure the informativeness of potential queries. We evaluate this approach in
three robotic environments and find that it consistently outperforms six
baselines while exhibiting sample efficiency in two key metrics: number of
environment interactions, and number of queries to the expert. Code:
https://tinyurl.com/active-predicatesComment: Conference on Lifelong Learning Agents (CoLLAs) 202
Syntactic Abstraction of B Models to Generate Tests
In a model-based testing approach as well as for the verification of
properties, B models provide an interesting solution. However, for industrial
applications, the size of their state space often makes them hard to handle. To
reduce the amount of states, an abstraction function can be used, often
combining state variable elimination and domain abstractions of the remaining
variables. This paper complements previous results, based on domain abstraction
for test generation, by adding a preliminary syntactic abstraction phase, based
on variable elimination. We define a syntactic transformation that suppresses
some variables from a B event model, in addition to a method that chooses
relevant variables according to a test purpose. We propose two methods to
compute an abstraction A of an initial model M. The first one computes A as a
simulation of M, and the second one computes A as a bisimulation of M. The
abstraction process produces a finite state system. We apply this abstraction
computation to a Model Based Testing process.Comment: Tests and Proofs 2010, Malaga : Spain (2010
From Logical Calculus to Logical Formality—What Kant Did with Euler’s Circles
John Venn has the “uneasy suspicion” that the stagnation in mathematical logic between J. H. Lambert and George Boole was due to Kant’s “disastrous effect on logical method,” namely the “strictest preservation [of logic] from mathematical encroachment.” Kant’s actual position is more nuanced, however. In this chapter, I tease out the nuances by examining his use of Leonhard Euler’s circles and comparing it with Euler’s own use. I do so in light of the developments in logical calculus from G. W. Leibniz to Lambert and Gottfried Ploucquet. While Kant is evidently open to using mathematical tools in logic, his main concern is to clarify what mathematical tools can be used to achieve. For without such clarification, all efforts at introducing mathematical tools into logic would be blind if not complete waste of time. In the end, Kant would stress, the means provided by formal logic at best help us to express and order what we already know in some sense. No matter how much mathematical notations may enhance the precision of this function of formal logic, it does not change the fact that no truths can, strictly speaking, be revealed or established by means of those notations
Predicate Abstraction with Indexed Predicates
Predicate abstraction provides a powerful tool for verifying properties of
infinite-state systems using a combination of a decision procedure for a subset
of first-order logic and symbolic methods originally developed for finite-state
model checking. We consider models containing first-order state variables,
where the system state includes mutable functions and predicates. Such a model
can describe systems containing arbitrarily large memories, buffers, and arrays
of identical processes. We describe a form of predicate abstraction that
constructs a formula over a set of universally quantified variables to describe
invariant properties of the first-order state variables. We provide a formal
justification of the soundness of our approach and describe how it has been
used to verify several hardware and software designs, including a
directory-based cache coherence protocol.Comment: 27 pages, 4 figures, 1 table, short version appeared in International
Conference on Verification, Model Checking and Abstract Interpretation
(VMCAI'04), LNCS 2937, pages = 267--28
- …