Defining Datalog in Rewriting Logic

Transcription

1 M. A. Feliú Universidad Politécnica de Valencia, DSIC / ELP Joint work with María Alpuente, Christophe Joubert and A. Villanueva Coimbra, September 2009

2 Motivation Recent interest in defining complex interprocedural program analyses in Datalog Concise and intuitive analysis specifications Need of efficiently solving Datalog programs under a huge set of facts Existing approaches: bddbddb: based on Bdds Problem: Simplicity is lost when handling reflection properties Datalog solve: based on Bess Problem: Traceability for giving answers is difficult (low level) 2 / 40

3 Motivation Our proposal: from Datalog to Maude Remaining at a higher level Existing transformations from Logic Programming to Rewriting Interesting Maude features higher expressivity ACU efficient implementation reflection/metaprogramming Final goals: expressing analysis involving reflection concisely being efficient enough 3 / 40

4 Outline 1 Datalog 2 Maude 3 Our proposal: from Datalog to Maude 4 Conclusions 4 / 40

5 Datalog Relational language (similar to Prolog) using declarative clauses to both describe and query a deductive database Evaluation strategy: top-down (goal-directed) [Ullman 1985] bottom-up (inferred from base facts) [Ullman 1989] Datalog query: q = R, G where: R, a Datalog program defined over P, V and C, G, a goal. Additional restrictions Finite domains P, V (capital letters) and C (lower-case letters) No function symbols... 5 / 40

6 Datalog Example Facts supervise(mary, alice). supervise(alice, mark). 6 / 40

7 Datalog Example Facts supervise(mary, alice). supervise(alice, mark). Clauses superior(x, Y) :- supervise(x, Y). superior(x, Y) :- supervise(x, Z), superior(z, Y). 6 / 40

8 Datalog Example Facts supervise(mary, alice). supervise(alice, mark). Clauses superior(x, Y) :- supervise(x, Y). superior(x, Y) :- supervise(x, Z), superior(z, Y). Example of goal :- superior (X, mark). 6 / 40

9 Datalog Example Facts supervise(mary, alice). supervise(alice, mark). Clauses superior(x, Y) :- supervise(x, Y). superior(x, Y) :- supervise(x, Z), superior(z, Y). Example of goal :- superior (X, mark). Answer {X/mary,X/alice} 6 / 40

10 Maude Reflective language supporting both equational and rewriting logic sorts define data types and subsort relations among them sorts Constraint ConstraintSet subsort Constraint < ConstraintSet Deterministic behavior defined by (conditional) equations op, : Constraint Constraint -> Constraint [assoc comm id:t].. eq C1, C1 = C1 Non deterministic behavior defined by (conditional) rules op vp : Term Term -> Constraint. crl vp(t1,t2) => C if isconsistent(c) /\... 7 / 40

11 Maude For deterministic computations (equations) reduce t reduces the term t to its normal form For non-deterministic computations (rules) search t t explores all possible rewrites from t to t The order in which equations and rules appear does not matter Conditions in both equations and rules are evaluated from left to right 8 / 40

12 Our proposal JOEQ Source Java program Datalog facts Datalog analysis Maude specification The execution of the Maude specification recovers the computed answers of the original Datalog program Not moded transformation 9 / 40

13 The running example: Simple Pointer Analysis Java-like program o1 : p = new Object() o2 :. if.... q = p p = new Object(). 10 / 40

14 The running example: Simple Pointer Analysis Java-like program o1 : p = new Object() o2 :. if.... q = p p = new Object(). = Datalog representation vp0(p,o1). a(q,p). vp0(p,o2). 10 / 40

15 The running example: Simple Pointer Analysis Facts vp0(p,o1). vp0(p,o2). a(q,p). Clauses vp(v, O) :- vp0(v, O). vp(v, O) :- a(v, V ), vp(v, O). 11 / 40

16 The running example: Simple Pointer Analysis Facts vp0(p,o1). vp0(p,o2). a(q,p). Clauses vp(v, O) :- vp0(v, O). vp(v, O) :- a(v, V ), vp(v, O). Example of goal :- vp(q, H). Answer {H/o1, H/o2} 11 / 40

17 The running example: Simple Pointer Analysis Facts vp0(p,o1). vp0(p,o2). a(q,p). Clauses vp(v, O) :- vp0(v, O). vp(v, O) :- a(v, V ), vp(v, O). Example of goal :- vp(q, H). Answer {H/o1, H/o2} :- vp(v, o1). {V/p, V/q} 11 / 40

18 The running example: Simple Pointer Analysis Facts vp0(p,o1). vp0(p,o2). a(q,p). Clauses vp(v, O) :- vp0(v, O). vp(v, O) :- a(v, V ), vp(v, O). Example of goal :- vp(q, H). Answer {H/o1, H/o2} :- vp(v, o1). {V/p, V/q} :- vp(q, o1). {} True 11 / 40

