OWL: A Description Logic Based Ontology Language Ian Horrocks Information Management Group School of Computer Science University of Manchester

Talk Outline Introduction to Description Logics Introduction to Ontologies Introduction to Ontology Languages Ontology Reasoning Why do we want it? How do we do it? Current Work and Research Challenges Summary

Introduction to Description Logics

What Are Description Logics? A family of logic based Knowledge Representation formalisms –Descendants of semantic networks and KL-ONE –Describe domain in terms of concepts (classes), roles (properties, relationships) and individuals Distinguished by: –Formal semantics (typically model theoretic) Decidable fragments of FOL (often contained in C 2 ) Closely related to Propositional Modal & Dynamic Logics Closely related to Guarded Fragment –Provision of inference services Decision procedures for key problems (satisfiability, subsumption, etc) Implemented systems (highly optimised)

DL Basics Concepts (unary predicates/formulae with one free variable) –E.g., Person, Doctor, HappyParent, ( Doctor t Lawyer) Roles (binary predicates/formulae with two free variables) –E.g., hasChild, loves, ( hasBrother ± hasDaughter ) Individuals (constants) –E.g., John, Mary, Italy Operators (for forming concepts and roles) restricted so that: –Satisfiability/subsumption is decidable and, if possible, of low complexity –No need for explicit use of variables Restricted form of 9 and 8 (direct correspondence with ◊ and []) –Features such as counting can be succinctly expressed

The DL Family (1) Smallest propositionally closed DL is ALC (equiv modal K (m) ) –Concepts constructed using booleans u, t, :, plus restricted quantifiers 9, 8 –Only atomic roles E.g., Person all of whose children are either Doctors or have a child who is a Doctor: Person u 8 hasChild.(Doctor t 9 hasChild.Doctor)

The DL Family (2) S often used for ALC extended with transitive roles ( R + ) Additional letters indicate other extensions, e.g.: – H for role hierarchy (e.g., hasDaughter v hasChild) – O for nominals/singleton classes (e.g., {Italy}) – I for inverse roles (e.g., isChildOf ´ hasChild – ) – N for number restrictions (e.g., > 2 hasChild, 6 3 hasChild) – Q for qualified number restrictions (e.g., > 2 hasChild.Doctor) – F for functional number restrictions (e.g., 6 1 hasMother) S + role hierarchy ( H ) + inverse ( I ) + QNR ( Q ) = SHIQ SHIQ is the basis for W3C’s OWL Web Ontology Language –OWL DL ¼ SHIQ extended with nominals (i.e., SHOIQ ) –OWL Lite ¼ SHIQ with only functional restrictions (i.e., SHIF )

DL Semantics Semantics given by standard FO model theory: Interpretation domain  I Interpretation function I Individuals i I 2  I John Mary Concepts C I µ  I Lawyer Doctor Vehicle Roles r I µ  I £  I hasChild owns (Lawyer u Doctor)

A TBox is a set of “schema” axioms (sentences), e.g.: {Doctor v Person, HappyParent ´ Person u 8 hasChild.(Doctor t 9 hasChild.Doctor)} An ABox is a set of “data” axioms (ground facts), e.g.: {John:HappyParent, John hasChild Mary} A Knowledge Base (KB) is just a TBox plus an ABox DL Knowledge Base

Introduction to Ontologies

See other talk…

Introduction to Ontology Languages

Semantic Web led to requirement for a “web ontology language” set up Web-Ontology (WebOnt) Working Group –WebOnt developed OWL language –OWL based on earlier languages OIL and DAML+OIL –OWL now a W3C recommendation (i.e., a standard) OIL, DAML+OIL and OWL based on Description Logics –OWL effectively a “Web-friendly” syntax for SHOIN The Web Ontology Language OWL

OWL RDF/XML Exchange Syntax E.g., Person u 8 hasChild.(Doctor t 9 hasChild.Doctor):

Class/Concept Constructors C is a concept (class); P is a role (property); x is an individual name XMLS datatypes as well as classes in 8 P.C and 9 P.C –Restricted form of DL concrete domains

Ontology Axioms OWL ontology equivalent to DL KB (Tbox + Abox)

Why Description Logic? OWL exploits results of 15+ years of DL research –Well defined (model theoretic) semantics

Why Description Logic? OWL exploits results of 15+ years of DL research –Well defined (model theoretic) semantics –Formal properties well understood (complexity, decidability) [Garey & Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. Freeman, 1979.] I can’t find an efficient algorithm, but neither can all these famous people.

Why Description Logic? OWL exploits results of 15+ years of DL research –Well defined (model theoretic) semantics –Formal properties well understood (complexity, decidability) –Known reasoning algorithms

Why Description Logic? OWL exploits results of 15+ years of DL research –Well defined (model theoretic) semantics –Formal properties well understood (complexity, decidability) –Known reasoning algorithms –Implemented systems (highly optimised) Pellet

