Bundy, Alan

Lehmann, J.

English

Edinburgh Research Explorer

     Edinburgh Research Explorer                                      An Architecture of GALILEO: A System for Automated OntologyEvolution in PhysicsCitation for published version:Bundy, A & Lehmann, J 2009, 'An Architecture of GALILEO: A System for Automated Ontology Evolution inPhysics' Paper presented at IJCAI-09 Workshop on Automated Reasoning about Context and OntologyEvolution, Pasadena, California, United States, 11/07/09, .Link:Link to publication record in Edinburgh Research ExplorerDocument Version:Preprint (usually an early version)General 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. 2015An Architecture of GALILEO: A System for Automated Ontology Evolution inPhysicsMichael Chan and Alan BundySchool of InformaticsUnviersity of Edinburgh{M.Chan, A.Bundy}@ed.ac.ukAbstractThe GALILEO system implements novel mecha-nisms for automated ontology evolution in physics.These mechanisms, called ontology repair plans,resolve logical conflicts between several modularontologies. To demonstrate that ontology evolutioncan be automated using ontology repair plans, wepropose a flexible architecture for the implementa-tion. Support for inference of formulae that triggerrepair plans and modularisation of ontologies arecentral to the design. Huet’s Zipper data structureis to be used to avoid encoding the object-level for-malism with a deep embedding. For a high degreeof modularity, the management of a collection ofontologies is handled by development graphs.1 IntroductionVisions of applications involving multi-agent systems, e.g.,the Semantic Web, have intensified the need for mechanismsfor automated ontology evolution. We address the issueby developing ontology repair plans and applying them torecords of ontology evolution in the history of physics. Theimplemented programs form the core of the GALILEO sys-tem (Guided Analysis of Logical Inconsistencies Leads toEvolved Ontologies). Ontology repair plans enable agentsto autonomously update their own ontologies by applying di-agnosis and repair operations [Bundy and Chan, 2008]. Asa step towards the demonstration that automated ontologyevolution via ontology repair plans is computationally fea-sible, the repair plans and the example ontologies are imple-mented in Teyjus, an implementation of λProlog [Miller andNadathur, 1988]. Higher-order abstract syntax is used to en-able the meta-logic to recurse over the syntactical structureof the object-logic. Unfortunately, this results in the inabilityof performing inference to reason about whether some on-tology has a theorem that infers the triggering formulae of arepair plan. One consequence is that theorems are forced tobe coded as axioms. This implementation is clearly unnatu-ral, but has been kept simple because it is a mere proof-of-concept. A more flexible architecture is essential in order togo beyond.The goals underlying the design of the architecture of thenew implementation are two-fold:• Higher-order reasoning engines must be incorporated toinfer formulae that trigger ontology repair plans.• The representation of knowledge as ontologies shouldbe modular.In the current pure λProlog implementation, the inference isleft to the programmer and the encoding of the ontologiesfor repair is tailored to the specific triggering formulae of therepair plans. This issue can be addressed by adopting a rea-soner, such as a theorem prover. Only higher-order reasonersare useful to us because many physics properties are more re-alistically represented as higher-order objects. For instance, astar’s orbit is more realistically represented as a function ob-ject that returns the 3-D spatial position of the star for a giventime moment. If it were represented as a non-functional ob-ject, then much of the description and expressivity would belost and the representation would be much closer to that ofstatic, physical entities, e.g., a dog or a house.The idea of making the knowledge-base modular has re-ceived much attention from the knowledge representationcommunity. For instance, it is a basis of Sowa’s notion of“knowledge soup” [Sowa, 2006]; it suggests that because theknowledge in a person’s head is of a disorganised and dy-namically changing nature, it consists of many self-consistentchunks of knowledge. Similarly in Cyc [Lenat, 1995], differ-ent contexts are represented as separate microtheories; eachis represented by a set of assertions that corresponds to therelevant facts and assumptions valid in the particular context.Our current representation is modular as the predictive andobservational ontologies are already separate representations[Bundy, 2008]. Each of these is internally consistent, but pos-sibly inconsistent with one another [Bundy and Chan, 2008].We will extend this principle by modularising other contentsas well, e.g., foundational theories of physics and mathemat-ics.2 Reasoning for Ontology EvolutionPhysics ontologies are represented at the object-level, quan-tifying over physics functions, objects, and measurements.Object-level reasoning is therefore needed to, e.g., derive theLaw of Universal Gravitational Force from an ontology con-taining the axioms of the Newtonian theory. Repair plans aredesigned to guide the ontology repair procedure, so they needto be represented at the meta-level quantifying over objects atthe object-level. Meta-level reasoning is therefore clearly dis-tinct from that of object-level; for instance, it reasons aboutwhether an ontology can trigger a repair plan by matchingsome of its theorems to the trigger formulae. Moreover, on-tology manipulation is also guided by the meta-level, e.g., thechange of signatures and the addition of axioms.Some higher-order theorem provers, such as Isabelle [Nip-kow et al., 2002], offer a clear separation of the logic intometa- and object-levels. We shall discuss the possibility ofusing a theorem prover as the sole basis for the implementa-tion.2.1 Effects of Shallow and Deep EmbeddingsThere are generally two techniques of encodings: shallow anddeep embeddings. In a shallow embedding, only the seman-tics of the logic needs to be defined. As the syntactic struc-tures are not represented, theorems about the syntax cannotbe proven. If the two logics are both shallowly-embedded, itis then difficult for the meta-logic to reason about the syntac-tical structure of the object-level formalism, e.g., matchinga theorem to some trigger formulae. Syntax then cannot bedeconstructed by pattern matching because higher-order uni-fication attempts to instantiate some variable to the constantin question. We do not want a variable to be instantiated whenalmost any constant is pattern matched against it.In a deep embedding, both the (abstract) syntax and thesemantics of the object-logic must be defined. The syn-tax is typically defined by an inductive definition. In ef-fect, statements of an object-logic are represented as ob-jects of a data type of the meta-logic. For instance,f(x) becomes (applic f x), where applic is of type(A -> B) -> A -> B and both f and x are constants. Ifinference is to be enabled, the unification algorithm may evenneed to be reimplemented. Note that the current λProlog im-plementation uses deep embedding to represent the two logicsas one.Neither a pure shallow nor deep embedding appears toenable both inference and the matching and instantiation oftrigger formulae. Our solution involves a kind-of hybrid ap-proach.2.2 Huet’s Zipper Data StructureDue to the rigorous formalisation required, the effort for pro-ducing a deep embedding that allows inference to be done canbe substantial. Our solution aims at the accommodation ofboth the shallowly-embedded formulae and their parse trees.It is based on using Huet’s zipper data structure [Huet, 1997],a data structure that can deconstruct any list- and tree-likedata structure and requires a constant time to move in anylocation.The creation of a zipper from the parse tree of a formularesembles the translation from shallow to deep embedding.Of course, it is not true deep embedding since the zipper doesnot carry information about the semantics, but the represen-tation of the parse tree in a zipper is sufficient for our needs.Navigating around a zipper naturally corresponds to movingaround terms, so operations for term manipulation can thenbecome intuitive. So, we will have the best of both shallowand deep embeddings by passing around both the formula andthe zippers. The formula can be used for inference, while thezipper containing the parse tree can be used for pattern match-ing.3 Modularising KnowledgeCurrently, the theoretical and sensory ontologies are treatedas separate interacting logic theories, e.g., the Inconstancyontology repair plan resolves conflicts between a theoreticaland multiple sensory ontologies [Chan and Bundy, 2008]. Amajor theoretic advantage of having multiple, internally con-sistent ontologies is the better management of logical incon-sistency. Since inconsistent theories can prove all formulae,all instantiations of the triggers of all repair plans would alsobe provable. Keeping the theories consistent only internallyavoids the combinatorial explosion of instantiations, yet aconflict can still be detected at the global level. A high de-gree of modularity also makes the integration of new ontolo-gies more natural and convenient. Instead of adding axiomsand changing type declarations to existing ontologies, whichcan invalidate previous proofs, a new ontology can be whollyintroduced to the collection. This is in fact close to a centralprinciple of object-oriented programming; that is, the work-ings of an object are decoupled from the rest of the systemand the addition of a class does not affect other parts of theprogram.To further modularise the existing knowledge represen-tation, the physics and mathematical theories can be par-titioned into small ontologies. Each ontology resembles asmall context, e.g., there could be separate ontologies fora formal theory and for a naive theory of geometry, whichonly covers 2-D spaces. Certainty factors can be assignedto an ontology, determining the vulnerability of the theoryor experiment to repair. For instance, the ontology for acontroversial theory should be valued at a lower confidencethan an established one. The factors could be expressed us-ing a discrete representation, e.g., definitely true andtrue by default, as experimented in Cyc.3.1 Partition Management with DevelopmentGraphThe collection of ontologies can be translated to form a struc-tured logical representation called a development graph [Au-texier et al., 1999], in which a node corresponds to an ontol-ogy. A node, thus an ontology, can be defined to import sig-natures and theorems from other nodes. Such morphisms be-tween theories are formalised using definition links. To helpseparate the axiomatisation of the theory itself from the im-ported, the axiomatisation is split into local and global parts.For the implementation of ontology repair, repaired ontolo-gies are inserted into the development graph as new nodes, re-placing those that correspond to the original ontologies. Thenew nodes should have the same morphisms as the old, sothe morphisms of the replaced nodes are preserved. Clearly,some of the old morphisms may no longer be desirable de-pending on the type of repair performed and the notion ofminimal change adopted. The new nodes could partly importthe axiomatisation of the replaced, giving them implicit def-initions. In this case, the replaced nodes still exist, but aredisconnected from the rest of the system.Development graph is already implemented in HETS[Mossakowski et al., 2007] and MAYA [Autexier et al., 2002],which are systems for managing evolutionary developmentand for analysis and proof management, respectively. In bothsystems, development graph can be created by translatingan input HASCASL specification, a higher-order extension ofCASL.3.2 Example Specification[debugging]4 Putting the Pieces TogetherTo leverage an existing implementation of developmentgraph, we are currently experimenting with HETS becausethe implementation is better maintained. Unfortunately, HETShas no support for evolutionary change management. We willlikely migrate to a system to be called DocTip, the successorof HETS and MAYA, once it becomes available. Both DocTipand HETS can be connected to a range of theorem provers, in-cluding Isabelle. So, the trigger formulae of a repair plan canbe inferred from the conflicting ontologies if the ontologiesare encoded by using a shallow embedding.The repair plan programs are responsible for directingthe modification of the development graph, e.g., adding anddeleting nodes and morphisms. These therefore need to com-municate to the development graph editor via an API. Apolymorphic, higher-order logic programming language, e.g.,λProlog, is needed to encode trigger formulae and transfor-mation rules.It is, however, not yet clear how to correctly instantiate thetrigger formulae by recursing over the syntactical structureof the object-level formulae. Future work will involve theinvestigation of the use of zippers in HETS or DocTip.5 ConclusionThe current λProlog implementation deeply-embeds themeta- and object-logics into one, and this approach limits theability to perform inference on the trigger formulae. As analternative, we have described the possibility of using Huet’sZipper data structure to encode the parse tree of a formula.Our new architecture accommodates the use of various rea-soning engines, e.g., Isabelle, to prove theorems of ontolo-gies. Since partitioning the knowledge-base into small on-tologies help control logical inconsistency and provides eas-ier maintenance, we go beyond just separating the predictiveand sensory ontologies. Development graph is used for themanagement of the highly modularised ontologies.References[Autexier et al., 1999] S. Autexier, D. Hutter, H. Mantel, andA. Schairer. Towards an Evolutionary Formal Software-Development Using CASL. Lecture Notes In ComputerScience; Vol. 1827, pages 73–88, 1999.[Autexier et al., 2002] S. Autexier, D. Hutter,T. Mossakowski, and A. Schairer. The developmentgraph manager MAYA. In Proceedings of the 9th In-ternational Conference on Algebraic Methodology andSoftware Technology, pages 495–501. Springer-VerlagLondon, UK, 2002.[Bundy and Chan, 2008] A. Bundy and M. Chan. Towardsontology evolution in physics. In W. Hodges, editor, Procs.Wollic 2008. LNCS, Springer-Verlag, July 2008.[Bundy, 2008] Alan Bundy. Automating Signature Evolutionin Logical Theories, volume 5144/2008, pages 333–338.Springer Berlin / Heidelberg, Jul 2008.[Chan and Bundy, 2008] M. Chan and A. Bundy. Incon-stancy: An ontology repair plan for adding hidden vari-ables. In S. Bringsjord and A. Shilliday, editors, Sympo-sium on Automated Scientific Discovery, number FS-08-03in Technical Report, pages 10–17. AAAI Press, November2008. ISBN 978-1-57735-395-9.[Huet, 1997] G. Huet. The zipper. Journal of FunctionalProgramming, 7(5):549–554, 1997.[Lenat, 1995] D.B. Lenat. CYC: a large-scale investment inknowledge infrastructure. Commun. ACM, 38(11):33–38,November 1995.[Miller and Nadathur, 1988] D. Miller and G. Nadathur. Anoverview of λProlog. In R. Bowen, editor, Proceed-ings of the Fifth International Logic Programming Confer-ence/ Fifth Symposium on Logic Programming. MIT Press,1988.[Mossakowski et al., 2007] Till Mossakowski, ChristianMaeder, and Klaus Lu¨ttich. The Heterogeneous Tool Set.In Orna Grumberg and Michael Huth, editors, TACAS2007, volume 4424 of Lecture Notes in Computer Science,pages 519–522. Springer-Verlag Heidelberg, 2007.[Nipkow et al., 2002] Tobias Nipkow, Lawrence C. Paulson,and Markus Wenzel. Isabelle/HOL — A Proof Assistantfor Higher-Order Logic, volume 2283 of LNCS. Springer,2002.[Sowa, 2006] J.F. Sowa. The challenge of knowledge soup.In J. Ramadas and S. Chunawala, editors, ResearchTrends in Science, Technology and Mathematics Educa-tion, Mumbai, 2006. Homi Bhabha Centre.

An overview of Prolog. In

Automating Signature Evolution in Logical Theories,

CYC: a large-scale investment in knowledge infrastructure.

Inconstancy: An ontology repair plan for adding hidden variables.

Isabelle/HOL — A Proof Assistant for Higher-Order Logic,

The challenge of knowledge soup.

The development graph manager MAYA.

The Heterogeneous Tool Set.

The zipper.

Towards an Evolutionary Formal SoftwareDevelopment Using CASL.

An Architecture of GALILEO: A System for Automated Ontology Evolution in Physics

An Architecture of GALILEO: A System for Automated Ontology Evolution in Physics

Abstract

Similar works

Full text

Available Versions

Edinburgh Research Explorer