19 The running example: Simple Pointer Analysis Facts Clauses vp0(p,o1). vp0(p,o2). a(q,p). vp(v, O) :- vp0(v, O). vp(v, O) :- a(v, V ), vp(v, O). Example of goal Answer :- vp(q, H). {H/o1, H/o2} N O T M O D E D :- vp(v, o1). {V/p, V/q} :- vp(q, o1). {} True 11 / 40

20 From Logic to Rewriting Different operational mechanisms: Logic programming based on resolution Functional programming based on term rewriting Transformations preserve the observational behavior: termination, success set, computed answers,... We don t want to impose a specific mode Traditional transformations impose an input/output relation among the parameters Giesl et al. provide a non-moded transformation preserves the termination behavior, not the computed answers 12 / 40

21 Intuition of the transformation What we want... Query Answer We want a query to progressively reduce to an answer What we must consider... Ground representation Non-determinism Unification Guided execution 13 / 40

22 Ground representation Constants We represent logic constants as Maude s Qid terms sort Constant. subsort Qid < Constant. Variables We represent logic variables with the constructor v sort Variable. op v : Qid -> Variable [ctor]. op v : Term Term -> Variable [ctor]. 14 / 40

23 Ground representation Predicates We represent predicates as defined symbols with the same arity op vp0 : Term Term -> Constraint. op vp : Term Term -> Constraint. op a : Term Term -> Constraint. Terms We represent terms as either Constants or Variables sorts Variable Constant Term. subsort Variable Constant < Term. 15 / 40

24 Ground representation Existential variables in the body of clauses In the Maude code... We create existential variables with the binary (polymorphic) constructor v(, ) The arguments of the existential variables ensure freshness 16 / 40

25 Ground representation What is an answer? An instantitation (or Constraint) of (on) the output variables that makes the query satisfiable in the logic program op = : Term Constant -> Constraint. op T : -> Constraint [ctor]. op, : Constraint Constraint -> Constraint [assoc comm id: T ]. = builds simple Constraints T is the solution when there are no output variables, builds conjunctions of Constraints 17 / 40

26 Ground representation How does a query reduction look like? vp(v, o1) V = p but also... vp(v, o1) V = q If a query has many solutions, how can we get them all? 18 / 40

27 Non-determinism Some ideas... Clauses and facts are non-deterministic Maude rules are non-deterministic Maude s search command makes a depth-first search on the rules rewriting space Decisions Each clause is translated into a conditional rule Each fact is translated into a rule The search command finds solutions by exploring the rewriting space representing correct applications of the logic program clauses 19 / 40

28 Non-determinism Datalog clauses vp(var,heap) :- vp0(var,heap). vp(var1,heap) :- a(var1,var2), vp(var2,heap). Maude code crl vp(t1,t2) => C if...condition involving vp0 crl vp(t1,t2) => C if...condition involving a and vp Each clause is translated into a corresponding conditional rule 20 / 40

29 Non-determinism Datalog facts a(q,p). vp0(p,o1). vp0(p,o2). Maude code rl a(t1,t2) => ( T1 = q ), T2 = p. rl vp0(t1,t2) => ( T1 = p ), T2 = o1. rl vp0(t1,t2) => ( T1 = p ), T2 = o2. Each fact is translated into a corresponding rule 21 / 40

30 Unification One idea... Unification guarantees correctness by succeding only when the constraints imposed on the variables in the terms to be unified are consistent Decision Explicitly check the consistency of the constraint each time a query or subgoal is reduced Pattern-matching also keeps the reduction consistent 22 / 40

31 Unification Consistency checking function op isconsistent : Constraint -> Bool. eq isconsistent( success ) = true. ceq isconsistent( ((X=Cte1), X=Cte2), C) = false if Cte1 =/= Cte2. ceq isconsistent( (Cte1=Cte2), C) = false if Cte1 =/= Cte2. ceq isconsistent( (Te=Cte), C) = true if isconsistent(c) [owise]. Detects If a variable is constrained by two different constants If a constant is constrained by something different than itself 23 / 40

32 Guided execution Datalog clauses vp(var,heap) :- vp0(var,heap). vp(var1,heap) :- a(var1,var2), vp(var2,heap). Maude code crl vp(t1,t2) => C if vp0(t1,t2) => C /\ isconsistent(c). crl vp(t1,t2) => (v(t1,t2) = Cte), C1, C2 if a(t1,v(t1,t2)) => ((v(t1,t2) = Cte), C1) /\ isconsistent((v(t1,t2) = Cte), C1) /\ vp(cte,t2) => C2 /\ isconsistent((v(t1,t2) = Cte), C1, C2). 24 / 40

33 Towards the final transformation Some problems of the previous transformation... Very inefficient Duplicated work Costs associated to the use of conditions and backtracking Difficult integration with other equational theories Maude MetaLevel needed due to the use of search Metalevel usually means more inefficiency Our transformation tries to overcome those problems Purely equational, thus deterministic It doesn t make use of backtracking It can use memoization capabilities Integration is easier It uses no conditional equation 25 / 40

