The Architecture of the Galileo Project

Transcription

1 The Architecture of the Galileo Project Michael Chan (Joint work with Alan Bundy and Jos Lehmann) School of Informatics University of Edinburgh ARCOE 2009

2 Outline 1 The Old and New Architectures Overview 2 The Latent Heat Case Study Overview The λprolog Implementation The Casl Specification The Development Graph for Latent Heat 3 Ontology Repair Plans Overview The λprolog Implementation Shallow and Deep Embeddings Effecting Repair 4 Discussion What has to be Done

3 Overview Current implementation: Implemented in λprolog (using Teyjus). Uses deep embedding. Ad hoc and inference is not enabled. Design goals for the new architecture: Need access to higher-order inference engines to prove trigger formulae Modularise the ontologies and use development graphs for maintaining the ontologies and managing change. Development graph is based on institution theory, where nodes are ontologies and arrows are morphisms. Hets: An analysis tool for Casl and enables theorems to be proved using ATPs. Contains an implementation of development graphs.

4 The Latent Heat Case Study Before Joseph Black s investigations, heat and temperature conflated. Leads to paradox when heat is reduced but temperature is constant!

5 The λprolog Implementation Logic O t Heat(H 2 O, Start(Freeze)) = Heat(H 2 O, Start(Freeze)) O t Heat(H 2 O, Start(Freeze)) > Heat(H 2 O, End(Freeze)) λprolog axioms ont_t (applic equal (applic heat ( h2o :: (applic start freeze) :: nil):: :: nil)) :: nil) :: applic greater (applic heat (h2o :: (applic start freeze) :: nil) :: (applic heat (h2o :: applic d freeze :: nil)) ::nil) :: nil). The ontologies are deeply-embedded. Cannot do inference. All theorems are coded as elements of a list of axioms. Cannot derive the predictive theory for freezing. Difficult to ext an ontology from another. The lack of subtyping forces the types for heat and energy to be distinct. Difficult to read.

6 The Casl Specification Logic O t Heat(H 2 O, Start(Freeze)) = Heat(H 2 O, Start(Freeze)) O t Heat(H 2 O, Start(Freeze)) Heat(H 2 O, End(Freeze)) O s Heat(H 2 O, Start(Freeze)) = Heat(H 2 O, End(Freeze)) Casl spec ClassicalEnergyFlow = BasicPhys then sorts Energy < Int; Heat < Energy; Energy_Release < Process;... ops HeatAmt : Obj * Time -> Heat spec Energy_Release = ClassicalEnergyFlow then forall o:obj; t1,t2:time. t1 B t2 <=> HeatAmt(o,t1) > HeatAmt(o,t2). t1 = t2 <=> HeatAmt(o,t1) = HeatAmt(o,t2). t1 Bi t2 <=> HeatAmt(o,t1) < HeatAmt(o,t2) spec Ot = Energy_Release then %implies forall h:h2o; f:freeze. HeatAmt(h, Start(f)) > HeatAmt(h, End(f)) %(prediction)% spec Os = Ot then %implies. exists f:freeze; h:h2o. HeatAmt(h, Start(f)) = HeatAmt(h, End(f)) %(observation)% Nodes can import the axiomatisation of other nodes. Subtypes can be defined as subsorts. Heat can now be related to energy. Permits a richer description.

7 More on Using Casl The specification is to be analysed using Hets We will still need to define axioms, unless we mechanise the workings of Newtonian theory, etc. With support for reasoning, the axioms defined in Casl can be more general, e.g., forall o:obj; t1,t2:time. t1 B t2 <=> Heat(o,t1) > Heat(o,t2) vs. applic greater (applic heat (h2o :: (applic start freeze) :: nil) :: (applic heat (h2o :: applic d freeze :: nil)) ::nil) For higer-order logic, we will use HasCasl.

