José Júlio Alferes Luís Moniz Pereira Centro de Inteligência Artificial - CENTRIA Universidade Nova de Lisboa, Portugal Pierangelo Dell’Acqua Dept. of Science and Technology - ITN Linköping University, Sweden

Contribution  The paper presents a compilation of programs formalizing update plus preference reasoning into standard generalized logic programs, and shows the correctness of the transformation.  The compilation is based on: - a transformation into normal programs of sequences of general logic programs updates. - a transformation of logic programs with preferences.

Update reasoning  Updates model dynamically evolving worlds.  Updates differ from revisions which are about an incomplete static world model.  Knowledge, whether complete or incomplete, can be updated to reflect world change.  New knowledge may contradict and override older one. New models may also be created by removing such contradictions.

Preference reasoning  Preferences are employed with incomplete knowledge when several models are possible  Preferences act by choosing some of the possible models  They do this via a partial order among rules. Rules will only fire if they are not defeated by more preferred rules

Preference and updates combined  Despite their differences preferences and updates display similarities.  Both can be seen as wiping out rules:  in preferences the less preferred rules, so as to remove models which are undesired.  in updates the older rules, inclusively for obtaining models in otherwise inconsistent theories.  This view helps put them together into a single uniform framework.  In this framework, preferences can be updated.

LP Framework Atomic formulae: A objective atom not A default atom Formulae: every L i is an objective or default atom generalized rule L 0  L 1  L n

LP Framework Let N={ n 1,…, n k } be a set of constants containing a unique name for each generalized rule. Let P be a set of generalized rules and R a set of priority rules. Then (P,R) is a prioritized logic program. Z is a literal n r <n u or not n r <n u priority rule Z  L 1  L n n r <n u means that rule r is preferred to rule u

Dynamic Prioritized Programs Let S={1,…,s,…} be a set of natural numbers. We call the elements i  S states. Let (Pi,Ri) be a prioritized logic program for every i  S, then  {(Pi,Ri) : i  S} is a dynamic prioritized program. Intuitively, the meaning of such a sequence results from updating (P 1, R 1 ) with the rules from (P 2, R 2 ), and then updating the result with … the rules from (P n, R n )

Example Suppose a scenario where Stefano watches programs on football, tennis, or the news. (1) In the initial situation, being a typical italian, Stefano prefers both football and tennis to the news and, in case of international competitions, he prefers tennis over football. In this situation, Stefano has two alternative TV programmes equally preferable: football and tennis. f  not t, not n (r 1 ) t  not f, not n (r 2 ) n  not f, not t (r 3 ) n 1 <n 3 n 2 <n 3 n 2 <n 1  us x<y  x<z, z<y P1 R1

Example (2) Next, suppose that a US-open tennis competition takes place: Now, Stefano's favourite programme is tennis. us  (r 4 ) P2R2 (3) Finally, suppose that Stefano's preferences change and he becomes interested in international news. Then, in case of breaking news he will prefer news over both football and tennis. bn  (r 5 ) P3 not (n 1 <n 3 )  bn not (n 2 <n 3 )  bn n 3 <n 1  bn n 3 <n 2  bn R3

Preferred Stable Models Let P =  {(Pi,Ri) : i  S} be a dynamic prioritized program, Q =  { Pi  Ri : i  S }, PR =  i (Pi  Ri), and M an interpretation of P. Def. Default and Rejected rules Default(PR,M) = {not A :  (A  Body) in PR and M |  body } Reject(s,M,Q) = { r  Pi  Ri :  r’  Pj  Rj, head(r)=not head(r’), i<j  s and M |= body(r’) }

Preferred Stable Models Def. Unsupported and Unprefered rules Unsup(PR,M) = {r  PR : M |= head(r) and M |  body - (r)} Unpref(PR,M) is the least set including Unsup(PR, M) and every rule r such that:  r’  (PR – Unpref(PR, M)) : M |= r’ < r,  M |= body + (r’) and [not head(r’)  body - (r) or  (not head(r)  body - (r’) and M |= body(r))]

