Normative Monitoring: Semantics and Implementation

Introduction Related Work Preliminary deﬁnitions Semantics Reduction Implementation Conclusions

Normative Monitoring:
Semantics and Implementation

Sergio Alvarez-Napagao, Huib Aldewereld,
´
Javier Vazquez-Salceda and Frank Dignum

COIN@MALLOW 2010
Lyon, France
August 30, 2010

´
S.Alvarez-Napagao, H.Aldewereld, J.Vazquez-Salceda, F.Dignum Normative Monitoring: Semantics and Implementation


Outline

1 Introduction

2 Related Work

3 Preliminary deﬁnitions

4 Semantics

5 Reduction

6 Implementation

7 Conclusions

´


Motivation

Normative systems can help guide the behaviour of
interacting agents
Monitoring is vital for the effectiveness of a normative
system
Agents may enter and leave interaction contexts, so
dynamic normative speciﬁcations are desirable
Monitoring is a passive procedure based on the checking
of past events
Interpretation of institutional events from brute events
If decoupled from reasoning, can be used by different kinds
of agents and third parties

´


Requirements

Dynamic normative speciﬁcations

Interpretation of both
Institutional facts
What ought to be done
Ability to reason about norms themselves

Efﬁciency with large sets of events
Reusable formalism, decoupled implementation

´


Requirements

Dynamic normative specifications → Run-time specification
loading
Interpretation of both
Institutional facts → Counts-as rules
What ought to be done → Expressive normative language
Ability to reason about norms themselves → Norms as first-class
entities
Efficiency with large sets of events → Rule-based engine
Reusable formalism, decoupled implementation → From norms to rules

´


Related work

Normative / contract monitoring is not a new topic
Some approaches (e.g. [Kyas et al. 08]) are based on
veriﬁcation techniques, checking events against traces
For the monitoring of past events such complexity is not
needed
The most common approach has been rule-based

´


Related work
Some approaches for electronic SLA / contracts are quite
mature (e.g. [Paschke et al. 05][Strano et al. 08])
However, the expressivity of the norm language used is
limited
Other approaches (e.g. [Governatori 05][Hubner et al. 09])
¨
use rules to assert deontic expressions
Parts of the norm lifecycle implementation are out of the
base rule engine
Norm instances are not easily traceable
[Garcá-Camino et al. 05] defines a full translation scheme
ı
into Jess
But it uses language-specific constructs
No support for constitutive rules
[Tinnemeier et al. 09] defines operational semantics with a
combination of counts-as rules and sanctions
Regulative norms are not supported
´


Our proposal

Use of norm language with support for conditional deontic
expressions
Support for counts-as rules
Reduction to semantics of a general rule-based language
Providing a direct syntactic translation from norms to rules
Decouple monitoring process from reasoning

´


Example scenario

1 A person driving on a street is not allowed to break a traffic
convention.
2 In case (1) is violated, the driver must pay a fine.
3 In a city, to exceed 50kmh counts as breaking a traffic
convention.

´


Notation

O is a set of predicates and constants,
LO is a predicate based propositional logic language with
the connectives {¬, ∧, ∨},
wff (LO ) is the set of all possible well-formed formulas of
LO ,
Θ = {x1 ← t1 , x2 ← t2 , ..., xi ← ti } is a substitution instance
of the terms ti for the variables ti ,
R ⊂ O is the set of roles, and P is the set of participants,
each one enacting at least one role in R,
s ⊆ O is a certain state of the world,
ni = n, θ is a norm instance, and
n Y n means that n is a violation handling norm of n:
fA ∧ ¬fM ∧ ¬fD ≡ fA .
´


Definition of counts-as

Definition
A counts-as rule is a tuple c = γ1 , γ2 , s , where
γ1 , γ2 ∈ wff (LO ), and s ⊆ O.

Example
In a city, to exceed 50kmh counts as breaking a traffic
convention:
C :={ exceeds(D, 50), traffic violation(D), is in city(D) }

´


Definition of norm

Definition
A norm n is a tuple n = fA , fM , fδ , fD , fw , w , where
fA , fM , fδ , fD , fw ∈ wff (LO ), w ∈ R,
fA , fM , fD respectively represent the activation,
maintenance, and deactivation conditions of the norm,
fδ , fw are the explicit representation of the deadline and
target of the norm, and
w is the subject of the norm.

This definition does not explicitly include deontic operators, but:

fA → [Ow (Ew fw ≤ ¬fM ) U fD ]

´


Definition
A norm n is a tuple n = fA , fM , fδ , fD , fw , w , where
fA , fM , fδ , fD , fw ∈ wff (LO ), w ∈ R,
fA , fM , fD respectively represent the activation,
maintenance, and deactivation conditions of the norm,
fδ , fw are the explicit representation of the deadline and
target of the norm, and
w is the subject of the norm.

Example
A person driving on a street is not allowed to break a traffic convention:

n1 := enacts(X , Driver ) ∧ is driving(X ), fA
¬traffic violation(X ), fM
⊥, fδ
¬is driving(X ), fD
is driving(X ) ∧ ¬traffic violation(X ), fw
Driver w

