A Tableaux Decision Procedure for SHOIQ

1 / 24

# A Tableaux Decision Procedure for SHOIQ - PowerPoint PPT Presentation

##### A Tableaux Decision Procedure for SHOIQ

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. A Tableaux Decision Procedure for SHOIQ Ian Horrocks and Ulrike Sattler <horrocks|sattler@cs.man.ac.uk> University of Manchester Manchester, UK

2. SHOIQ: the Final Frontier Ian Horrocks and Ulrike Sattler <horrocks|sattler@cs.man.ac.uk> University of Manchester Manchester, UK

3. Introduction to Description Logics

4. 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 C2) • 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)

5. Applications of DLs • Databases • Ontologies (knowledge bases) • OWL Lite Web Ontology Language based on SHIF • OWL DL Web Ontology Language based on SHOIN • Motivation for OWL design was to 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(up until now)

6. 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) • Individual names (constants) • E.g., John, Mary, Italy • Operators (for forming concepts and roles) restricted so that: • Language 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

7. 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 u8hasChild.(Doctor t 9hasChild.Doctor)

8. The DL Family (2) • S often used for ALC with transitive roles (R+) • Additional letters indicate other extension, 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., >2hasChild, 63hasChild) • Q for qualified number restrictions (e.g., >2hasChild.Doctor) • ALC + R+ + role hierarchy + nominals + inverse + QNR = SHOIQ

9. Knowledge Bases (Ontologies) • A TBox is a set of “schema” axioms (sentences), e.g.: {Doctor v Person, HappyParent´Person u8hasChild.(Doctor t 9hasChild.Doctor)} • An ABox is a set of “data” axioms (ground facts), e.g.: {John:HappyParent, John hasChild Mary} • A Knowledge Base (KB) is a TBox plus and ABox • An ontology is usually taken to be equiv. to a TBox • But in OWL, an ontology is an arbitrary set of axioms (i.e., equiv. to a KB)

10. Description Logic Reasoning

11. Tableaux Reasoning (1) • 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

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

13. Tableaux Reasoning (3) • Tableau rules correspond to constructors in logic (u, 9 etc) • E.g., John:(Person u Doctor) --!John:Person andJohn: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: {Personv9hasParent.Person, John:Person}

14. Tableaux Reasoning (4) • In general, (representation of) model consists of: • Named individuals forming arbitrary directed graph • Trees of anonymous individuals rooted in named individuals

15. Decision Procedure • Algorithm is a decision procedure, 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

16. SHOIQ: Why is it Hard?

17. SHIQ is Already Tricky • Does not have finite model property, e.g.: {ITN v61edge–u8 edge.ITN u9edge.ITN, R:(ITN u60edge–)} • Double blocking • Block interpreted as infinite repetition

18. SHIQ is Already Tricky • Does not have finite model property, e.g.: {ITN v61edge–u8 edge.ITN u9edge.ITN, R:ITN u60edge–u9edge.ITN} • Double blocking • Block interpreted as infinite repetition • Yo-yo problem due to > and 6, e.g.: {John:9hasChild.Doctor u>2 hasChild.Lawyer u62hasChild} • Add inequalities between nodes generated by > rule • Clash if 6 rule only applicable to  nodes

19. SHOIQ: ExpTime ! NExpTime • Interactions between O, I, and Q lead to termination problems • Anonymous branches can loop back to named individuals (O) • E.g., 9r.{Mary} • Number restrictions (Q) on incoming edges (I) lead to non-tree structure • E.g., Mary:61r– • 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

20. 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

21. SHOIQ: Yo-Yo Problem is Back! E.g., KB: {VMP´Person u9loves.{Mary} u9hasFriend.VMP, John:9hasFriend.VMP Mary:62loves–} • Blocking prevented by N-nodes • Repeated creation and merging of nodes leads to non-termination

22. Intuition: Guess Exact Cardinality • New Ro?-rule guesses exact cardinality constraint on N-nodes {VMP´Person u9loves.{Mary} u9hasFriend.VMP, John:9hasFriend.VMP Mary:62loves–} • Inequality between resulting N-nodes fixes yo-yo problem • Introduces new source of non-determinism • But only if nominals used in a “nasty” way • Usage in ontologies typically “harmless” • Otherwise behaves as forSHIQ

23. Summary • DLs are a family of logic based KR formalisms • Well known as basis of ontologylanguages such as OWL • Key motivation for the design of OWL was the existence of DL tableaux decision procedures and implementations • But, no procedure/implementation for OWL DL/SHOIN (up to now) • SHOIQ algorithm solves this (very embarrassing) problem • Ro?-rule introduces new source of non-determinism • But good “pay as you go” characteristics • Implementation already underway in FaCT++ and Pellet systems • Should work well in realistic ontology applications

24. Questions?