8 The Development Graph for Latent Heat Development Graph Casl spec ClassicalEnergyFlow = BasicPhys then sorts Energy < Int; Heat < Energy;... ops HeatAmt : Obj * Time -> Heat spec Energy_Release = ClassicalEnergyFlow then forall o:obj; t1,t2:time. t1 B t2 <=> HeatAmt(o,t1) > HeatAmt(o,t2). t1 = t2 <=> HeatAmt(o,t1) = HeatAmt(o,t2). t1 Bi t2 <=> HeatAmt(o,t1) < HeatAmt(o,t2) spec Ot = Energy_Release then %implies forall h:h2o; f:freeze. HeatAmt(h, Start(f)) > HeatAmt(h, End(f)) spec Os = Ot then %implies. exists f:freeze; h:h2o. HeatAmt(h, Start(f)) = HeatAmt(h, End(f)) %(observation)% The ontologies are modularised. Ot and Os ext from other nodes and are implicitly defined. The prediction and observation become proof obligations in Energy_Release and Ot, respectively.

9 Reducing Theorem Links Figure: DGs after decomposition and subsumption.

10 Ontology Repair Plans Resolve logical conflicts between modular ontologies. They are composed of rules for conflict diagnosis (trigger) and transformation of ontologies (repair). Repair operations could split/conflate concepts, add/remove arguments, etc. Repairs can be represented as morphisms between the old and the new ontologies. The repaired ontologies typically inherit some of the signatures and theorems of the old. We may need to ext DG to consider signature changes as morphisms.

11 The λprolog Implementation Logic λprolog Trigger: wms_trigger O1 O2 Stuff Arg O t stuff ( s) = v 1, (applic Stuff Arg) 2 :- O s stuff ( s) = v 2, turnstile O1 (applic equal (applic Stuff Arg :: Val1 :: nil)), O t v 1 v 2 turnstile O2 (applic equal (applic Stuff Arg :: Val2 :: nil)), turnstile O2 (applic greater (Val1 :: Val2 :: nil)). Repair: Ax(ν(O t )) ::= { s: τ. repair O1 O2 NA1 NA2 : stuff σ invis ( s) ::= stuff ( s) wms_trigger O1 O2 S L Tot P stuff σ vis ( s)} Ax(O t ) flip P FP choose S L T Ax(ν(O s )) ::= newstuff Tot T SVis SInvis {φ{stuff /stuff σ vis } φ axioms O1 A1 Ax(O s )} axioms O2 A2 changewms P O1 A1 Tot SVis SInvis NA1 changewms FP O2 A2 Tot SVis SInvis NA2. The predicate turnstile is used to represent that a formula is a theorem of an ontology. Mathematical relations such as = and < need to be defined.

12 Shallow and Deep embeddings We cannot deeply-embed or shallowly-embed the logics. With a deep embedding, we ll lose the ability to do inference on the object-logic. With a shallow embedding, we ll lose the ability to recurse over syntactical structures. We can use Huet s zippers for recursion over the syntax of a theorem. The recursion will need to be done either in Hets/DocTip itself or in an external module interfaced with Hets/DocTip.

13 Effecting Repair The repair is guided by external programs, possibly implemented in λprolog. Haskell could be an alternative, but the implementation would be less natural. To effect the repair, the DG is manipulated by, e.g., adding/removing nodes and adding/removing links between nodes.

14 What has to be Done We will need mechanisms for effecting the repair in DGs. Need an Api connecting repair programs to Hets/DocTip. The changes made may need to be propagated to the GUI. How ontology repairs can be represented as morphisms? How should the recursion over syntactical structures of theorems take place?

15 Conclusion The current implementation has several major limitations, e.g., the inability to perform inference. The new architecture focuses on modularising ontologies and reduces most of these limitations. So far, the implementation of the latent heat ontologies looks promising. Work with Hets/DocTip developers to: Implement mechanisms that effect repair Build an Api Ext morphisms to include signature changes