´


Definition of institution

Definition
An institution I is a tuple of norms, roles, participants, counts-as
rules, and an ontology:

I = N, R, P, C, O

Example
N :={ enacts(X , Driver ) ∧ is driving(X ),
¬traffic violation(X ), ⊥, ¬is driving(X ),
is driving(X ) ∧ ¬traffic violation(X ), Driver ,
enacts(X , Driver ) ∧ is driving(X ) ∧ traffic violation(X ),
,
paid fine(X ), Driver }
R :={Driver }, P :={Person1 }
C :={ exceeds(D, 50), traffic violation(D), is in city(D) }
O :={role, enacts, is driving, is in city,
exceeds, traffic violation, is driving, paid fine,
Person1 , role(Driver ), enacts(Person1 , Driver )}

´


Norm Lifecycle

Definition
Let ni = n, Θ be a norm instance, where n = fA , fM , fD , w ,
and a state of the world s with an expansion F (s). The lifecycle
for norm instance ni is defined by the following normative state
predicates:
activated(ni) ⇔ ∃f ∈ F (s), Θ(fA ) ≡ f
maintained(ni) ⇔ ∃Θ , ∃f ∈ F (s), Θ (fM ) ≡ f ∧ Θ ⊆ Θ
deactivated(ni) ⇔ ∃Θ , ∃f ∈ F (s), Θ (fD ) ≡ f ∧ Θ ⊆ Θ
instantiated(ni) ⇔ ni ∈ IS
violated(ni) ⇔ ni ∈ VS
fulfilled(ni) ⇔ ni ∈ FS

where IS is the instantiation set, FS is the fulfillment set, and
VS is the violation set, as defined above.
´


Example of Norm Lifecycle

A person driving on a street is not allowed to break a trafﬁc
convention:

´


Normative Monitor

Definition
A Normative Monitor MI for an institution I is a tuple
MI = I, S, IS, VS, FS .

Definition
An event e is a tuple e = α, p , where α ∈ P, and p ∈ wff (LO ).

Definition
The Labelled Transition System for a Normative Monitor MI is
defined by Γ, E, £ .

´


Deﬁnition
Event processed:

ei = α, p
(1)
i, s, is, vs, fs , ei , ei+1 £ i, s ∪ {p}, is, vs, fs , ei+1

Counts-as rule activation:

∃Θ, ∃f ∈ F (s), ∃ γ1 , γ2 , si ∈ C, si ⊆ s ∧ Θ(γ1 ) ≡ f ∧ Θ(γ2 ) ∈ s
/
(2)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s ∪ {Θ(γ2 )}, is, vs, fs , e

Counts-as rule deactivation:

∃Θ, ∃f ∈ F (s), ∃ γ1 , γ2 , si ∈ C, si ⊆ s ∧ Θ(γ1 ) ≡ f ∧ Θ(γ2 ) ∈ s
(3)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s − {Θ(γ2 )}, is, vs, fs , e

´


Deﬁnition
Norm instantiation:

∃n = fA , fM , fD , w ∈ N ∧ ¬∃n ∈ N, n Y n ∧ n, Θ ∈ is ∧ ∃Θ, ∃f ∈ F (s), f ≡ Θ(fA )
/
(4)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, is ∪ { n, Θ }, vs, fs , e

Norm instance violation:

∃n = fA , fM , fD , w ∈ N ∧ n, Θ ∈ is ∧ n, Θ ∈ vs∧
/
¬(∃Θ, ∃f ∈ F (s), f ≡ Θ(fM ) ∧ Θ ⊆ Θ ) ∧ NR = n;n n ,Θ
(5)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, (is − { n, Theta }) ∪ NR,
vs ∪ { n, Θ }, fs , e

Norm instance fulﬁlled:

∃n = fA , fM , fD , w ∈ N ∧ n, Θ ∈ is ∧ ∃Θ, ∃f ∈ F (s), f ≡ Θ(fD ) ∧ Θ ⊆ Θ
(6)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, is − { n, Θ }, vs, fs ∪ n, Θ ,e

Norm instance violation repaired:

∃n, n ∈ N ∧ n Y n ∧ n, Θ ∈ vs ∧ n , Θ ∈ fs
(7)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, is, vs − { n, Θ }, fs , e

´


Definition
Norm instantiation:

∃n = fA , fM , fD , w ∈ N ∧ ¬∃n ∈ N, n Y n ∧ ∃Θ, (activated( n, Θ ) ∧ ¬instantiated( n, Θ ))
(8)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, is ∪ { n, Θ }, vs, fs , e

Norm instance violation:

∃n = fA , fM , fD , w ∈ N ∧ ∃Θ , instantiated( n, Θ ) ∧ ¬violated( n, Θ )
∧¬maintained( n, Θ ) ∧ NR = n;n n ,Θ
(9)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, (is − { n, Theta }) ∪ NR,
vs ∪ { n, Θ }, fs , e

Norm instance fulfilled:

