Modelling Adaptive Controllers withEvolving Logic Programs

Pierangelo Dell’Acqua

Anna Lombardi

Dept. of Science and Technology - ITN

Linköping University, Sweden

Luís Moniz Pereira

Centro de Inteligência Artificial - CENTRIA

Universidade Nova de Lisboa, Portugal

ICINCO’06 - Setúbal, PortugalSeptember, 2005August, 2006

Adaptive controllers

An adaptive controller is a controller that is able to change its behaviour in response to changes in the dynamics of the environment.

• Several approaches have been proposed for adaptive control:

e.g., gain scheduling, model-reference adaptive control, self-tuning

regulators, and logic-based switching.

• Classical approaches to deterministic adaptive control have limitations when

unknown parameters enter the process model.

Fuzzy logic controllers have been proposed to control systems with

a high degree of uncertainty.

Evolving Logic Programs (Evolp)

Evolp is a simple, powerful, language to reason about knowledge base evolution.

• It enjoys a well-defined declarative and procedural semantics.

• It provides a firm formal basis in which to express, implement, and reason about dynamic knowledge bases.

Aim of the work

We propose the use of Evolp to model adaptive, dynamic, controllers

operating in complex and uncertain environments.

The use of well-defined, evolving logic-based controllers allows us:

• to model dynamic, complex environments, and

• to formally validate system’s requirements.

Evolp programs

Evolp rules are generalized logic programming rules (possibly with not’s in their heads) plus the special predicate assert, in bodies as well as heads.

The argument of assert is an Evolp rule, e.g.:

assert( a ← not b) ← d, not e

not h ← not assert( assert(a ← b)← not b), c

Evolp programs are sets of Evolp rules.

Evolp

The predicate assert allows one to incorporate new information, and therefore make the program evolve.

In the following, let P0 be an initial Evolp program,

and SM = stable model.

P0 gives rise to a sequence of Evolp programs P0 , P1 , P2 ,… as follows:

if assert(Rule) SM(P0) then RuleP1

if assert(Rule) SM(P0 P1) then RuleP2

…

if assert(Rule) SM(P0 … Pn) then RulePn+1

Note the not’s in heads allow newer rules to supervene older rules, e.g.:

assert( not a ← c ) ← f, g

Meaning of Evolp programs

The meaning of P0 is determined by sequences of sets I of literals:

• Each sequence < I0 ,…,In > represents a possible evolution

• The first set in a sequence is a stable model of the initial program:

I0 = SM(P0)

• The nth set in a sequence represents what holds after n steps in that evolution:

I0 = SM(P0)

I1 = SM(P0 P1)

…

In = SM(P0 … Pn)

Events

Program evolution may me influenced from the outside.

• Observations of facts and rules.

Influence from outside is represented in Evolp via the notion of events.

• Events do not persist by inertia.

Semantic account:

Let E0, E1, …, En be the sets of events received at steps 0, 1, …, n.

The meaning of P0 wrt. E0, E1, …, En is a sequence < I0 ,…,In > such that:

I0 = SM(P0 E0)

I1 = SM(P0 ( P1 E1) )

…

In = SM(P0 … ( Pn En ) )

Modelling adaptive controllers

P0 = controller’s specification

Cycle with:

E0, P0 I0 = SM(P0 E0)

do(Action) I0

assert(Rule) I0 P1

E1, P1 I1 = SM(P0 ( P1 E1) )

do(Action) I1

assert(Rule) I1 P2

. . .

E Controller

assert(.)

do(.)

EVOLP

Process

Modelling supervisory control

E Supervisor

assert(.)

EVOLP

Controller

Process

U

add(.)remove(.)

P0 = supervisor’s specification

0 = controller’s specification

Supervisor

P0, E0, U0 I0 = SM(P0 E0 U0)

add() I0

remove() I0

assert(Rule) I0 P1

Controller

E0, add(), remove() 0 ( E0) = U1

1 = 0 + - . . .

Conclusions

We have addressed the problem of modelling adaptive controllers via Evolp:

• Evolp allows one to express them in a concise, natural, and elegant way.

• Furthermore, employing a well-defined, logic-based approach makes it possible to validate properties of controllers.

Various forms of logic reasoning can be incorporated to enhance performance:

• Abductive reasoning: e.g., to diagnose erroneous controller behaviours

• Preference reasoning: to prefer among plausible alternatives in case of uncertainty.

• Prospective reasoning: to simulate possible futures with the aim to avoid undesirable ones (model predictive control with look-ahead).