34 Towards the final transformation Key Idea To deterministically reduce the query to the set of answers 26 / 40

35 The equational-based approach Rule-based Equational-based Rule non-determinism Equation determinism search reduce Conditions guide execution Unravelings guide execution Explicit consistency check Implicit consistency check The computed term encodes the whole set of (partial) computed answers 27 / 40

36 Set of Datalog computed (partial) answers Non-determinism What is a set of answers? A disjunction of anwers (or Constraints) for the given query sorts ConstraintSet EmptyConstraintSet NonEmptyConstraintSet. subsort EmptyConstraintSet NonEmptyConstraintSet < ConstraintSet. subsort NonEmptyConstraint TConstraint < NonEmptyConstraintSet. subsort FConstraint < EmptyConstraintSet. op ; : ConstraintSet ConstraintSet -> ConstraintSet [assoc comm id: F]. op ; : NonEmptyConstraintSet ConstraintSet -> NonEmptyConstraintSet [assoc comm id: F]. var NECS : NonEmptyConstraintSet. eq NECS ; NECS = NECS. --- Idempotence 28 / 40

37 Ground representation A refinement on the definition of Constraints is needed: F represents a failed computation sorts Constraint EmptyConstraint NonEmptyConstraint TConstraint FConstraint. subsort EmptyConstraint NonEmptyConstraint < Constraint. subsort TConstraint FConstraint < EmptyConstraint. op = : Term Constant -> NonEmptyConstraint. op T : -> TConstraint. op F : -> FConstraint. op, : Constraint Constraint -> Constraint [assoc comm id: T].. 29 / 40

38 Unification No consistency check function Conjunction, and substitution = are now a defined symbol Constraints are simplified as soon as possible and always kept consistent var NEC : NonEmptyConstraint. var V : Variable. var Cte Cte1 Cte2 : Constant. eq (Cte = Cte) = T. --- Simplification eq (Cte1 = Cte2) = F [owise]. --- Unsatisfiability eq NEC,NEC = NEC. --- Idempotence eq F,NEC = F. --- Zero element eq F,F = F. --- Simplification eq (V = Cte1),(V = Cte2) = F [owise].--- Unsatisfiability 30 / 40

39 Facts transformation Datalog facts a(q,p). vp0(p,o1). vp0(p,o2). Maude code eq a(t1,t2) = ((T1 = q), (T2 = p)). eq vp0(t1,t2) = ((T1 = p), (T2 = o1)) ; ((T1 = p), (T2 = o2)). Something new... op vp vp0 a : Term Term -> ConstraintSet. 31 / 40

40 Clauses transformation Datalog clauses C1: vp(var,heap) :- vp0(var,heap). C2: vp(var1,heap) :- a(var1,var2), vp(var2,heap). Maude code eq vp(t1,t2) = vpc1(t1,t2) ; vpc2(t1,t2). The answers of a predicate are the disjunction of the answers of its clauses 32 / 40

41 Clauses transformation The case when the body is composed of a single subgoal Datalog clauses C1: vp(var,heap) :- vp0(var,heap). Maude code eq vpc1(t1,t2) = vp0(t1,t2). 33 / 40

42 Clauses transformation Datalog clauses C2: vp(var1,heap) :- a(var1,var2), vp(var2,heap). Maude code eq vpc2(t1,t2) = vpc2s1(t1,t2). eq vpc2s1(t1,t2) = vpc2s2(a(t1,v(t1,t2)),t1 T2). eq vpc2s2(((v(t1,t2) = Cte), C) ; CS, T1 T2) = (vp(cte,t2) x ((v(t1,t2) = Cte), C)) ; vpc2s2(cs,t1 T2). eq vpc2s2(f,t1 T2) = F. vpc2s1 and vpc2s2 are unraveling functions which guide execution 34 / 40

43 Formalization of the transformation A formalization of the transformation has been defined (see pre-proceedings) The formalization allowed us to implement a prototype that, given a Datalog program, generates the Maude specification We have proved correctness and completeness of the transformation w.r.t. Datalog resolution (see the full version) 35 / 40

44 Experimental results One more thing... op vp : Term Term -> ConstraintSet [memo]. 36 / 40

45 Experimental results One more thing... op vp : Term Term -> ConstraintSet [memo]. a/2 vp0/2 vp/2 rule-based equational eq.+memo / 40

46 Experimental results Comparison w.r.t. other implementations 37 / 40

47 Conclusions and Future work Datalog for the analysis of OO programs A general transformation has been formalized and implemented equational-based not moded preserves computed answers correct and complete Future work Representing reflective features for the analysis (Maude capability) Using a more compact representation of the facts Considering other optimizations 38 / 40

48 Have a nice trip back home!!! Questions? For more information: mfeliu@dsic.upv.es