The Discrete Event Calculus for Games and Other (Soft) Real Time Systems

Size: px

Start display at page:

Download "The Discrete Event Calculus for Games and Other (Soft) Real Time Systems"

Mercy Warner
6 years ago
Views:

1 The Discrete Event Calculus for Games and Other (Soft) Real Time Systems Matthew Fuchs, PhD Paideia Computing Corp

2 Outline Movie The target DEC explained DEC as a programming language Implementation Future possibilities

3 Give me a command Video at

4 What I was looking for Unified approach Not mix of java, prolog, etc., with protocols and events passing among them Able to handle/model multi-modal input Speech, movement, pointing, possession Rich behavior, not just Finite State Machines Rich behavior set, but not difficult to add new behaviors Large variety of events arriving at any time Can integrate with other AI systems or handle such tasks directly Personality, planning, language Multitasking Handle multiple characters in a single environment Sufficiently fast soft real time not aware of any explicitly temporal rule engines Able to reason about programs

5 Event Calculus

6 What it s been used for Robotic path planning Linguistics Story understanding Abductive planning Agent programming Contract law Workflow modeling Mateas work in games Etc.

7 What I found: Rules with Time AI Logic Formalism Descended from Situation Calculus First proposed by Kowalski and Sergot, extended by Shanahan Has an explicit time parameter either continuous or discrete Commonsense law of inertia Handles the Frame Problem through Circumscription Sorted (multiple token types)

8 DEC What Fluents Events When Happens HoldsAt How Initiates Terminates Trajectory AntiTrajectory Releases

9 Fluents A function of sort fluent Unique names f 1 (p 1,,p n ) = f 2 (q 1,,q n ) iff f 1 =f 2 & p 1 =q 1,,p n =q n HoldsAt(f,t) is 2 parameter predicate HoldsAt(walks(John),0). Either holds or doesn t at t=0 Normally only changes value through events (law of inertia)

10 Events A function of sort event Unique Names e(p 1,,p n ) = e(q 1,,q n ) iff p 1 =q 1,,p n =q n Happens(e,t) is a 2 parameter predicate Happens(notices(John,Tiger),4). Events happen at particular moments in time and are only true at that moment (or happen again)

11 Initiates/Terminates Initiates(e,f,t) Happens(e,t) & ~HoldsAt(f,t) -> HoldsAt(f,t+1). Terminates(e,f,t) Happens(e,t) & HoldsAt(f,t) -> ~HoldsAt(f,t+1). [t]initiates(notices(john,tiger),runs(john),t). [t]terminates(notices(john,tiger),walks(john),t)

