105 research outputs found
Verification of Golog Programs over Description Logic Actions
High-level action programming languages such as Golog have successfully been used to model the behavior of autonomous agents. In addition to a logic-based action formalism for describing the environment and the effects of basic actions, they enable the construction of complex actions using typical programming language constructs. To ensure that the execution of such complex actions leads to the desired behavior of the agent, one needs to specify the required properties in a formal way, and then verify that these requirements are met by any execution of the program. Due to the expressiveness of the action formalism underlying Golog (situation calculus), the verification problem for Golog programs is in general undecidable. Action formalisms based on Description Logic (DL) try to achieve decidability of inference problems such as the projection problem by restricting the expressiveness of the underlying base logic. However, until now these formalisms have not been used within Golog programs. In the present paper, we introduce a variant of Golog where basic actions are defined using such a DL-based formalism, and show that the verification problem for such programs is decidable. This improves on our previous work on verifying properties of infinite sequences of DL actions in that it considers (finite and infinite) sequences of DL actions that correspond to (terminating and non-terminating) runs of a Golog program rather than just infinite sequences accepted by a Büchi automaton abstracting the program
Verification of Generalized Inconsistency-Aware Knowledge and Action Bases (Extended Version)
Knowledge and Action Bases (KABs) have been put forward as a semantically
rich representation of a domain, using a DL KB to account for its static
aspects, and actions to evolve its extensional part over time, possibly
introducing new objects. Recently, KABs have been extended to manage
inconsistency, with ad-hoc verification techniques geared towards specific
semantics. This work provides a twofold contribution along this line of
research. On the one hand, we enrich KABs with a high-level, compact action
language inspired by Golog, obtaining so called Golog-KABs (GKABs). On the
other hand, we introduce a parametric execution semantics for GKABs, so as to
elegantly accomodate a plethora of inconsistency-aware semantics based on the
notion of repair. We then provide several reductions for the verification of
sophisticated first-order temporal properties over inconsistency-aware GKABs,
and show that it can be addressed using known techniques, developed for
standard KABs
On the Decidability of Verifying LTL Properties of Golog Programs: Extended Version
Golog is a high-level action programming language for controlling autonomous agents such as mobile robots. It is defined on top of a logic-based action theory expressed in the Situation Calculus. Before a program is deployed onto an actual robot and executed in the physical world, it is desirable, if not crucial, to verify that it meets certain requirements (typically expressed through temporal formulas) and thus indeed exhibits the desired behaviour. However, due to the high (first-order) expressiveness of the language, the corresponding verification problem is in general undecidable. In this paper, we extend earlier results to identify a large, non-trivial fragment of the formalism where verification is decidable. In particular, we consider properties expressed in a first-order variant of the branching-time temporal logic CTL*. Decidability is obtained by (1) resorting to the decidable first-order fragment C² as underlying base logic, (2) using a fragment of Golog with ground actions only, and (3) requiring the action theory to only admit local effects.In this extended version we extend the decidability result for the verification problem to the temporal logic CTL* over C2-axioms
Logic-Based Specification Languages for Intelligent Software Agents
The research field of Agent-Oriented Software Engineering (AOSE) aims to find
abstractions, languages, methodologies and toolkits for modeling, verifying,
validating and prototyping complex applications conceptualized as Multiagent
Systems (MASs). A very lively research sub-field studies how formal methods can
be used for AOSE. This paper presents a detailed survey of six logic-based
executable agent specification languages that have been chosen for their
potential to be integrated in our ARPEGGIO project, an open framework for
specifying and prototyping a MAS. The six languages are ConGoLog, Agent-0, the
IMPACT agent programming language, DyLog, Concurrent METATEM and Ehhf. For each
executable language, the logic foundations are described and an example of use
is shown. A comparison of the six languages and a survey of similar approaches
complete the paper, together with considerations of the advantages of using
logic-based languages in MAS modeling and prototyping.Comment: 67 pages, 1 table, 1 figure. Accepted for publication by the Journal
"Theory and Practice of Logic Programming", volume 4, Maurice Bruynooghe
Editor-in-Chie
On the Complexity of Verifying Timed Golog Programs over Description Logic Actions: Extended Version
Golog programs allow to model complex behaviour of agents by combining primitive actions defined in a Situation Calculus theory using imperative and non-deterministic programming language constructs. In general, verifying temporal properties of Golog programs is undecidable. One way to establish decidability is to restrict the logic used by the program to a Description Logic (DL), for which recently some complexity upper bounds for verification problem have been established. However, so far it was open whether these results are tight, and lightweight DLs such as EL have not been studied at all. Furthermore, these results only apply to a setting where actions do not consume time, and the properties to be verified only refer to the timeline in a qualitative way. In a lot of applications, this is an unrealistic assumption. In this work, we study the verification problem for timed Golog programs, in which actions can be assigned differing durations, and temporal properties are specified in a metric branching time logic. This allows to annotate temporal properties with time intervals over which they are evaluated, to specify for example that some property should hold for at least n time units, or should become specified within some specified time window. We establish tight complexity bounds of the verification problem for both expressive and lightweight DLs. Our lower bounds already apply to a very limited fragment of the verification problem, and close open complexity bounds for the non-metrical cases studied before
Probabilistic Planning by Probabilistic Programming
Automated planning is a major topic of research in artificial intelligence,
and enjoys a long and distinguished history. The classical paradigm assumes a
distinguished initial state, comprised of a set of facts, and is defined over a
set of actions which change that state in one way or another. Planning in many
real-world settings, however, is much more involved: an agent's knowledge is
almost never simply a set of facts that are true, and actions that the agent
intends to execute never operate the way they are supposed to. Thus,
probabilistic planning attempts to incorporate stochastic models directly into
the planning process. In this article, we briefly report on probabilistic
planning through the lens of probabilistic programming: a programming paradigm
that aims to ease the specification of structured probability distributions. In
particular, we provide an overview of the features of two systems, HYPE and
ALLEGRO, which emphasise different strengths of probabilistic programming that
are particularly useful for complex modelling issues raised in probabilistic
planning. Among other things, with these systems, one can instantiate planning
problems with growing and shrinking state spaces, discrete and continuous
probability distributions, and non-unique prior distributions in a first-order
setting.Comment: Article at AAAI-18 Workshop on Planning and Inferenc
Bounded Situation Calculus Action Theories
In this paper, we investigate bounded action theories in the situation
calculus. A bounded action theory is one which entails that, in every
situation, the number of object tuples in the extension of fluents is bounded
by a given constant, although such extensions are in general different across
the infinitely many situations. We argue that such theories are common in
applications, either because facts do not persist indefinitely or because the
agent eventually forgets some facts, as new ones are learnt. We discuss various
classes of bounded action theories. Then we show that verification of a
powerful first-order variant of the mu-calculus is decidable for such theories.
Notably, this variant supports a controlled form of quantification across
situations. We also show that through verification, we can actually check
whether an arbitrary action theory maintains boundedness.Comment: 51 page
Logic, Probability and Action: A Situation Calculus Perspective
The unification of logic and probability is a long-standing concern in AI,
and more generally, in the philosophy of science. In essence, logic provides an
easy way to specify properties that must hold in every possible world, and
probability allows us to further quantify the weight and ratio of the worlds
that must satisfy a property. To that end, numerous developments have been
undertaken, culminating in proposals such as probabilistic relational models.
While this progress has been notable, a general-purpose first-order knowledge
representation language to reason about probabilities and dynamics, including
in continuous settings, is still to emerge. In this paper, we survey recent
results pertaining to the integration of logic, probability and actions in the
situation calculus, which is arguably one of the oldest and most well-known
formalisms. We then explore reduction theorems and programming interfaces for
the language. These results are motivated in the context of cognitive robotics
(as envisioned by Reiter and his colleagues) for the sake of concreteness.
Overall, the advantage of proving results for such a general language is that
it becomes possible to adapt them to any special-purpose fragment, including
but not limited to popular probabilistic relational models
- …