971,638 research outputs found
REBA: A Refinement-Based Architecture for Knowledge Representation and Reasoning in Robotics
This paper describes an architecture for robots that combines the
complementary strengths of probabilistic graphical models and declarative
programming to represent and reason with logic-based and probabilistic
descriptions of uncertainty and domain knowledge. An action language is
extended to support non-boolean fluents and non-deterministic causal laws. This
action language is used to describe tightly-coupled transition diagrams at two
levels of granularity, with a fine-resolution transition diagram defined as a
refinement of a coarse-resolution transition diagram of the domain. The
coarse-resolution system description, and a history that includes (prioritized)
defaults, are translated into an Answer Set Prolog (ASP) program. For any given
goal, inference in the ASP program provides a plan of abstract actions. To
implement each such abstract action, the robot automatically zooms to the part
of the fine-resolution transition diagram relevant to this action. A
probabilistic representation of the uncertainty in sensing and actuation is
then included in this zoomed fine-resolution system description, and used to
construct a partially observable Markov decision process (POMDP). The policy
obtained by solving the POMDP is invoked repeatedly to implement the abstract
action as a sequence of concrete actions, with the corresponding observations
being recorded in the coarse-resolution history and used for subsequent
reasoning. The architecture is evaluated in simulation and on a mobile robot
moving objects in an indoor domain, to show that it supports reasoning with
violation of defaults, noisy observations and unreliable actions, in complex
domains.Comment: 72 pages, 14 figure
Compiling Causal Theories to Successor State Axioms and STRIPS-Like Systems
We describe a system for specifying the effects of actions. Unlike those
commonly used in AI planning, our system uses an action description language
that allows one to specify the effects of actions using domain rules, which are
state constraints that can entail new action effects from old ones.
Declaratively, an action domain in our language corresponds to a nonmonotonic
causal theory in the situation calculus. Procedurally, such an action domain is
compiled into a set of logical theories, one for each action in the domain,
from which fully instantiated successor state-like axioms and STRIPS-like
systems are then generated. We expect the system to be a useful tool for
knowledge engineers writing action specifications for classical AI planning
systems, GOLOG systems, and other systems where formal specifications of
actions are needed
Verification of Knowledge-Based Programs over Description Logic Actions
A knowledge-based program defines the behavior of an agent by combining primitive actions, programming constructs and test conditions that make explicit reference to the agent’s knowledge. In this paper we consider a setting where an agent is equipped with a Description Logic (DL) knowledge base providing general domain knowledge and an incomplete description of the initial situation. We introduce a corresponding new DL-based action language that allows for representing both physical and sensing actions, and that we then use to build knowledge-based programs with test conditions expressed in the epistemic DL. After proving undecidability for the general case, we then discuss a restricted fragment where verification becomes decidable. The provided proof is constructive and comes with an upper bound on the procedure’s complexity
- …