Why Description Logic? Foundational research was crucial to design of OWL –Informed Working Group decisions at every stage, e.g.: “Why not extend the language with feature x, which is clearly harmless?” “Adding x would lead to undecidability - see proof in […]”

Ontology Reasoning: Why do We Want It?

See other talk…

Why Decidable Reasoning? OWL’s expressive power restricted so reasoning is decidable Design was motivated by: –Layered architecture of Semantic Web languages RDF(S) provides basic relational language and simple ontological primitives (or this is what RDF should be) OWL provides powerful but still decidable ontology language Further layers (e.g. RIF) will extend OWL (and may be undecidable) –W3C requirement for “implementation experience” Evidence that language can be / is being used “in practice” Should be several implemented systems –Users expectations of (automated reasoning) systems Should exhibit correct, consistent and predictable behaviour And should be quick about it!

Ontology Reasoning: How do we do it?

Using Standard DL Techniques Key reasoning tasks reducible to KB (un)satisfiability –E.g., C v D w.r.t. KB K iff K [ {x:(C u : D)} is not satisfiable State of the art DL systems typically use (highly optimised) tableaux algorithms to decide satisfiability (consistency) of KB Tableaux algorithms work by trying to construct a concrete example (model) consistent with KB axioms: –Start from ground facts (ABox axioms) –Explicate structure implied by complex concepts and TBox axioms Syntactic decomposition using tableaux expansion rules Infer constraints on (elements of) model

Tableaux Reasoning (1) E.g., KB: { HappyParent ´ Person u 8 hasChild.(Doctor t 9 hasChild.Doctor), John:HappyParent, John hasChild Mary, Mary: : Doctor Wendy hasChild Mary, Wendy marriedTo John} Person 8 hasChild.(Doctor t 9 hasChild.Doctor)

Tableaux Reasoning (2) Tableau rules correspond to constructors in logic ( u, 9 etc) –E.g., John: ( Person u Doctor) -- ! John:Person and John:Doctor Stop when no more rules applicable or clash occurs –Clash is an obvious contradiction, e.g., A(x), : A(x) Some rules are nondeterministic (e.g., t, 6 ) –In practice, this means search Cycle check (blocking) often needed to ensure termination –E.g., KB: { Person v 9 hasParent.Person, John:Person}

Tableaux Reasoning (3) In general, (representation of) model consists of: –Named individuals forming arbitrary directed graph –Trees of anonymous individuals rooted in named individuals

Decision Procedures Algorithms are decision procedures, i.e., KB is satisfiable iff rules can be applied such that fully expanded clash free graph is constructed: Sound –Given a fully expanded and clash-free graph, we can trivially construct a model Complete –Given a model, we can use it to guide application of non-deterministic rules in such a way as to construct a clash-free graph Terminating –Bounds on number of named individuals, out-degree of trees (rule applications per node), and depth of trees (blocking) Crucially depends on (some form of) tree model property

Ontology Reasoning: A Tableaux Algorithm for SHOIQ

Motivation for OWL Design Exploit results of DL research: –Well defined semantics –Formal properties well understood (complexity, decidability) –Known tableaux decision procedures and implemented systems But not for SHOIN (until recently)! So why is/was SHOIN so hard?

SHIQ is Already Tricky Does not have finite model property, e.g.: { ITN v 6 1 edge – u 9 edge.ITN, R:(ITN u 6 0 edge – )} –Double blocking –Block interpreted as infinite repetition

SHIQ is Already Tricky Does not have finite model property, e.g.: { ITN v 6 1 edge – u 9 edge.ITN, R:(ITN u 6 0 edge – )} –Double blocking –Block interpreted as infinite repetition Termination problem due to > and 6, e.g.: { John: 9 hasChild.Doctor u > 2 hasChild.Lawyer u 6 2 hasChild } –Add inequalities between nodes generated by > rule –Clash if 6 rule only applicable to  nodes

SHOIQ : Loss (almost) of TMP Interactions between O, I, and Q lead to new termination problems –Anonymous branches can loop back to named individuals ( O ) E.g., 9 r.{Mary} –Number restrictions ( Q ) on incoming edges ( I ) lead to non-tree structure E.g., Mary: 6 1 r – –Result is anonymous nodes that act like named individual nodes –Blocking sequence cannot include such nodes Don’t know how to build a model from a graph including such a block

Intuition: Nominal Nodes Nominal nodes (N-nodes) include: –Named individual nodes –Nodes affected by number restriction via outgoing edge to N-node Blocking sequence cannot include N-nodes Bound on number of N-nodes –Must initially have been on a path between named individual nodes –Length of such paths bounded by blocking –Number of incoming edges at an N-node is limited by number restrictions

Generate & Merge Problem is Back! E.g., KB: { VMP ´ Person u 9 loves.{Mary} u 9 hasFriend.VMP, John: 9 hasFriend.VMP Mary: 6 2 loves – } Blocking prevented by N-nodes Repeated generation and merging of nodes leads to non-termination

Intuition: Guess Exact Cardinality New Ro?-rule guesses exact cardinality constraint on N-nodes { VMP ´ Person u 9 loves.{Mary} u 9 hasFriend.VMP, John: 9 hasFriend.VMP Mary: 6 2 loves – } Inequality between resulting N-nodes fixes generate & merge problem Introduces new source of non-determinism –But only if nominals used in a “nasty” way Usage in ontologies typically “harmless” –Otherwise behaves as for SHIQ

Research Challenges: What next?

Increasing Expressive Power OWL not expressive enough for some applications –Constructors mainly for classes (unary predicates) –No complex datatypes or built in predicates (e.g., arithmetic) –No variables –No higher arity predicates Extensions (of OWL) that have/are being considered include: –(Decidable) extensions to underlying DL –“Rule” language extensions The focus of much research/debate (e.g., W3C RIF working group) –First order logic (e.g., SWRL-FOL) –(Syntactically) higher order extensions (e.g., Common Logic)

Extend Underlying DL Role box ( SROIQ ) [Horrocks, Kutz & Sattler, KR-06] –E.g., hasLocation ± partOf v hasLocation –Reflexive, irreflexive, and antisymmetric roles –Basis for OWL 1.1 effort Concrete domains/datatypes [Lutz, IJCAI-99; Pan et al, ISWC-03] –E.g., value comparison (income > expenditure) –Custom datatypes (integer >25) Database style keys [Lutz et al, JAIR 2004] –E.g., make + model + chassis-number is a key for Vehicles … Note that role box + concrete domains is basis for OWL 1.1

Rule Language Extensions (to OWL) First Order extension (e.g., SWRL) [Horrocks et al, JWS, 2005] –Horn clauses where predicates are OWL classes and properties –Resulting language is undecidable –Reasoning support currently only via FOL theorem provers (Hoolet) Hybrid language extensions being investigated –Restricting language “interaction” maintains decidability DL extended with Answer Set Programming [Eiter et al, KR-04] DL extended with Datalog rules [Motik et al, ISWC-04; Rosati, JWS, 2005] LP/F-logic rule language –Claimed “interoperability” with OWL via DLP subset [de Bruijn et al, WWW-05]

Improving Scalability Optimisation techniques –Improve performance of DL reasoners, e.g., [Sirin et al, KR-06] Reduction to disjunctive Datalog [Motik et at, KR-04] –Transform DL ontology to Datalog Ç rules –Use LP techniques to deal with large numbers of ground facts Hybrid DL-DB systems [Horrocks et al, CADE-05] –Use DB to store “Abox” (individual) axioms –Cache inferences and use DB queries to answer/scope logical queries Polynomial time algorithms for sub- ALC logics [Baader et al, IJCAI-05] –Graph based techniques for subsumption computation

Other Reasoning Tasks Querying [Calvanese et al, PODS-98, Fikes et al, JWS, 2004] –Retrieval and instantiation wont be sufficient –Would like, e.g., DB style conjunctive query language –May also need “what can I say about x?” style of query Explanation [Schlobach & Cornet, DL-03; Parsia et al, WWW-04] –To support ontology design –Justifications and proofs (e.g., of query results)

Other Reasoning Tasks “Non-Standard Inferences” (e.g., LCS, matching, …) [Küsters, 2001] –To support ontology integration –To support “bottom up” design of ontologies Design methodologies, e.g., [Wolter & Lutz, KR-06] –Foundational ontologies, conservative extensions, modularisation, etc. Entity SubstantialQualityEvent Achievement Stative Accomplishment PerdurantEndurant

Tools and Infrastructure Editors/environments –Oiled, Protégé, Swoop, Construct, Ontotrack, …

Tools and Infrastructure Editors/environments –Oiled, Protégé, Swoop, Construct, Ontotrack, … Reasoning systems –Cerebra, FaCT++, Kaon2, Pellet, Racer, … Pellet

Summary DLs are a family of logic based KR formalisms –Describe domain in terms of concepts, roles and individuals DLs have many applications –But best known as basis of ontology languages such as OWL

Summary Reasoning is crucial to use of ontologies –E.g., in design, maintenance and deployment Reasoning support via underlying logic –E.g., based on DL systems Many challenges remain, including: –Well founded language extensions –Extending range and effectiveness of reasoning services Enough work to keep logic based KR community busy for many years to come

Acknowledgements Thanks to my many friends in the DL and ontology communities, in particular: –Alan Rector –Franz Baader –Uli Sattler

Resources Slides from this talk – FaCT++ system (open source) – Protégé – W3C Web-Ontology (WebOnt) working group (OWL) – DL Handbook, Cambridge University Press –

DL & KR, Windermere, 30 th May – 5 th June Any questions? Thank you for listening