Download presentation

Presentation is loading. Please wait.

Published byTyler Bent Modified about 1 year ago

1
Determinacy Inference for Logic Programs Lunjin Lu @ Oakland University In collaboration with Andy King @ Kent University, UK

2
Context Project - “An Integrated Framework for Semantic Based Analysis of Logic Programs” Backward analyses Parametric analyses Context sensitive analyses Project – “US-UK Collaborative Research on Backward analyses for Logic Programs”

3
Determinacy sort(Xs,Ys) :- perm(Xs,Ys), ordered(Ys). perm(Xs,[Z|Zs]) :- select(Z,Xs,Ys),perm(Ys,Zs). perm([],[]). ordered([]). ordered([X]) :- number(X). ordered([X,Y|Ys]) :- X =< Y, ordered([Y|Ys]). select(X,[X|Xs],Xs). select(X,[Y|Ys],[Y|Zs]) :- select(X,Ys,Zs). A call is determinate if it has at most one computed answer and that answer is generated once. ?- sort([2,2],L). L=[2,2] ; No.

4
Goal Infer sufficient conditions under which a call is determinate Generalizing determinacy checking

5
Motivation Useful in language implementations Program development Tune performance Execute a determinate call under once; Detect possible bugs; Useful in program specialization Unfold when certain determinacy condition is satisfied. Determinacy is important in concurrent programming

6
Reversing a list (1) append(Xs, Ys, Zs) :- Xs = [], Ys = Zs. (2) append(Xs, Ys, Zs) :- Xs = [X|Xs1], Zs = [X|Zs1], append(Xs1, Ys, Zs1). (3) rev(Xs,Ys) :- Xs = [], Ys = []. (4) rev(Xs,Ys) :- Xs = [X|Xs1], Ys2 = [X], rev(Xs1, Ys1), append(Ys1, Ys2, Ys).

7
Overall structure of analysis Success Patterns wrt Mux Conditions wrt rigid’ Determinacy Conditions wrt rigid’ Success pattern wrt rigid’ Determinacy condition wrt rigid’

8
Computing success patterns wrt term abstraction Success Patterns wrt Mux Conditions wrt rigid’ Determinacy Conditions wrt rigid’ Success pattern wrt rigid’ Determinacy condition wrt rigid’

9
Abstracting terms A concrete term is mapped into an abstract term via a map . Example one: d k d 0 (t) = _ d k (X) = X d k (f(t 1,…,t n )) = f(d k-1 (t 1 ),…,d k-1 (t n )) Example two: list length norm

10
Abstracting primitive constraints Term abstraction induces an abstraction map, also denoted , that takes concrete constraints into abstract constraints. Examples (K=[X|L]) is (K=1+L) when = || || (L=[X,Y,Z,W]) is (L=[X,Y|_]) when = d 2. Operations on abstract constraints \/ /\ x

11
Abstracting program wrt a term abstraction (1) append(Xs, Ys, Zs) :- Xs = [], Ys = Zs. append(Xs, Ys, Zs) :- Xs≥0, Ys≥0, Zs≥0, Xs = 0, Ys = Zs. (2) append(Xs, Ys, Zs) :- Xs = [X|Xs1], Zs = [X|Zs1], append(Xs1, Ys, Zs1). append(Xs, Ys, Zs) :- Xs≥0, Ys≥0, Zs≥0, Xs1≥0, Zs1≥0, Xs = 1+Xs1, Zs = 1+Zs1, append(Xs1, Ys, Zs1).

12
Abstract program (1) append(Xs, Ys, Zs) :- Xs≥0, Ys≥0, Zs≥0, Xs = 0, Ys = Zs. (2) append(Xs, Ys, Zs) :- Xs≥0, Ys≥0, Zs≥0, Xs1≥0, Zs1≥0, Xs = 1+Xs1, Zs = 1+Zs1, append(Xs1, Ys, Zs1). (3) rev(Xs,Ys) :- Xs≥0, Ys≥0, Xs = 0, Ys = 0. (4) rev(Xs,Ys) :- Xs≥0, Ys≥0, Xs1≥0, Ys1≥0,Ys2≥0, Xs = 1+Xs1, Ys2 = 1, rev(Xs1, Ys1), append(Ys1, Ys2, Ys).

