Dynamic Logic Programming with Multiple Dimensions João Alexandre Leite José Júlio Alferes Luís Moniz Pereira CENTRIA – Universidade Nova de Lisboa AGP’2000 Universidad de la Habana, Cuba, 4 Dec. 2000 Overview Introduction and Motivation (Overview of Dynamic Logic Programming) Multi-dimensional Dynamic Logic Programming Framework Semantics Syntactical Transformation Application to Multi-agent Systems Conclusions and Future Work Motivation In Dynamic Logic Programming (DLP) knowledge is given by a sequence of Programs Each program represents a different state of our knowledge, where different states may be: different time points, different hierarchical instances, different viewpoints, etc. Different states may have mutually contradictory or overlapping information. DLP, using the relations between states, determines the semantics at each one. Motivation (2) LUPS was presented as a language to build DLPs It can been used to: model evolution of knowledge in time reason about actions reason about hierarchies, … But how to combine several of these aspects in a single system? Motivation Example The parliament issues law L1 at time t1. The local authorithy issues law L2 at t2 > t1 Parliament laws override local laws, but not vice-versa. L2 L1 More recent laws have precendence over older ones L1 L2 How to combine these two dimension of knowledge precedence? DLP with Multiple Dimensions (MDLP) DLP with Multiple dimensions In MDLP knowledge is given by a set of programs Each program represents a different state of our knowledge. States are connected by a DAG MDLP, using the relations between states and their precedence in the DAG, determines the semantics at each state. Allows for combining knowledge which evolve in various dimensions. P11 P21 P31 d2 d1 2 Dimensional Lattice P12 P22 P32 P13 P23 P33 Acyclic Digraph (DAG) Pa Pb Pc Pe Pd Pi Pf Pg Ph Generalized Logic Programs To represent negative information in LP and their updates, we need LPs with not in heads Object formulae are generalized LP rules: A B1,…, Bk, not C1,…,not Cm not A B1,…, Bk, not C1,…,not Cm The semantics is a generalization of SMs MDLPs definition Definition: A Multi-dimensional Dynamic Logic Program, P, is a pair (PD,D) where D=(V,E) is an acyclic digraph and PD={PV : v V} is a set of generalized logic programs indexed by the vertices v V of D. MDLP - Semantics Definition: Let P=(PD,D) be a Multi-dimensional Dynamic Logic Program, where PD={PV : v V} and D=(V,E). An interpretation Ms is a stable model of the multi-dimensional update at state sV iff: Ms=least([Ps – Reject(s, Ms)] Defaults (Ps, Ms)) Ps= js Pi MDLP - Semantics Ms=least([Ps – Reject(s, Ms)] Defaults (Ps, Ms)) where: Reject(s, Ms)= {r Pi | r’ Pj , ijs, head(r)=not head(r’) Ms |= body(r’)} Defaults (Ps, Ms)={not A | r Ps : head(r)=A Ms |= body(r)} Example 1 {a c} Ps1 {b} P r1 Ps2 {} Pr2 {c} {not a c} Psr Semantics at sr: M = {b, not a, c} Reject(sr,M) = {a c} Default(P,M) = {not a} Semantics at r1: M = {b, not a, not c} Reject(r1,M) = {} Default(P,M) = {not a, not c} Semantics at s1: M = {not a, not b, not c} Reject(s1,M) = {} Default(P,M) = M Example 1 (cont) {a c} Ps1 {b} P r1 Ps2 {} Pr2 {c} {not a c} Psr Semantics at sr: M = {not a, not b, not c} Reject(sr,M) = {} Default(P,M) = M Semantics at r1: M = {b, not a, not c} Reject(r1,M) = {} Default(P,M) = {not a, not c} Semantics at s1: M = {a, b, c} Reject(s1,M) = {not a c} Default(P,M) = {} Example 2 Semantics at t2a1: {p q} P t1a1 {not p q} Pt1a2 Pt2a1 {q} Pt2a2 {} Semantics at t2a2: M = {q, not p} Reject(t2a2,M) = {p q} Default(P,M) = {} M = {p, q} Reject(t2a1,M) = {} Default(P,M) = {} Semantics at t1a2: M = {not p, not q} Reject(t1a2,M) = {} Default(P,M) = M Towards an implementation of MDLP How to implement MDLP? Pre-process a MDLP at a state s into a single generalized program, where the stable models at s are the stable models of the single program. Query-answering is reduced to that at single programs. MDLP – Syntactical Transformation Definition: Let P=(PD,D) be a Multi-dimensional Dynamic Logic Program, where PD={PV : v V} and D=(V,E), including a special empty source s0. The dynamic program update over P at the state s S is a logic program s P with: (RP) Rewritten program rules (IR) Inheritance rules (UR) Update Rules (RR) Rejection Rules (DR) Default Rules (CRS) Current State Rules (GR) Graph Rules Syntactical Transformation (RP) Rewritten program rules APv B1 , … , Bm , C’1, … , C’n A´Pv B1 , … , Bm , C’1, … , C’n for any rule A B1 , … , Bm , not C1, … , not Cn not A B1 , … , Bm , not C1, … , not Cn in Pv Syntactical Transformation (GR) Graph rules edge(u,v) (for every u < v E ) path(X,Y) edge(X,Y). path(X,Y) edge(X,Z), path(Z,Y). Syntactical Transformation (IR) Inheritance rules Av Au , not reject(Au), edge(u,v) A´v A´u , not reject(A´u ), edge(u,v) (RR) Rejection rules reject(Au) A´Pu , path(u,v) reject(A´u) APu , path(u,v) Syntactical Transformation (UP) Update rules Av APv A’v A’Pv (DR) Default rules A’s0 (CSR) Current state rules A As not A A’s MDLP - Results Theorem: The generalized stable models of the program s P coincide with the generalized stable models of the multi-dimensional update at state s according to the semantical characterization. Theorem: Multi-dimensional Dynamic Logic Programming generalizes Dynamic Logic Programming. MDLP applications Combining agents’ knowledge Distributed KBs Program composition Evolution of hierarchical knowledge Legal reasoning e-commerce policy integration and evolution Organizational decision making Multiple inheritance Individual agents’ views Future Work A (LUPS-like) language for building MDLPs allowing updatable DAGs (new edges and nodes) allowing for conditions on new edges Societies of MDLPs Observation points (public and private) Inter-MDLP updates and communication Integration of MDLPs with common Ps Hypothetical reasoning over MDLPs Remove the acyclicity condition (??) Applications and relationships