Table Of Content

Underconsideration for publication in Theory and Practice of Logic Programming 1 Efficient Groundness Analysis in Prolog JACOB M. HOWE 2 0 Department of Computing, CityUniversity, London, EC1V OHB, UK 0 [email protected] 2 n ANDY KING a J Computing Laboratory, Universityof Kent, CT2 7NF, UK [email protected] 6 1 ] L Abstract P Boolean functions can be used to express the groundness of, and trace grounding depen- . s denciesbetween,programvariablesin(constraint)logicprograms.Inthispaper,avariety c of issues pertaining to the efficient Prolog implementation of groundness analysis are in- [ vestigated, focusing on the domain of definite Boolean functions, Def. The systematic 1 design of the representation of an abstract domain is discussed in relation to its impact v on the algorithmic complexity of the domain operations; the most frequently called op- 2 erations should be the most lightweight. This methodology is applied to Def, resulting 1 in a newrepresentation, together with new algorithms for its domain operations utilising 0 previouslyunexploitedproperties ofDef –forinstance, quadratic-timeentailmentcheck- 1 ing. The iteration strategy driving the analysis is also discussed and a simple, but very 0 effective, optimisation of induced magic is described. The analysis can be implemented 2 straightforwardly in Prolog and the use of a non-ground representation results in an ef- 0 ficient, scalable tool which does not require widening to be invoked, even on the largest / s benchmarks.An extensiveexperimental evaluation is given. c Keywords:Abstractinterpretation,groundnessanalysis,definiteBoolean functions, fix- : v point algorithms. i X r a 1 Introduction Groundness analysis is an important theme of logic programming and abstract in- terpretation.Groundnessanalysesidentify thoseprogramvariablesboundtoterms that contain no variables (ground terms). Groundness information is typically in- ferred by tracking dependencies among programvariables.These dependencies are commonly expressed as Boolean functions. For example, the function x∧(y ← z) describes a state in which x is definitely ground, and there exists a grounding dependency such that whenever z becomes ground then so does y. Groundness analyses usually track dependencies using either Pos, the class of positiveBooleanfunctions(Bagnara&Schachte,1999;Baker&Søndergaard,1993; Codish & Demoen, 1995; Fecht & Seidl, 1999;Marriott & Søndergaard, 1993;Van Hentenrycket al.,1995),orDef,theclassofdefinitepositivefunctions(Armstrong et al., 1998; Dart, 1991; Garc´ıa de la Banda et al., 1996; Genaim & Codish, 2001; 2 Jacob M. Howe and Andy King Howe & King, 2000). Pos is more expressive than Def, but studies have shown thatDef analyserscanbe fasterthancomparablePos analysers(Armstronget al., 1998)and, in practice,the loss of precisionfor goal-dependentgroundness analysis is usually small (Heaton et al., 2000). This paper is a development of (Howe & King, 2000) and is an exploration of the representation of Boolean functions for groundness analysis and the use of Prolog as a medium for implementing all the components of a groundness analyser. The rationale for this work was to develop an analyser with conceptually simple domain operations, with a small and simple (thus easily maintained) Prolog implementation based on a meta-interpreter and with performance comparable to thatofBDD-basedanalysers.Moreover,sincePrologiswellsuitedtosymbolicma- nipulation, it should provide an appropriate medium for implementing a symbolic analysis,suchas groundnessanalysis.Any analysisthat canbe quickly prototyped in Prolog is particularly attractive. The main drawback of this approach has tra- ditionally been performance. The efficiency of an analyser can be guaranteed by including a widening (the controlled exchange of precision for scalability). How- ever,a successful analyser should fire widening infrequently to maximise precision. The efficiency of groundness analysis depends critically on the way dependencies are represented. Representation has two aspects: the theoretical representation (BDDs, Blake Canonical Form, etc.) of the Boolean functions and the data- structures of the implementation language that are used to support this representation. The theoretical representation determines the complexity of the domain operations,but the implementationrequiresthe specific data-structuresusedto be amenable to efficient implementation in the chosen language. That is, the implementation can push the complexity into a higher class, or introduce a prohibitive constant factor in the complexity function. This paper considers how a representation should be chosen for the intended application (groundness analysis) by bal- ancing the size of the representation (and its impact) with the complexity of the abstractoperationsandthefrequencywithwhichtheseoperationsareapplied.The paper also explains how Prolog can be used to implement a particularly efficient Def-basedgroundnessanalysis.The orthogonalissue ofthe iterationstrategyused to drive the analysis is also considered. Specifically, this paper makes the following contributions: • A representation of Def formulae as non-canonical conjunctions of clauses is chosenby followingamethodologythatadvocates:1)ensuringthatthe most commonly called domain operations are the most lightweight; 2) that the abstractions that arise in practice should be dense; 3) that, where possible, expensive domain operations should be filtered by lightweight special cases. • A fast Prolog implementation of Def-based groundness analysis is given founded on the methodology above, using a compact, factorised representation. • Representing Boolean functions as non-ground formulae allows succinct implementation of domain operations. In particular a constant-time meet is Efficient Groundness Analysis in Prolog 3 achieved using difference lists and a quadratic-time entailment check is built using delay declarations. • A new join algorithm is presented which does not require formulae to be preprocessed into a canonical form. • The use of entailment checking as a filter for join is described, as is the use of a filtered projection. • Various iteration strategies are systematically compared and it is suggested (at least for groundness analysis) that good performance can be obtained by a surprisingly simple analysis framework. • An extensive experimental evaluation of groundness analysis using a variety of combinations of domains, representations and iteration strategies is given. • As a whole, the work presented in this paper strongly suggests that the implementor can produce a robust, fast, precise, scalable analyser for goal- dependentgroundnessanalysiswritteninProlog.Theanalyserpresenteddoes notrequirewideningtobeappliedforanyprogramsinthebenchmarkssuite. The rest of the paper is structured as follows: Section 2 details the necessary preliminaries.Section3reviewsthemethodsusedforchoosingtherepresentationof Def.ItgoesontodescribevariousrepresentationsofDef inrelationtoafrequency analysisoftheoperations;anon-canonicalrepresentationasconjunctionsofclauses isdetailed.Section4describesanewjoinalgorithm,alongwithfilteringtechniques for join and for projection. Section 5 discusses a variety of iteration strategies for driving an analysis. Section 6 gives an experimental evaluation of the various combinations of domain representations and iteration strategy for Def (and also for the domains EPos and Pos). Section 7 surveys related work and Section 8 concludes. 2 Preliminaries A Boolean function is a function f : Booln → Bool where n ≥ 0. Let V denote a denumerable universe of variables. A Boolean function can be represented by a propositionalformulaoverX ⊆V where|X|=n.Thesetofpropositionalformulae overX isdenotedbyBool .Throughoutthispaper,Booleanfunctions andpropo- X sitionalformulae are used interchangeablywithout worryingabout the distinction. The convention of identifying a truth assignment with the set of variables M that it maps to true is also followed. Specifically, a map ψ (M) : ℘(X) → Bool is X X introduceddefinedby:ψ (M)=(∧M)∧¬(∨(X\M)). Inaddition,the formula∧Y X is often abbreviated as Y. Definition 1 The (bijective) map model : Bool → ℘(℘(X)) is defined by: model (f) = X X X {M ⊆X |ψ (M)|=f}. X Example 1 If X = {x,y}, then the function {htrue,truei 7→ true, htrue,falsei 7→ false, hfalse,truei7→false, hfalse,falsei7→false} can be represented by the formula x∧y. Also, model (x∧y) = {{x,y}} and model (x∨y) = {{x},{y}, {x,y}}. X X 4 Jacob M. Howe and Andy King Thefocusofthispaperisontheuseofsub-classesofBool intracinggroundness X dependencies. These sub-classes are defined below: Definition 2 A function f is positive iff X ∈ model (f). Pos is the set of positive Boolean X X functions over X. A function f is definite iff M ∩M′ ∈model (f) for all M,M′ ∈ X model (f).Def isthesetofpositivefunctionsoverX thataredefinite.Afunction X X f is GE iff f is definite positive and, where Y = ∩model (f), for all M,M′ ∈ X model (f), Y ∪(M\M′)∈model (f). EPos is the set of GE functions overX. X X X Note that EPos ⊆Def ⊆Pos . One useful representational property of Def X X X X is thateachf ∈Def canbe describedasa conjunctionof definite (propositional) X clauses, that is, f = ∧n (y ← ∧Y ) (Dart, 1991). Note that the y s are not i=1 i i i necessarily distinct. Finally, Def abbreviates Def . Also notice that EPos = V X {∧F |F ⊆X ∪E }, where E ={x↔y |x,y ∈X}. X X Example 2 Suppose X = {x,y,z} and consider the following table, which states, for some Boolean functions, whether they are in EPos , Def or Pos and also gives X X X model . X f EPos Def Pos model (f) X X X X false ∅ x∧y • • • { {x,y}, {x,y,z}} x∨y • { {x},{y}, {x,y},{x,z},{y,z},{x,y,z}} x←y • • {∅,{x}, {z},{x,y},{x,z}, {x,y,z}} x∨(y ←z) • {∅,{x},{y}, {x,y},{x,z},{y,z},{x,y,z}} true • • • {∅,{x},{y},{z},{x,y},{x,z},{y,z},{x,y,z}} Note, in particular, that x∨y is not in Def (since its set of models is not closed X under intersection) and that false is neither in EPos , nor Pos nor Def . X X X Defining f ∨˙f = ∧{f ∈ Def | f |= f ∧f |= f}, the 4-tuple hDef ,|=,∧,∨˙i is 1 2 X 1 2 X a finite lattice (Armstrong et al., 1998), where true is the top element and ∧X is thebottomelement.Existentialquantificationis definedbySchröder’sElimination Principle, that is, ∃x.f = f[x 7→ true]∨˙f[x 7→ false]. Note that if f ∈ Def then X ∃x.f ∈Def (Armstrong et al., 1998). X Example 3 If X = {x,y} then x∨˙(x ↔ y) = ∧{(x ← y),true} = (x ← y), as can be seen in the Hasse diagram for dyadic Def (Fig. 1). Note also that x∨˙y = ∧{true} = X true6=(x∨y). The set of (free) variables in a syntactic object o is denoted by var(o). Also, ∃{y ,...,y }.f (project out) abbreviates ∃y .....∃y .f and ∃Y.f (project onto) 1 n 1 n denotes∃var(f)\Y.f.Letρ ,ρ befixedrenamingssuchthatX∩ρ (X)=X∩ρ (X) 1 2 1 2 = ρ (X)∩ρ (X)=∅. Renamings are bijective and therefore invertible. 1 2 Downward closure, ↓, relates Pos and Def and is useful when tracking sharing with Boolean functions (Codish et al., 1999). It is defined by ↓f =model−1({∩S | X Efficient Groundness Analysis in Prolog 5 true true true # c # c (cid:0)(cid:0) @@ # c # c (cid:0) @ x←y y←x x←y x∨y y←x x x↔y y @@ (cid:0)(cid:0) ##@@ (cid:0)(cid:0)cc @@ (cid:0)(cid:0) x x↔y y x x↔y y c # c # @ (cid:0) c # c # x∧y x∧y x∧y EPos Def Pos {x,y} {x,y} {x,y} Fig. 1. Hasse Diagrams ∅ ⊂ S ⊆ model (f)}). Note that ↓f has the useful computational property that X ↓f = ∧{f′ ∈ Def |f |= f′} if f ∈ Pos . That is, ↓ takes a Pos formula to its X X bestDef approximation.Finally,foranyf ∈Bool ,coneg(f)=model−1({X\M | X X M ∈model (f)}) (Codish et al., 1999). X The following pieces of logic programming terminology will also be needed. Let T denote the set of terms constructed from V and a set of function symbols F. Π is a set of predicate symbols. An equation e is a pair (s = t) where s,t ∈ T. A substitution is a (total) map θ :V →T such that {v ∈ V |θ(v) 6= v} is finite. Let Sub denote the set of substitutions and let E denote a finite set of equations. Let θ(t) denote the term obtained by simultaneously replacing each occurrence of v in t with θ(v), and let θ(E) = {θ(s)=θ(t)|(s=t)∈E}. Compositionof substitutions induces the (more generalthan) relation≤ defined by: θ ≤ ψ if there exists δ ∈ Sub such that ψ = δ◦θ. More general than lifts to terms by s ≤ t iff there exists δ ∈ Sub such that δ(s) = t. The set of unifiers of E, unify(E), is defined by: unify(E) = {θ ∈Sub|∀(s =t)∈E.θ(s) = θ(t)} and the setof most generalunifiers,mgu(E), is defined by: mgu(E)={θ ∈unify(E)| ∀ψ ∈ unify(E).θ ≤ ψ}. Finally, the set of generalisations of two terms is defined by: gen(t ,t )={t∈T|t≤t ∧t≤t } and the set of most specific generalisations 1 2 1 2 is defined by: msg(t ,t )={t∈gen(t ,t )|∀s∈gen(t ,t ).s≤t}. 1 2 1 2 1 2 3 Choosing a Representation for Def 3.1 Review of Design Methods The efficiency of an analyser depends critically on the algorithmic complexities of itsabstractdomainoperations.Theseinturnaredeterminedbytherepresentation of the abstract domain. The representation also determines the size of the inputs to the domain operations, as well as impacting on memory usage. Because of this, the choice of representation is fundamental to the efficiency of an analyser and is therefore of great importance. The remainder of this subsection reviews three factors which should help the implementor arrive at a suitable representation and suggest where domain operations might be refined. 3.1.1 Frequency Analysis of the Domain Operations There are typically many degrees of freedom in designing an analyser, even for a givendomain. Furthermore,work can often be shifted from one abstract operation 6 Jacob M. Howe and Andy King into another. For example, Booleanformulae can be representedin either conjunc- tive normal form (CNF) or disjunctive normal form (DNF). In CNF, conjunction is constant-time and disjunction is quadratic-time, whereas in DNF, conjunction is quadratic-time and disjunction is constant-time. Ideally, an analysis should be designed so that the most frequently used operations have low complexity and are therefore fast. This motivates the following approach: 1. Prototype an analyser for the given domain. 2. Instrumenttheanalyserto countthe numberoftimes eachdomainoperation is invoked. 3. Generate these counts for a number of programs (the bigger the better). 4. Choosearepresentationwhichgivesagoodmatchbetweenthefrequencyand the complexity of the domain operations. Becausethefrequencyanalysisissolelyconcernedwithgeneratedinstructioncounts, the efficiency of the prototype analyser is not a significant issue. The objective is to choose a representation for which the most frequently occurring operations are also the fastest. However, this criterion needs to be balanced with others, such as the density of the representation. 3.1.2 Density of the Domain Representation The complexity of the domain operations is a function of the size of their inputs. Large inputs nullify the value of good complexities, hence a balance between size of representation and complexity of domain operations is needed. The following factors impact on this relationship: 1. The abstractions which typically arise should be represented compactly. 2. Afactorisedrepresentationwithanexpressive,highdensity,lowmaintenance component is attractive. 3. Maintainingthe representation(for example,asa canonicalform)shouldnot come with a high overhead. 4. Therepresentationshouldfitwithmachineryavailableintheimplementation language. A domain is said to be factorised if its information is represented as a product of subdomains. It may not always be possible to fulfill all these requirements. More- over, these factors needs to balanced with others, such as their impact on the complexities of frequently called domain operations. 3.1.3 Filtering the Domain Operations In many analyses it is inevitable that some domain operations will have high complexity. However, it is sometimes possible to reduce the impact of this by filtering the operation, as follows: 1. For a high complexity domain operation identify special cases where the operation can be calculated using a lower complexity algorithm. Efficient Groundness Analysis in Prolog 7 2. Instrumenttheanalysertoquantifyhowoftenthelowercomplexityalgorithm can be applied. 3. Ifitappearsthatthespecialcaseoccursfrequently,thenimplementthespecial case and measure the impact on performance. The bottom line is that the cost of detecting the special case should not outweigh the benefit of applying the specialised domain algorithm. 3.2 Frequency Analysis for Def In order to balance the frequency of abstract operations against their cost, an existing Def analyser was instrumented to count the number of calls to the various abstract operations. The analyser used for this is based on Armstrong and Schachte’s BDD-based domain operations for Pos and Sharing (Armstrong et al., 1998; Schachte, 1999). Using the domain operations provided for these domains, a Def analyser can easily be derived. This analyser is coded in Prolog as a simple meta-interpreterthatusesinducedmagic-sets(Codish,1999a)andeagerevaluation (Wunderwald, 1995)to perform goal-dependent bottom-up evaluation and call the C implemented domain operations. Induced magic is a refinement of the magic set transformation, avoiding much of the re-computation that arises because of the repetition of literals in the bodies of magicked clauses (Codish, 1999a). Eager evaluation (Wunderwald, 1995) is a fixpointiterationstrategywhichproceeds as follows:wheneveran atomis updated with a new (weaker) abstraction, a recursive procedure is invoked to ensure that everyclausethathasthatatominitsbodyisre-evaluated.Anadvantageofinduced magic is that it can be coded straightforwardlyin Prolog. Table 1 gives a breakdown of the relative frequency (in percentages) of the calls to eachabstractoperationin the BDD-basedDef analysisof eightlargeprograms. Meet, join, equiv, project and rename are the obvious Boolean operations. Join (diff) is those calls to a join f ∨˙f where f ∨˙f 6= f and f ∨˙f 6= f (this will 1 2 1 2 1 1 2 2 be useful in section 4). Total details the total number of calls to these domain operations. file rubik chat parser sim v5-2 peval aircraft essln chat 80 aqua c meet 30.9 31.6 35.9 32.5 28.5 42.7 34.0 34.2 join 10.4 10.4 8.8 9.7 11.1 8.4 10.2 10.5 join (diff) 1.1 1.7 0.0 2.9 0.1 0.9 1.5 1.6 equiv 10.4 10.4 8.8 9.7 11.1 8.4 10.2 10.5 project 12.6 12.5 13.0 12.5 13.0 10.5 12.1 11.7 rename 34.7 33.4 33.6 32.8 36.2 29.2 32.0 31.6 total 14336 14124 5943 6275 24758 19051 45444 280485 Table 1. Frequency Analysis: BDD-based DefAnalyser (Figures in %) Observethatmeetandrenamearecalledmostfrequently.Join,equivandproject arecalledwithasimilarfrequency,butlessfrequentlythanmeetandrename.Note that it is rare for a join to differ from both its arguments. Join is always followed 8 Jacob M. Howe and Andy King by an equivalence and this explains why the join and equiv rows coincide. Since meet and rename are the most frequently called operations,ideally they should be the most lightweight. As join, equiv and project are called less frequently, a higher algorithmic complexity is more acceptable for these operations. 3.3 Representations of Def ThissectionreviewsanumberofrepresentationsofDef intermsofthealgorithmic complexity of the domain operations. The representations considered are reduced ordered binary decision diagrams, dual Blake canonical form (specialised for Def (Armstrong et al., 1998)) and a non-canonical definite propositional clause representation. ROBDD A reduced ordered binary decision diagram (ROBDD) is a rooted, directed acyclic graph. Terminal nodes are labelled 0 or 1 and non-terminal nodes are labelled by a variable and have edges directed towards two child nodes. ROBDDs have the additional properties that: 1) each path from the root to a node respects a given ordering on the variables, 2) a variable cannot occur multiply in a path, 3) no subBDD occurs multiply. ROBDDs give a unique representation for every Boolean function (up to variable ordering). DBCF Dual Blake Canonical Form (DBCF) represents Def functions as conjunctions of definite (propositional) clauses (Armstrong et al., 1998; Dart, 1991; Garc´ıa de la Banda et al., 1996) maintained in a canonical (orthogonal) form that makes explicit transitive variable dependencies and uses a reduced mono- tonic body form. For example, the function (x←y)∧(y ←z) is represented as (x ← (y∨z))∧(y ← z). Again, DBCF gives a unique representation for every Def function (up to variable ordering). Non-canonical Thenon-canonicalclausalrepresentationexpressesDef functionsas conjunctions of propositional clauses, but does not maintain a canonical form. This does not give a unique representation. Table 2 details the complexities of the domain operations for Def for the three representations. Notice that the complexities are in terms of the size of the repre- sentationsandthattheseareallpotentiallyexponentialinthenumberofvariables. Also,observethatsinceDBCFmaintainstransitivedependencies,whereasthenon- canonical representation does not, the DBCF of a Def function has the potential to be considerably larger than the non-canonical representation. As ROBDDs are representedinafundamentallydifferentway,theirsizecannotbedirectlycompared with clausal representations. Both ROBDDs and DBCF are maintained in a canonical form. Canonical forms reduce the cost of operations such as equivalence checking and projection by fac- toring out search. However, canonical forms need to be maintained and this main- tenancehas anassociatedcostinmeetandjoin.Thatis,ROBDDsandDBCFbuy lowcomplexityequivalencecheckingandprojectionatthecostofhighercomplexity meet and join. Efficient Groundness Analysis in Prolog 9 Representation meet join equiv rename project ROBDD O(N2) O(N2) O(1) O(N2) O(N2) DBCF O(N4) O(22N) O(N) O(N) O(N) Non-canonical O(1) O(22N) O(N2) O(N) O(2N) Table 2. Complexity of Def Operations for Various Representations (where N is the size of the representation – number of nodes/variable occurrences). As discussed in the previously, the lowest cost operations should be those that are most frequently called. Table 1 shows that for Def based groundness analysis, meet and renaming are called significantly more often than the other operations. Hence these should be the most lightweight. This suggests that the non-canonical representation is better suited to Def-based goal-dependent groundness analysis than ROBDDs and DBCF. The following sections will detail the non-canonical representation. 3.4 GEP Representation This section outlines how the non-canonical representation is used in an analysis for call and answer patterns. Implementing call and answer patterns with a non- ground representationenables the non-canonicalrepresentation to be factorised at little overhead. A call (or answer) pattern is a pair ha,fi where a is an atom and f ∈ Def. Normallythe argumentsof a are distinct variables.The formula f is a conjunction (list) of propositional clauses. In a non-ground representation the arguments of a canbe instantiated and aliasedto express simple dependency information (Heaton etal.,2000).Forexample,ifa=p(x ,...,x ),thentheatomp(x ,true,x ,x ,true) 1 5 1 1 4 represents a coupled with the formula (x ↔ x ) ∧ x ∧ x . This enables the 1 3 2 5 abstraction hp(x ,...,x ),(x ↔ x ) ∧ x ∧ x ∧ (x → x )i to be collapsed to 1 5 1 3 2 5 4 1 hp(x ,true,x ,x ,true),x → x i. This encoding leads to a more compact repre- 1 1 4 4 1 sentationandissimilartotheGERfactorisationofROBDDsproposedbyBagnara and Schachte (Bagnara & Schachte, 1999). The representation of call and answer patternsdescribedaboveiscalledGEP(groundness,equivalencesandpropositional clauses)wheretheatomcapturesthefirsttwopropertiesandtheformulathelatter. Formally,letGEP ={hp(t ,...,t ),fi|p∈Π,t ∈V ∪{true},f ∈(Def\GE)∪ 1 n i {true}}. Define |= by hp(~a ),f i |= hp(~a ),f i iff ∃~x.((~a ↔ ~x)∧f ) |= ∃~x.((~a ↔ 1 1 2 2 1 1 2 ~x)∧f )andvar(~x)∩(var(~a )∪var(~a )∪var(f )∪var(f ))=∅.ThenhGEP,|=iisa 2 1 2 1 2 preorder.The preorder induces the equivalence relation ≡ defined by hp(~a ),f i≡ 1 1 hp(~a ),f i iff hp(~a ),f i |= hp(~a ),f i and hp(~a ),f i |= hp(~a ),f i. Let GEP 2 2 1 1 2 2 2 2 1 1 ≡ denotes GEP quotiented by the equivalence. Define ∧ :GEP ×GEP →GEP ≡ ≡ ≡ by [ha ,f i] ∧[ha ,f i] =[hθ(a ),θ(f )∧θ(f )i] , where θ ∈mgu(a ,a ). Then 1 1 ≡ 2 2 ≡ 1 1 2 ≡ 1 2 hGEP ,|=,∧i is a finite lattice. ≡ The meet of the pairshp(~a ),f i andhp(~a ),f i can be computed by unifying a 1 1 2 2 1 and a and concatenating f and f . The unification is nearly linear in the arity of 2 1 2 p(usingrationaltreeunification(Jaffar,1984))andconcatenationisconstant-time (using difference lists). Since the arguments~a and~a are necessarily distinct, the 1 2 10 Jacob M. Howe and Andy King analyser would unify ~a and ~a even in a non-factorised representation, hence no 1 2 extra overhead is incurred. The objects that require renaming are formulae and call (answer) pattern GEP pairs. If a dynamic database is used to store the pairs (Hermenegildo et al., 1992), then renaming is automatically applied each time a pair is looked-up in the database. Formulae can be renamed with a single call to the Prolog builtin copy term. Renaming is therefore linear. TheGEPfactorisationdefinedaboveistrue,thatis,alltheGEdependenciesare factoredintotheatom.AnalternativedefinitionwouldbeGEP ={hp(t ,...,t ),fi| 1 n p∈Π,t ∈V∪{true},f ∈Def}.Herethefactorisationisnotnecessarilytrue,inthe i sensethatGEdependenciesmayexistsinthePcomponent,e.g.hp(x,x,true),truei mayalsobecorrectlyexpressedashp(u,v,w),(u↔v)∧wi.Anon-truefactorisation may be advantageous when it comes to implementing the domain and from hence- forth GEP will refer to the non-true factorisation version unless stated otherwise. ThePcomponentmaycontainredundant(indeed,repeated)clausesandthesemay impact adversely on performance. In order to avert unconstrained growth of P, a redundancy removal step may be applied to P at a convenient point (via entail- mentchecking).Sincethenon-canonicalformulaedonotneedtobemaintainedina canonicalformandsincethefactorisationisnotnecessarilytrue,therepresentation is flexible in that it can be maintained on demand, that is, the implementor can choosetomovedependenciesfromPintoGEatexactlythosepointsintheanalysis where true factorisation gives a performance benefit. 4 Filtering and Algorithms The non-canonical representation has high cost join and projection algorithms. Therefore it is sensible to focus on improving the efficiency of these operations. This is accomplished through filtering following the strategy described in section 3.1.This section presents a new approachto calculating join and describes the use of entailment checking as a filter in the join algorithm. It also describes a filtering method for projection. 4.1 Join This section describes a new approach to calculating join, inspired by a convex hull algorithm for polyhedra used in disjunctive constraint solving (De Backer & Beringer, 1993). The new join algorithm is first described for formulae and is then lifted to the GEP representation. 4.1.1 Join for Formulae Calculating join in Def is not straightforward. It is not enough to take the join each possible pair of clauses and conjoin them – transitive dependencies also need tobetakenintoaccount.Thisisillustratedbythefollowingexample(adaptedfrom (Armstrong et al., 1998)).