13
Computing success set of abstract program 1) append(Xs,Ys,Zs) :- Ys≥0,Zs≥0,Xs=0,Ys=Zs. 2) append(Xs, Ys, Zs) :- 1≥Xs,Xs≥0,Ys≥0,1≥Zs,Zs≥0,Zs=Xs+Ys 3) append(Xs,Ys,Zs) :- Xs≥0,Ys≥0,Zs=Xs+Ys 4) rev(Xs,Ys) :- Xs = 0, Ys = 0. 5) rev(Xs,Ys) :- 1≥Xs, Xs≥0, 1≥Ys, Ys≥0, Xs=Ys. 6) rev(Xs,Ys) :- Xs≥0, Xs=Ys.

14
Predicate level success patterns append(x1,x2,x3) :- (x1≥0) (x2≥0) (x1+x2=x3) rev(x1,x2) :- (x1≥0) (x1=x2)

15
Clause level success patterns (1) append(x1,x2,x3) :- (x1=0) (x2≥0) (x2=x3). (2) append(x1,x2,x3) :- (x1≥1) (x2≥0) (x1+x2=x3). (3) rev(x1,x2) :- (x1=0) (x2=0). (4) rev(x1,x2) :- (x1≥1) (x1=x2)

16
Synthesizing mutual exclusion conditions Success Patterns wrt Mux Conditions wrt rigid’ Determinacy Conditions wrt rigid’ Success pattern wrt rigid’ Determinacy condition wrt rigid’

17
Tracking rigidity Induced rigidity: term abstraction induces a rigidity predicate: rigid (t) (t)=((t)) for any e.g. rigid ([1,X]) = true e.g. rigid (X) = false Tracked rigidity: it may be simpler to track a rigidity predicate which implies the induced one. rigid’ (t) rigid (t) Domain of rigidity: Pos Rigidity dependence is expressed as positive Boolean functions such as (x1x2).

18
Galois connection rigid’ (f) = {Sub|Sub.assign()|=f} rigid’ () = {fPos| rigid (f)} assign()= {x rigid’ ( (x))|x dom()}

19
Mutual exclusion conditions A mutual exclusion condition for a predicate is a rigidity constraint under which at most one clause of the predicate may commence a successful derivation.

20
Mutual exclusion of two clauses Let C 1 and C 2 have success patterns p(x) :- c 1 p(x) :- c 2. If Y and X P (Y,p(x),C 1,C 2 ) then C 1 and C 2 are mutually exclusive where X P (Y,p(x),C 1,C 2 ) = ( -Y (c 1 ) -Y (c 2 ))

