1. Modelling Adaptive Controllers with Evolving 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, Portugal September, 2005 August, 2006

2. 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.

3. 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.

4. 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.

5. 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.

6. Evolp The predicate assert allows one to incorporate new information, and therefore make the program evolve. In the following, let P 0 be an initial Evolp program, and SM = stable model. P 0 gives rise to a sequence of Evolp programs P 0, P 1, P 2,… as follows: if assert(Rule)  SM(P 0 ) then Rule  P 1 if assert(Rule)  SM(P 0  P 1 ) then Rule  P 2 … if assert(Rule)  SM(P 0  …  P n ) then Rule  P n+1 Note the not’s in heads allow newer rules to supervene older rules, e.g.: assert( not a ← c ) ← f, g

7. Meaning of Evolp programs The meaning of P 0 is determined by sequences of sets I of literals: Each sequence represents a possible evolution The first set in a sequence is a stable model of the initial program: I 0 = SM(P 0 ) The n th set in a sequence represents what holds after n steps in that evolution: I 0 = SM(P 0 ) I 1 = SM(P 0  P 1 ) … I n = SM(P 0  …  P n )

8. 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 E 0, E 1, …, E n be the sets of events received at steps 0, 1, …, n. The meaning of P 0 wrt. E 0, E 1, …, E n is a sequence such that: I 0 = SM(P 0  E 0 ) I 1 = SM(P 0  ( P 1  E 1 ) ) … I n = SM(P 0  …  ( P n  E n ) )

9. Modelling adaptive controllers P 0 = controller’s specification Cycle with: E 0, P 0  I 0 = SM(P 0  E 0 ) do(Action)  I 0 assert(Rule)  I 0  P 1 E 1, P 1  I 1 = SM(P 0  ( P 1  E 1 ) ) do(Action)  I 1 assert(Rule)  I 1  P 2...

10. Modelling supervisory control E Supervisor assert(.) EVOLP Controller Process U add(.) remove(.) P 0 = supervisor’s specification  0 = controller’s specification Supervisor P 0, E 0, U 0  I 0 = SM(P 0  E 0  U 0 ) add(  )  I 0 remove(  )  I 0 assert(Rule)  I 0  P 1 Controller E 0, add(  ), remove(  )  0 ( E 0 ) = U 1  1 =  0 +  - ...

11. 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).