∃n = fA , fM , fD , w ∈ N ∧ instantiated( n, Θ ) ∧ fulfilled(n, Θ )
(10)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, is − { n, Θ }, vs, fs ∪ n, Θ ,e

Norm instance violation repaired:

∃n, n ∈ N ∧ n Y n ∧ ∃Θ, violated( n, Θ ) ∧ fulfilled( n , Θ )
(11)
N, R, P, C, O , s, is, vs, fs , e £ N, R, P, C, O , s, is, vs − { n, Θ }, fs , e

´


Semantics of production systems

Definition
A production rule is denoted if p, c remove r add a, or

patterns, constraints ⇒ remove, add

Definition
A general production system PS is defined as
PS = P, WM0 , R , where:
P is a set of predicate symbols,
WM is the working memory, a set of facts, and
R is a set of production rules.

´


Reduction to production systems
In order to represent our semantics to a production system, we
have to define the translation of P, WM0 , and R for a certain
institution I = N, R, P, C, O . We assume all formulas are in
DNF.
Definition
The set of predicates for our production system is:
PI := O ∪ {activated, maintained, deactivated, violated,
instantiated, fulfilled, event, repair , holds, has clause, countsas}

WMI will include each formula found in every norm condition
and counts-as rule, as well as the relationship between each
formula and norms or counts-as rule.
Example
has clause(f , f0 ), has clause(f , f1 ), activation(n1 , f )
´


Reduction to production systems

The set of rules of the production system will include:
For each formula in a norm or counts-as rule, when they
hold true:
r h := has clause(f , f ) ∧ holds(f , Θ) ⇒ ∅, {holds(f , Θ)}
A translation of each rule from the Normative Monitor
transition system:
r nf = deactivation(n, f ) ∧ instantiated(n, Θ) ∧
subseteq(Θ , Θ) ∧ holds(f , Θ ),
Θ ⊆Θ
⇒ {instantiated(n, Θ)}, {fulﬁlled(n, Θ)}

´


Architecture

A prototype has been implemented as a D ROOLS program.

´


Rules in D ROOLS

The base rules have been directly translated:

r u l e ” norm i n s t a n c e f u l f i l l m e n t ”
when
D e a c t i v a t i o n ( n : norm , f : f o r m u l a )
n i : I n s t a n t i a t e d ( norm == n , t h e t a : s u b s t i t u t i o n )
SubsetEQ ( t h e t a 2 : subset , s u p e r s e t == t h e t a )
Holds ( f o r m u l a == f , s u b s t i t u t i o n == t h e t a 2 )
then
retract ( ni ) ;
i n s e r t ( new F u l f i l l e d ( n , t h e t a ) ) ;
end

´


Rules in D ROOLS

The norms and counts-as rules are parsed into rules at
run-time:

rule ” N1 activation 0 ”
when
n : Norm ( i d == ” N1 ” )
A c t i v a t i o n ( norm == n , f : f o r m u l a )
Enacts ( X : p0 , p1 == ” D r i v e r ” )
I s D r i v i n g ( p0 == X )
then
Set<Value> t h e t a = new Set<Value > ( ) ;
t h e t a . add ( new Value ( ” X ” , X ) ) ;
i n s e r t ( new Holds ( f . getClause ( 0 ) , t h e t a ) ) ;
end

´


Rules in D ROOLS

The parser ﬁlls the working memory:

ksession . i n s e r t ( norm1 ) ;
ksession . i n s e r t ( norm2 ) ;
ksession . i n s e r t (new Repair ( norm1 , norm2 ) ) ;
ksession . i n s e r t (new A c t i v a t i o n ( norm1 , fn1a ) ) ;
ksession . i n s e r t (new Maintenance ( norm1 , fn1m ) ) ;
ksession . i n s e r t (new D e a c t i v a t i o n ( norm1 , fn1d ) ) ;
ksession . i n s e r t (new HasClause ( fn1a , fn1a1 ) ) ;
ksession . i n s e r t (new HasClause ( fn1m , fn1m1 ) ) ;
ksession . i n s e r t (new HasClause ( fn1d , fn1d1 ) ) ;
/∗ . . . same f o r norm2 . . . ∗/
ksession . i n s e r t (new CountsAs ( c1g1 , c1g2 , c1s ) ) ;
ksession . i n s e r t (new HasClause ( c1g1 , c1g11 ) ) ;
ksession . i n s e r t (new HasClause ( c1g2 , c1g21 ) ) ;
ksession . i n s e r t (new HasClause ( c1s , c1s1 ) ) ;

´


Conclusions

Practical reasoner for detecting event-driven normative
states
Not intended to be a general purpose reasoner (e.g.
planner)
But can be used as a decoupled component
Supporting both regulative norms and constitutive rules
Reduction to general production systems
Based on very abstract semantics of production systems
Wide range of implementation-level rule languages
available
Allowing for dynamic normative speciﬁcations

´


Thank You!

´

Normative Monitoring: Semantics and Implementation

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Mehr von Knowledge Engineering and Machine Learning Group

Mehr von Knowledge Engineering and Machine Learning Group (8)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Normative Monitoring: Semantics and Implementation