The use of abstraction has been largely informal. As a consequence,  it has often been difficult to see how or why a particular  abstraction works. This paper attempts to help correct this trend  by presenting a formal theory of abstraction. We use this theory to  characterise the different types of abstraction that can be built; the  different classes of abstractions we identify capture the majority of  abstractions of which we are aware. We end by proposing a method  for automatically building one very common type of abstraction, that  used in Abstrips; our proposal is motivated by consideration of the  various formal properties that such a method should possess

Bundy, Alan

Giunchiglia, F.

Walsh, T.

English

The use of abstraction has been largely informal. As a consequence, it has often been difficult to see how or why a particular abstraction works. This paper attempts to help correct this trend by presenting a formal theory of abstraction. We use this theory to characterise the different types of abstraction that can be built; the different classes of abstractions we identify capture the majority of abstractions of which we are aware. We end by proposing a method for automatically building one very common type of abstraction, that used in Abstrips; our proposal is motivated by consideration of the various formal properties that such a method should possess

Edinburgh Research Explorer

     Edinburgh Research Explorer                                      Building AbstractionsCitation for published version:Bundy, A, Giunchiglia, F & Walsh, T 1990, 'Building Abstractions' Automatic Generation of Approximationsand Abstactions, vol na, no. na, pp. 1-10.Link:Link to publication record in Edinburgh Research ExplorerDocument Version:Author final version (often known as postprint)Published In:Automatic Generation of Approximations and AbstactionsGeneral rightsCopyright for the publications made accessible via the Edinburgh Research Explorer is retained by the author(s)and / or other copyright owners and it is a condition of accessing these publications that users recognise andabide by the legal requirements associated with these rights.Take down policyThe University of Edinburgh has made every reasonable effort to ensure that Edinburgh Research Explorercontent complies with UK legislation. If you believe that the public display of this file breaches copyright pleasecontact openaccess@ed.ac.uk providing details, and we will remove access to the work immediately andinvestigate your claim.Download date: 20. Feb. 2015Building abstractionsAlan BundyDept. of Artificial Intelligence, EdinburghFausto GiunchigliaIRST, TrentoToby WalshDept. of Artificial Intelligence, EdinburghAbstractThe use of abstraction has been largely informal. As a conse-quence, it has often been difficult to see how or why a particularabstraction works. This paper attempts to help correct this trendby presenting a formal theory of abstraction. We use this theory tocharacterise the different types of abstraction that can be built; thedifferent classes of abstractions we identify capture the majority ofabstractions of which we are aware. We end by proposing a methodfor automatically building one very common type of abstraction, thatused in Abstrips; our proposal is motivated by consideration of thevarious formal properties that such a method should possess.1 IntroductionWe see abstraction as the mapping of one representation of a problem, the“ground” representation onto a new representation, the “abstract” represen-tation. The overall aim might be to improve the efficiency of reasoning; forexample, an abstract solution might be used to guide the solution to theground problem. Or it might be to increase the number of facts derivable;for example, a learning system might construct abstract versions of rules thatare learnt so that they can fire in new situations.0Unfortunately the use of abstraction has in general lacked sound and the-oretical foundations. This has led to many problems. For example, abstrac-tions have in general been constructed by hand; without a comprehensivetheory of abstraction, it is very difficult to determine automatically what toabstract for a given problem representation. Additionally there has been alack of understanding of why abstraction works, of the different ways ab-straction can be used, and of the relationships between the different typesof abstractions. These factors have greatly restricted the usefulness of ab-straction. The aim of this paper is: (1) to describe a theory of abstraction;(2) to use this theory to identify the different types of abstractions that canbe built; (3) to look in detail at how we can automatically build one (ratherfamous) type of abstraction.2 A theory of abstractionWe begin by outlining the formal framework presented in [?, ?]. Since we seeabstraction as a mapping between problem representations, we need a formalmethod for describing problem representations. One very general method iswith a formal system, Σ.Definition 1 (Formal System) : A formal system, Σ is apair, 〈Λ, TH(Σ)〉 where Λ is the language, TH(Σ) is the set oftheorems and TH(Σ) ⊂ Λ.The language, Λ provides the basic tools for writing down formulae. Usu-ally the language is defined by an alphabet, the set of (well formed) termsand the set of well formed formulae (wffs from now on). To simplify matters,we just take it to be a set of well formed formulae (leaving the alphabet, andthe set of well formed terms implicit). The set of theorems, TH(Σ) is theset of statements which are taken to be true. Thus TH(Σ) ⊂ Λ. In fact,we nearly always deal with axiomatic formal system, in which the theoremsare given by the transitive closure of a set of inference rules applied to a setof axioms.Since we view abstraction as a mapping between problem representations,we formally define an abstraction as a mapping from one formal system toanother, more abstract one:1Definition 2 (Abstraction) : An abstraction, f : Σ1 ⇒ Σ2is a pair of formal systems 〈Σ1,Σ2〉 with languages Λ1 and Λ2respectively, and an effective total function f : Λ1 → Λ2.Following historical convention, Σ1 is called the ground space and Σ2the abstract space. f , the function that maps wffs from Λ1 onto wffsin Λ2 is called the mapping function. This is a very general definitionof abstraction. Indeed it gives no guarantee that the abstraction is useful;what is true in the abstract space may bear no relationship to what is truein the ground space. An interesting and general restriction is therefore toabstractions that preserve provability in some way. In [?] we identified thevery important class of truthful abstractions for which any theorem of theground space is mapped onto a theorem of the abstract space.Definition 3 (Truthfulness) An abstraction, f : Σ1 ⇒ Σ2 istruthful iff, if ϕ ∈ TH(Σ1) then f(ϕ) ∈ TH(Σ2).Truthful abstractions are complete (the abstraction of any ground theo-rem is a theorem in the abstract space) but may not be correct (there maybe theorems in the abstract space which do not correspond to any theorem inthe ground space). A large number of abstractions proposed in the past aretruthful. For example, Hobbs’ granularity [?] can be described as a truthfulabstraction. In [?], we also considered the dual class of abstractions which arecorrect but not complete. In any sufficiently interesting theory, undecidabil-ity ensures that is not possible to have both completeness and correctness.Preserving provability is actually only a very weak property to demand – in[?] we also consider stronger properties like the preservation of the structureof proofs; abstract proofs can then be used to guide the search for groundproofs. Of course, the preservation of the structure of proofs usually entailssome type of preservation of provability. What is perhaps most importantis that we are able to prove some very interesting results just from the weakassumption that provability is preserved.3 Types of abstractionsMany different (truthful) abstractions have been proposed. Unfortunately,there have been few attempts at classifying the different types of abstractions.2A first step therefore in building abstractions automatically is to identifythe different ways we can abstract a problem representation. This sectionattempts to provide such a classification.With axiomatic formal systems, the abstract space often uses the sameinference rules (or a subset of them) as the ground space. This makes im-plementation easier, and allows for the use of hierarchies of abstractions.Additionally, the axioms of the abstract space are frequently given by apply-ing the mapping function to the axioms of the ground space. From now onwe will restrict our attention to such abstractions. We can therefore classifyabstractions simply by the properties of their mapping function.An important class of abstractions – and one that formalises nearly allprevious work in abstraction – is the class of atomic abstractions; that is,abstractions which map the atomic formulae, and not their logical structure.For example, f(p & q) is often the same as f(p) & f(q). Note that we haveoverloaded the symbol “&” since it is used to represent both conjunction inthe ground and in the abstract languages. Strictly speaking we should dis-tinguish between these two uses. However, since it is given the same meaningin both the ground and the abstract spaces, we introduce no ambiguity bythis overloading.Abstracting the logic is very dangerous as the consistency of a formalsystem is usually very finely balanced. In general, the logic itself is wellbehaved and it is the theory that needs to be simplified. Additionally, anabstraction cannot change the logical structure of formulae too radically ifit is to preserve provability (or, more strongly, the structure of proofs). [?]provides a longer discussion of these issues.The recursive definition of atomic formulae suggests a systematic classi-fication of atomic abstractions:1. term abstractions where we map the terms. Further subdivided into:• domain abstractions where we map the constants together;• function abstractions where we map the function names to-gether, or reduce their arity;2. predicate abstractions where we map the predicate names together,reduce their arity or (a special case) map the whole atomic formulaonto '/⊥.3This classification describes all atomic abstractions that can be decom-posed into mappings on the individual parts of the atomic formulae. Allthese different types of abstractions can be found in the literature. Most,in fact, can be found in the work of Plaisted [?, ?]. Both Hobbs [?] andImielinski [?] have proposed domain abstractions. Plaisted [?, ?] has usedfunction abstractions on some interesting problems. Tenenberg [?] has lookedat predicate abstractions which collapse predicate names together. And theabstraction used in Abstrips [?] can be seen as predicate abstraction thatmaps certain preconditions onto '.This section has identified some of the major types of abstraction. Eachmaps a different part of the atomic formula (eg. the predicate names, theconstants, ...) or alternatively the whole atomic formula. It will depend onthe problem, and the choice of representation exactly what it is worthwhilemapping together. The next section considers this problem in detail for oneparticular class of abstraction.4 Building Abstrips abstractionsAn important class of atomic abstractions is the class of predicate abstrac-tions which map some of the atomic formulae onto '. Abstrips [?] usedsuch abstractions to simplify its Strips-like planning domain. This sectionexplores how to build such abstractions automatically.The problem domain is determined by a set of operators. We assume eachhas a set of preconditions, and a conclusion described by an implication in asituation calculus. Abstrips constructed a hierarchy of abstraction levels bymapping preconditions onto true, ' according to their criticality; this is ameasure of how difficult the precondition is to achieve. Those preconditionswhich it is impossible to change are given the highest criticality. Thosepreconditions which it is very hard to change are given the next highestcriticality. And those preconditions which it is very easy to change are giventhe lowest criticality. This notion of criticality is, in fact, very general andneed not be restricted just to preconditions – for instance, when using adomain abstraction, we can define the criticality of the name of a constant.Abstrips constructed plans in a hierarchy of abstract spaces, each of whichignored the preconditions below a certain criticality. We propose a methodto calculate such criticalities automatically which improves upon the semi-4automatic method used in Abstrips. As in the original method used by Ab-strips, the criticality of a precondition is independent of its arguments; thatis, it is a measure of how difficult on average it is to achieve a precondition.To this end, we ignore the arguments to the preconditions.We envisage an iterative process, whereby we assign the preconditionssome default starting value and then by a series of iterations calculate theircriticality. We shall represent by C(Ops, p, n) the criticality of the predicate,p at the n-th iteration given a set of operators, Ops. Note that, unlike Ab-strips, we assign a criticality to every predicate, irrespective of whether itappears as a precondition to an operator or not. We will not be particu-larly interested in the absolute values C(Ops, p, n) returns, just their relativeordering. We motivate the choice of our criticality assignment function byidentifying some desirable properties it should possess. The first is that theassignment function should converge to an unique answer.Property 1 (Convergence)limn→∞ C(Ops, p, n) = apWe might sometimes allow ap to be infinite (in which case, we also wantto be able to know that the criticality can be calculated with arbitrary pre-cision). Second, we would like the assignment function to be fair. Initially,we have no information to distinguish between the different predicates. Theassignment function should not therefore discriminate between them. Everypredicate should be given a uniform starting value, a0.Property 2 (Fairness)C(Ops, p, 0) = a0Third, we want the function to be monotonic. Given a set of operators,if we add another operator with conclusion, p then as p is easier to satisfy(we have another way of proving it) the criticality of p should go down (or,at least, stay the same). And if we add a precondition, q to an operator withconclusion p then as p is more difficult to satisfy (we have to prove anotherprecondition) the criticality of p should go up (or, at least, stay the same).Property 3 (Monotonicity)C(Ops ∪ {q → p}, p, n) ≤ C(Ops, p, n)C(Ops ∪ {(q&r)→ p}, p, n) ≥ C(Ops ∪ {r → p}, p, n)5There are other properties, like selectivity (the assignment functionshould return a range of values), which are less precise in their definitionand whose truth may depend very precisely upon the given operators. Thisis, by no means, an exhaustive list of properties that a criticality assignmentfunction should possess; for example, we might also want the function to re-spect impossibility – those preconditions which cannot be changed shouldbe given the largest criticality. Nevertheless, we would argue that these areall necessary properties.5 A solutionWe propose a criticality assignment function that satisfies all the propertiesidentified in the last section. It is based upon interpreting C(Ops, p, n) asthe difficulty of finding a proof of p of up to depth n. C(Ops, p, n) is definedrecursively as a function of the difficulty of finding a proof of up to depthn − 1 plus the difficulty of finding a proof of exactly depth n (which werepresent by D(Ops, p, n)). We combine these difficulties by analogy to thecalculation of parallel resistance. With two resistors in parallel, the currentcan go through either the first resistor or the second, thereby reducing thetotal resistance. Similarly, we can find either a proof of up to depth n−1, orwe can find a proof of exactly depth n. Thus the difficulty of finding a proofof up to depth n is the parallel sum of the difficulties of finding a proof ofup to depth n − 1 and of finding a proof of exactly depth n (equation ??).This method of combining difficulties guarantees the monotonicity property.The starting values for the calculation of criticalities are given by equation??; this equation gauarantees the fairness of our solution.C(Ops, p, 0) = a0 (1)1C(Ops, p, n)=1C(Ops, p, n− 1) +1D(Ops, p, n)(2)This still leaves us to decide how to calculate D(Ops, p, n), the difficultyof finding a proof of exactly depth n. This is also defined recursively.The boundary conditions are easy. D(Ops, p, 0) is the difficulty of finding6a proof of depth 0; this must equal C(Ops, p, 0) (equation ??). The otherboundary condition is when no operator has p as a conclusion; since it willbe impossible to change this predicate, we set this difficulty to ∞ (equation??).The step equations are more complicated. The difficulty of finding aproof of p of exactly depth n, that is D(Ops, p, n) is the parallel sum of thedifficulties of finding a proof of depth n that ends with an operator with pas conclusion (equation ??). D(Ops, q → p, n) represents the difficulty offinding a proof of depth n that ends with the application of the operator,q → p. Note that q itself might be a conjunction of preconditions, pi. Finallythe difficulty of ending a proof of depth n with the operator, ∧pi → p, that isD(Ops,∧pi → p, n) is at least as difficult as finding a proof of depth n− 1 ofthe most difficult precondition to that operator, that is max{D(Ops, qi, n−1)} (equation ??). In calculating the difficulty of proving the preconditionsto an operator, we have made the simplifying assumption that the difficultyis dominated by the most difficult precondition; a more thorough analysiswould also consider the difficulties of proving the less difficult preconditions.However, such a calculation could be very expensive; taking the maximumshould give a good lower bound.D(Ops, p, 0) = a0 (3)D(Ops, r,m) = ∞ (4)1D(Ops, p, n)=∑q→p∈Ops1D(Ops, q → p, n) (5)D(Ops,∧qi → p, n) = max{D(Ops, qi, n− 1)} (6)where Ops contains no operator with r as conclusion, and m > 06 A worked exampleWe have tested this solution on some examples, taken from both planningdomains (eg. the original Abstrips operators [?]) and from theorem proving7domains (eg. the operators devised by Green for the famous Monkey andBananas problem [?]). For illustration, we give a table containing the calcu-lation of criticalities for the Monkey and Bananas problem. The operatorsfor this problem are given in Appendix ??.C /a0 n = 0 1 2 3 ∞at 1.00 0.25 0.25 0.25 0.25has 1.00 0.50 0.33 0.25 0.25reachable 1.00 0.50 0.33 0.33 0.33on 1.00 0.50 0.50 0.50 0.50movable 1.00 1.00 1.00 1.00 1.00empty 1.00 1.00 1.00 1.00 1.00climbable 1.00 1.00 1.00 1.00 1.00Our criticality assignment function converges to an answer rapidly. In-deed, by the third iteration it reaches its final values. The relative or-der of criticalities calculated by our method is almost identical to that as-signed by the original semi-automatic method used in Abstrips. The methodused in Abstrips also needed an initial partial order on the preconditions.For the Monkey and the Bananas problem, we assume the partial ordering{(climbable,movable, empty), (on, reachable, has, at)}. The first set of pre-conditions represent type preconditions that cannot be changed, whilst thesecond set are all conclusions of operators (and so can be changed). The onlydifference between the criticalities calculated by our method and those cal-clulated by the method used in Abstrips is that the latter method gives at alower criticality than has. However, this difference seems more a criticism ofthe need to supply a partial order as a different partial order would producedifferent criticality assignments.7 ConclusionsWe have presented a powerful theory of abstraction. We have used this theoryto identify the different ways we can abstract a new problem. We then8concentrated on one particular type of abstraction, that used in Abstrips.We explored how to build such abstractions automatically, motivating ourproposed method by defining the formal properties we want it to possess.AcknowledgementsAlan Bundy is supported by a SERC Senior Fellowship. Fausto Giunchigliastarted this work at the Department of Artificial Intelligence at Edinburghsupported by SERC grant GR/E/4459.8. He is now supported at IRSTby the Istituto Trentino di Cultura. Toby Walsh is supported by a SERCstudentship. All the members of the Mathematical Reasoning group in Edin-burgh and the Mechanized Reasoning group in Trento are thanked for theirmany contributions to this work.AppendixA Monkey and Bananas’ Operatorsat(z, x1, s) ∧movable(z) ∧ empty(x2, s) → at(Monkey, x2,m(Monkey, z, x2, s))at(z, x1, s) ∧movable(z) ∧ empty(x2, s) → at(z, x2,m(Monkey, z, x2, s))at(z, x, s) ∧ climbable(y, z, s) → at(z, x, c(y, z, s))at(z, x, s) ∧ climbable(y, z, s) → on(y, z, c(y, z, s))at(Box, Under, s) ∧ on(Monkey,Box, s) → reachable(Monkey,Bananas, s)reachable(z, x, s) → has(z, x, r(z, x, s))9

Building Abstractions

http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.24.4027

Building Abstractions

Abstract

Similar works

Full text

Available Versions

Edinburgh Research Explorer