21
Mutual exclusion of two clauses (1) append(x1,x2,x3) :- (x1=0) (x2≥0) (x2=x3). c1 (2) append(x1,x2,x3) :- (x1≥1) (x2≥0) (x1+x2=x3). c2 -{x1} (c1) = (x1=0) -{x1} (c2) = (x1≥1) X P ({x1},p(x),C 1,C 2 ) = true -{x2,x3} (c1) = (x2≥0) (x2=x3) -{x2,x3} (c2) = (x2≥0) (x2

22
Synthesizing mutual exclusions X P (p(x)) = {Y|C 1,C 2 S. (C 1 C 2 X P (Y,p(x),C 1,C 2 ))} with S = the set of clauses defining p. X P (append(x1,x2,x3)) = x1 (x2x3) X P (rev(x1,x2)) = x1 x2

23
Synthesizing Determinacy Conditions Success Patterns wrt Mux Conditions wrt rigid’ Determinacy Conditions wrt rigid’ Success pattern wrt rigid’ Determinacy condition wrt rigid’

24
Synthesizing determinacy conditions Determinacy inference takes two steps: The first is a lfp that computes rigidity success patterns The second is a gfp that calculates rigidity call patterns that ensures determinacy. (objective) Both lfp and gfp works on rigidity abstraction of the original program.

25
Abstracting program wrt rigidity (1) append(Xs, Ys, Zs) :- Xs = [], Ys = Zs. append(Xs, Ys, Zs) :- Xs (Ys Zs). (2) append(Xs, Ys, Zs) :- Xs=[X|Xs1], Zs=[X|Zs1], append(Xs1,Ys,Zs1). append(Xs, Ys, Zs) :- (XsXs1)(ZsZs1), append(Xs1,Ys,Zs1).

26
Rigidity program (1) append(Xs,Ys,Zs) :- Xs (Ys Zs). (2) append(Xs,Ys,Zs) :- (Xs Xs1) (Zs Zs1), append(Xs1,Ys,Zs1). (3) rev(Xs,Ys) :- Xs Ys. (4) rev(Xs,Ys) :- (Xs Xs1) Ys2, rev(Xs1,Ys1), append(Ys1,Ys2,Ys).

27
Computing rigidity success patterns Rigidity success patterns of the original program is obtained by calculating success set of the rigidity program. append(x1,x2,x3) = x1 (x2 x3) rev(x1,x2) = x1 x2

28
Synthesizing determinacy conditions via backward analysis Success Patterns wrt Mux Conditions wrt rigid’ Determinacy Conditions wrt rigid’ Success pattern wrt rigid’ Determinacy condition wrt rigid’

29
Determinacy Conditions Determinacy conditions describes those queries that are determinate. There is one determinacy condition for each predicate. p(x) :- g states that (p(x)) has at most one computed answer whenever rigid’ (g).

30
Lower approximation of determinacy conditions If p(x) :- g is a determinacy condition and g’ |= g then p(x):-g’ is a determinacy condition. Determinacy conditions can thus be approximated from below without compromising correctness (but not necessarily from above)

31
Greatest fixpoint computation Iteration commences with I 0 ={ p(x):-true | p }. I k+1 is computed from I k by considering each clause in turn and calculating a (more) correct determinacy condition. Intially I k+1 = I k Strengthen I k+1

32
Propagating determinacy conditions backwards p(x) f 0, p 1 (x 1 ),…,p n (x n ). A correct condition g’ is obtained by Propagating the condition on each call e i = -x ((f 0 j*
{
"@context": "http://schema.org",
"@type": "ImageObject",
"contentUrl": "http://images.slideplayer.com/11/3276626/slides/slide_32.jpg",
"name": "Propagating determinacy conditions backwards p(x) f 0, p 1 (x 1 ),…,p n (x n ).",
"description": "A correct condition g’ is obtained by Propagating the condition on each call e i = -x ((f 0 j
*

33
Updating I k+1 I k+1 contains a determinacy condition p(x) :- g” and this is updated to p(x) :- g”/\g’ if g” | g’. Determinacy conditions becomes progressively stronger on each iteration. This process will converge onto the gfp.

34
Gfp computation for reverse I0: append(x1,x2,x3) :- true rev(x1,x2) :- true I1: append(x1,x2,x3) = x1 (x2 x3) rev(x1,x2) = x1 x2 I3=I2: append(x1,x2,x3) = x1 (x2 x3) rev(x1,x2) = x1

35
Small Benchmarks

36
Performance

37
Other work on backward analysis for logic programs Termination Inference (Codish & Genaim 2005) Backward analysis via program transformation (Gallagher 2003) Suspension (Genaim and King 2003) Groundness (King & Lu 2002) Type (Lu & King 2002) Pair sharing (Lu & King 2004) Set sharing (Li & Lu 2005) Equivalence of Forward and backward analysis (King & Lu 2003)

38
Conclusion Backwards analysis can infer sufficient conditions that ensures some properties are satisfied. Determinacy inference analysis is composed of off-the-self success pattern analysis, mutual exclusion synthesis and a backwards analysis. Initial experiments shows that it is practical and infers useful results.

39
Future work Independence of computation rule For improved precision Mutual exclusion condition More term abstractions

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google