12 Trajectory Trajectory(f 1,t 1,f 1,t 2 ) If f 1 is initiated at t 1 and holds at t 1 +t 2, then f 2 holds at t 2 Trajectory(walksFrom(John,X,Y,Phi),t1, position(john,x+t2*cos(phi),y+t2*sin(phi),t2) Assumes you calculate the arguments to f 2 at t 2 Depends on the math for f 2

13 AntiTrajectory AntiTrajectory(f 1,t 1,f 2,t 2 ) If f 1 is terminated at t 1 and doesn t hold at t 2, then f 2 holds at t 1 +t 2 HoldsAt(Height(bird,h),t1)->AntiTrajectory(Flapping(bird),t1, Height(bird,h ½ G t 22 ) Assumes you calculate the arguments to f 2 at t 2 Depends on the math for f 2

14 Released Releases(e,f,t). A released fluent may take any logically allowed value Allows fluents to function like ordinary logical variables HoldsAt(sees(John,Tiger),t) -> HoldsAt(scared(John),t).

15 Circumscription Handles frame problem Some variables change between t and t + 1 How to make sure nothing else does Essentially create equivalence between a predicate and the rules that cause it 1 -> Happens(e,t) 2 -> Happens(e,t) Happens(e,t) <-> 1 2

16 Rest of syntax [] for universal quantificaton {} for existential quantification! for negation & for and, for or -> for implication My additions: notices(john,tiger)!time

17 Example John is walking John is frightened of tigers If John is frightened he Stops walking Finds a place to run to Starts running

18 Declarations sort mob sort gait mob John, Tiger gait Walking, Running structure Location(x:integer,y:integer,z:integer,theta:integer) externevent SetGait(mob,gait) externevent MovesTo(mob,location) fluent Position(mob,location) event Sees(mob,mob) predicate IsVisible(location,location) function MoveAway(location,location):location fluent Frightens(mob,mob) fluent Position(mob,location)

19 Initial Conditions Position(John, Location(0, 0, 0, Position(Tiger, Location(0, 0, 8, SetGait(John,

20 Some rules [mob,location,time] MovesTo(mob,location)=>Position(mob,location),time). [mob,location1,location2,time] &!(location2 = location1) -> MovesTo(mob,location2) /=> Position(mob,location1)@time. [mob1,mob2,location1,location2,time] Position(mob1,location1)@time & Position(mob2,location2)@time & IsVisible(location2,location1) -> Sees(mob1,mob2)!time.

21 Last rules [mob1,mob2,time] & -> [mob1,mob2,location1,location2,time] & & & location3 = MoveAway(location1,location2) -> MovesTo(mob1,location3)!time

22 How it s used Model checking Completely static Tic Tac Toe as an example Rules to generate all games Generates all games given some moves SAT is slow Perhaps Answer Set Programming?

23 DEC as a programming language Time parameter maps to game/animation world and simulation communicate via events World events arrive at each tick Rules are evaluated with new events Some events are external and reflected back Don t need Conscription Many State Constraints (F(x) & F(y) => x = y)

24 Markov issues DEC rules are symmetric to time e!t -> e 2!(t 10) e 2!t -> e!(t + 10) Future can affect past running(john)@t1 -> {t2}t2 < t1 & scared(john)@t2. Programs run forward in time

25 Implementation Convert into forward chaining DEC rules don t have Markov Property Rules that don t obey MP are tests/asserts Might be used for reasoning later on Execution but not reasoning only goes forwards Apply rete for efficiency Simplify by translating to CLIPS style system Not included in current implementation Released fluents (state constraints) (Anti)Trajectory

26 Rete algorithm Greek for net Allows forward chaining systems to be fast Rules of form (LHS -> RHS) ((a & b) (c & d)) -> g ((e & b) (c & d)) -> h Break up LHS into variables and binary ops Create a network from the results combining LHS overlaps Facts (de)activate parts of network

27 Forward Chaining System Active axioms of forms -> Initiates(e,f,t) -> Terminates(e,f,t) -> Trajectory(f 1,t 1,f 2,t 1 ) -> AntiTrajectory(f 1,t 1,f 2,t 2 ) Implication means perform ->Initiates(e,f,t) changes an explicit state Other forms become tests Move(rc1,rc2,mark1)!time & Move(rc3,rc4,mark2)!time -> rc1 = rc3 & rc2 = rc4 & mark1 = mark2.

28 Primitives (Clips style) Fluents are atoms (fluent, time, p1,,pn) Events are atoms (event, time, p1,,pn) Add structures, lists (name, id, type, ref count, p1,,pn) Primitive pattern matching

29 Multistage architecture Each time step has four stages Prepare new fluents Create fluents Garbage Collect Generate new events

30 Stage 0 (with events and fluents remaining from t-1) Evaluate ->Initiates(e,f,t) Leads to createfluent fact Evaluate -> Terminates(e,f,t) Leads to retractfluent fact Test fluent contradictions Initiate(e,f,t) & Terminate(e,f,t) are illegal

31 Stage 1 Actually create fluents Actually retract fluents Clean up events from round t - 1

32 Stage 2 Garbage collection Structures have references Language is all functional GC is through reference counting

33 Stage 3 Create all events Add all world events All rules of the forms: -> Happens(e,t). Creates external events (for outside world )

34 Test constraint violations X ->!Y X -> * +Y or X ->, -Y * +!Y HoldsAt(f,t) where t > 0

35 Rule by Rule DEC Syntax Clips Syntax (defrule startup-1 => (Time 0) (round 0) (assert (createfluent Frightens 0 Tiger John)))

36 HoldsAt as Constraint (defrule rule-2 (not (fluent Frightens?_time0 Foobar John)) (round 4) => (assert (ConstraintViolation rule-2 "[Foobar,John]")))

37 Happens on RHS [mob1,mob2,location1,location2,time] & & IsVisible(location2,location1) -> Sees(mob1,mob2)!time. (defrule rule-8 (fluent Position?_time2?mob1?location1) (fluent Position?_time3?mob2?location2) (IsVisible?location2?location1 TRUE) (round 3) (Time?time) => (assert (event Sees?time?mob1?mob2)))

38 Initiates [mob,location,time] (defrule rule-11 (event MovesTo?_time0?mob?location) (round 0) (Time?time) => (assert (modifyrefs (++?*modifyindex*)?location 1)) (assert (createfluent Position?time?mob?location)))

39 Terminates &!(location2 = location1))-> MovesTo(mob,location2)/=>Position(mob,location1)@time) (defrule rule-10 (event MovesTo?_time0?mob?location2) (fluent Position?_time2?mob?location1) (and (fluent Position?_time3?mob?location1) (not (test (=?location2?location1)))) (round 0) (Time?time) => (assert (modifyrefs (++?*modifyindex*)?location1-1)) (assert (retractfluent Position?time?mob?location1)))

40 Predicates number7 = ViewAngle(number1,number2,number3,number4) & number8 = AngleDif(number7,number5) & number8 < number6)))-> LookingAt(number1,number2,number3,number4,number5,number6) (defrule LookingAt-62 =>?_need <- (need-lookingat?number1?number2?number3?number4?number5?number6?foo) (ViewAngle?number1?number2?number3?number4?number7) (AngleDif?number7?number5?number8) (test (<?number8?number6) (retract?_need) (assert (LookingAt?number1?number2?number3?number4?number5?number6 TRUE)))

41 Functions [integer1,integer2]add(integer1,integer2) = +(integer1,integer2) (defrule Add-74?_need <- (need-add?integer1?integer2?foo) => (bind?return (+?integer1?integer2)) (retract?_need) (assert (Add?integer1?integer2?return)))

42 Behavior Management Speech Services Actions Speech output Grammar/ Lexicon Recognition results Speech Generation (Nuance/Loquendo /Phonetic Arts) Recognition Engine (Nuance/IBM/Sphinx) NPC voice Game events VoIP Layer World Engine Game/Learning Player voice Player actions NPC Actions

43 Multiple versions Flash Media Server Multiverse for robot video HTTP version for Parrot

44 Dancing Parrot Video at Parrot front end by Oddcast ( )

45 Fun other stuff Petri nets Model checking not just SAT Better syntax Pattern matching Probabilistic processes Adding probabilities to traversal Implementing the other party

46 Better Syntax f (e 1 =>f & e 1 /=>f 2 & f -> e 2!t) ( 1 xor 2 xor 3 )

47 Probabilistic Processes Model opponents Add probabilities e 1!t:0.2 xor e 2!t:0.6 xor e 3!t: :e!t->f1@t f2@t

48 Conclusion Works for animation/games Can work for soft real time processes Combines a rule engine with temporal processes Currently translating to Drools

49 Thank you!

Intelligent Systems: Reasoning and Recognition. Rule based programming - Introduction to CLIPS 6.0

Intelligent Systems: Reasoning and Recognition James L. Crowley ENSIMAG 2 / MoSIG M1 Second Semester 2010/2011 Lesson 5 16 February 2011 Rule based programming - Introduction to CLIPS 6.0 Production Systems...2