Preferred Stable Models Def. Preferred stable models Let s be a state, P =  {(Pi,Ri) : i  S} a dynamic prioritized program, and M a stable model of P. M is a preferred stable model of P at state s iff M = least( [X - Unpref(X, M)]  Default(PR, M) ) where: PR =  i  s (Pi  Ri) Q =  { Pi  Ri : i  S } X = PR - Reject(s,M,Q)

Transformation  (s,P) = DLP(s,P)   r  Q  (r)  DA  SPO Let s be a state and P =  {(Pi,Ri) : i  S} a dynamic prioritized program. Let Q =  i  s Pi Def.  (s,P) transformation

DLP(s,P) Transformation The DLP(s,P) transformation models the dynamic aspects of update reasoning: DLP(s,P) = RP  UR  IR  DR  RR  CS

DLP(s,P) Transformation (RP) Rewritten program rules with A Fi  A 1,…,A n,A - n+1,…,A - m with A - Fi  A 1,…,A n,A - n+1,…,A - m A  A 1,…,A n,not A n+1,…,not A m not A  A 1,…,A n,not A n+1,…,not A m Replace any rule in Fi=Pi  Ri of the form: and of the form:

(UR) Update rules A i  A Fi A - i  A - Fi (IR) Inheritance rules A i  A i-1, not A - Fi A - i  A - i-1, not A Fi (DR) Default rules A0-A0- DLP(s,P) Transformation

(RR) Rejection rules reject(n r )  A Ft reject(n r )  A - Ft for any rule r in Fi=Pi  Ri and for all i < t  s (CS) Current state rules A  A s A -  A - s false  A, A - DLP(s,P) Transformation

 (r) Transformation The  (r) transformation models preference reasoning. If r = not A  A 1,…,A n,not A n+1,…,not A m then ř = not Ă  Ă 1,…, Ă n,not Ă n+1,…,not Ă m Let [.] be a function from literals to objective atoms: [A] = A [not A] = A - Notation

 (r) Transformation  (r) rules: consists of the following collection of rules, for A  body + (r), not C  body - (r) and any rule u  Q:  ap(n r ), not reject(n r ) ok(n r ), [body(r)], [body - (ř)] ok(n r ), A -, Ă - ok(n r ), C, Č [head(ř)] ap(n r ) bl(n r ) Suppose that Q = { r 1,…, r k }

 (r) Transformation  ry(n r,n r1 ),…,ry(n r,n rk ) not (n u < n r ) (n u < n r ), ap(n u ) (n u < n r ), bl(n u ) ko(n u ) reject(n u ) not ok(n r ), not reject(n r ) [head(r)], C ok(n r ) ry(n r,n u ) ry(n r,n u ) false ko(n r )

Transformation (DA) Default atom rules Ă -  not Ă (SPO) Strict partial order false  n r < n r false  n r1 < n r2, n r2 < n r3, (n r1 < n r3 ) -

Properties of  (r) Let s be a state, P =  {(Pi,Ri) : i  S} a dynamic prioritized program and M a stable model of P. Let Q =  i  s Pi. Then, the following properties hold: -  r  Q if reject(n r )  M, then ok(n r )  M -  r  Q if reject(n r )  M, then ( ap(n r )  M iff bl(n r )  M ) -  r  Q if ko(n r )  M iff r  Unsup(Q,M) -  r  Q if reject(n r )  M, then ( ko(n r ) implies bl(n r ) )

Properties of  (s,P) Let s be a state and P a dynamic prioritized program. An interpretation M a stable model of  (s,P) iff M, restricted to the language of P, is a preferred stable model of P at state s. Thm. Correctness of  (s,P)

Conclusions  We presented a compilation into normal programs of logic programs subject to updates and preferences combined under the stable model semantics.  The preference part of our transformation is modular or incremental wrt. the update part of the transformation.  The size of the transformed program  (s,P) in the worst case is quadratic on the size of the original dynamic prioritized program P.  An implementation of the transformation is available at:

Future work  Garbage collection of dynamic logic programs.  Combining updates and preferences under the well-founded semantics.  Exploring some application areas: * abductive reasoning with updatable preferences. * dynamically reconfigurable web-sites which adapt to updatable user profiles.