Upload
internet
View
104
Download
0
Tags:
Embed Size (px)
Citation preview
Dynamic Logic Programming with Multiple Dimensions
João Alexandre Leite
José Júlio Alferes
Luís Moniz Pereira
CENTRIA – Universidade Nova de Lisboa
Universidad de la Habana, Cuba, 4 Dec. 2000AGP’2000
Overview
Introduction and Motivation (Overview of Dynamic Logic Programming)Multi-dimensional Dynamic Logic
Programming Framework Semantics Syntactical Transformation
Application to Multi-agent SystemsConclusions 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.
More recent laws have precendence over older ones
L2 L1
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 DAGMDLP, 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.
2 Dimensional Lattice
d1 d2P 11
P 33
P 23P 32
P 31
P 12
P 22
P 21
P 13
Acyclic Digraph (DAG)
P a
P h
P gP i
P c
P e
P d
P b
P f
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
Ps1 Ps2
Pr1 Pr2
Psr
{a c}
{b}
{not a c}
{c}
{}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
Semantics at sr:
M = {b, not a, c}Reject(sr,M) = {a c}Default(P,M) = {not a}
Example 1 (cont)
Ps1 Ps2
Pr1 Pr2
Psr
{a c}
{b}
{not a c}
{c}
{}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) = {}
Semantics at sr:
M = {not a, not b, not c}Reject(sr,M) = {}Default(P,M) = M
Example 2
Pt1a1{p q}
{q}{not p q}
{}
Semantics at t2a1:
M = {p, q}Reject(t2a1,M) = {}Default(P,M) = {}
Semantics at t1a2:
M = {not p, not q}Reject(t1a2,M) = {}Default(P,M) = M
Semantics at t2a2:
M = {q, not p}Reject(t2a2,M) = {p q}Default(P,M) = {}
Pt1a2
Pt2a2
Pt2a1
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
(RR) Rejection Rules
(CRS) Current State Rules
(UR) Update
Rules
(DR) Default
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
(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 rulesAv APv A’v A’Pv
(DR) Default rules
A’s0
(CSR) Current state rules
A As not A A’s
Syntactical Transformation
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 inheritanceIndividual 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 MDLPsRemove the acyclicity condition (??)Applications and relationships