74.419 Artificial Intelligence Description Logics see references last slide Description Logics Background and Motivation for DL Relation between DL and FOPL (extensional Semantics) Example Definitions The horrible truth of DL T-Box, A-Box LOOM

Description Logics - Background Prevent flaws of Semantic Networks; provide clear semantics of nodes and links Derived from Inheritance Hierarchies (IS-A hierarchies; taxonomies; terminologies) and Frame Systems Concepts, Roles, Features Series of KR Languages starting with KL-ONE, later KL-TWO, LOOM, CLASSIC, ... Relate to FOPL via extensional semantics Applied e.g. in Semantic Web Languages (DAML+OIL)

Description Logics - Overview DL provide language constructs to define concepts. Concepts are interpreted as sets of individuals (extensional semantics). Concept definitions are linear expressions, combining concepts, roles, etc. to express constraints on the fillers of the concept. The IS-A hierarchy is reflected in the subsumption relation (super-classsub-class relation), interpreted through set-inclusion.

Description Logic Notation The examples on the following slides are based on Ian Horrocks' and Ulrike Sattler's notation for Description Logic (see references at the end of the presentation). A conversion of these examples into PowerLoom notation is given on the last slides. Description Logics Basic Elements

Concepts Roles Features / Attributes Definition of concepts

e.g. father(AND (Parent Man)), Biped (AND (Animal (exactly 2 has-legs Legs))) Primary / Atomic Concepts and Roles (not completely defined) Individual Concepts (define singletons) Instances (entities) Description Logics Principles Concepts correspond to unary predicates or sets Roles correspond to binary predicates / relations

Features correspond to functions Concept-Definitions constrain filler-sets composed of concepts, roles, role restrictions using AND, OR, min-number, max-number etc. (Human (AND (Animal Biped Featherless)) Concept Definitions - Example (defconcept Person primary-concept) I (Person) D (defrole gender atomic-role)

I (gender) DD (defconcept Parent (AND Person (has-child.Person)) I (Parent) I (Person) {xD | y: (x,y) I (has-child) y I (Person) } (defconcept Man (AND Person (gender.Male)) I (Man) I (Person) {xD | y: (x,y) I(gender) y I (Male)} Basic Architecture and Functions

T-Box terminological knowledge (definition of concepts) A-Box assertional knowledge (statements about instances, concrete objects) Classification - insert concept into hierarchy based

on it's description / definition TELL insert knowledge into KB, e.g. define new concept or assert instance info ASK querying KB, e.g. ask about existence of instance T-Box Example T-Box (Concept Definitions) (defconcept Person) (defrelation has-child :domain Person :range Person)

(defconcept Male) (defconcept Person-with-Sons :is (:and Person (:at-least 1 has-child Male))) (defconcept Person-with-Two-Sons :is (and Person (:exactly 2 has-child Male))) A-Box Example A-Box (Assertions, Statements) (tell (Person Fred)) (tell (has-child Fred Sandy)) (tell (Male Sandy))

Example KB (defconcept Person) (defrelation has-child :domain Person :range Person) (defconcept Male) (defconcept Person-with-Sons :is (:and Person (:at-least 1 has-child Male))) (defconcept Person-with-Two-Sons :is (and Person (:exactly 2 has-child Male))) (tell (Person Fred)) (tell (has-child Fred Sandy)) (tell (Male Sandy))

Example Reasoning (defconcept Person) (defrelation has-child :domain Person :range Person) (defconcept Male) (defconcept Person-with-Sons :is (:and Person (:at-least 1 has-child Male))) ... (tell (Person Fred)) (tell (has-child Fred Sandy)) (tell (Male Sandy))

Conclude: (Person-with-Sons Fred) LOOM - Program: Definitions > (defconcept air-base :is-primitive (and Military-Installation (exactly 1 name) (at-least 1 runway-length) (exactly 1 service-branch))) |C|AIR-BASE > (defrelation name :range string) |R|NAME > (defrelation runway-length

:domain air-base :range number) |R|RUNWAY-LENGTH LOOM - Program: tell > (tellm (create ab-1 air-base) (name ab-1 "Atlanta NAS") (runway-length ab-1 12050))) Recognition changes at agent time 1: entry: AB-1 |C|MILITARY-INSTALLATION entry: AB-1 |C|AIR-BASE > (tellm (create ab-2 air-base) (name ab-2 "Mainland NAS")

(runway-length ab-2 9000)) Recognition changes at agent time 2: entry: AB-2 |C|MILITARY-INSTALLATION entry: AB-2 |C|AIR-BASE inferred LOOM - Program: retrieve > (retrieve ?p (air-base ?p)) ( |I| AB-1 |I| AB-2 ) Instances AB-1, AB-2

> (retrieve ?p (and (air-base ?p) (for-some (?l) (and (runway-length ?p ?l) (> ?l 10000))))) ( |I| AB-1 ) Instance AB-1 Loom Classifier One main task and purpose of Description Logics is to provide Classification algorithms, to insert newly

defined concepts into the hierarchy, ensuring the correctness and consistency of the subsumption relation. The LOOM Classifier uses a graph-like representation of definitions, which are firstly formulated as predicate expressions. Classification in LOOM is based on structural comparison of two graphs, and involves reasoning and inference mechanisms, like elaboration. Definition At-Least-One-Son At-Least-One-Son defines the set of all persons that

have at least one son: (defrelation At-Least-One-Son (?p) :iff-def (and (Person ?p) (>= (cardinality (setof (?c) (son ?p ?c))) 1)) Definition More-Sons-Than-Daughters More-Sons-Than-Daughters defines the set of persons that have more sons than daughters: (defrelation More-Sons-Than-Daughters (?pp)

:iff-def (and (Person ?pp) (> (cardinality (setof (?b) (son ?pp ?b))) (cardinality (setof (?g) (daughter ?pp ?g))) )) ) Structural Subsumption The PC classifier can prove that At-Least-One-Son subsumes More-Sons-Than-Daughters, i.e. it will classify More-Sons-Than-Daughters below At-LeastOne-Son. The PC classifier employs a structural subsumption

test. Roughly speaking, to prove that a description A subsumes a description B, a structural subsumption prover attempts to demonstrate that for every structural component in (the internal representation for) the definition of A there exists a corresponding component in (the internal representation for) the definition of B. Graph Representation The PC classifier parses definitions phrased in the prefix predicate calculus into graph-based structures. All subsequent reasoning involves operations on these

graphs. Each of these graphs represents a set expression, consisting of a list of domain variables and a set membership test (the definition). A node can represent a variable, a constant, or another set expression. A predicate applied to a list of terms is represented by a (hyper) edge connecting the nodes corresponding to the terms in the list, together with a pointer to the node that corresponds to the predicate. Nodes representing skolem variables are introduced to represent function terms. Variables other than domain variables are assumed to be existentially quantified. This graph representation eliminates the use of (or need for) universal quantifiers.

Transformation 1: At-Least-One-Son The At-Least-One-Son relation defined above is associated with a graph [1] representing the following set: (setof (?p) (and (Person ?p) (>= (cardinality (setof (?c) (son ?p ?c))) 1) Transformation 2: At-Least-One-Son Use set-of expressions and skolemization:

(setof (?p) (exists (?s1 ?card1) (and (Person ?p) set of sons of person ?p (= ?s1 (setof (?c) (son ?p ?c))) (cardinality ?s1 ?card1) (>= ?card1 1)))) number of sons of person ?p

Transformation: More-Sons-Than-Daughters Here is the graph [2] for More-Sons-Than-Daughters: (setof (?pp) (exists (?s2 ?s3 ?card2 ?card3) (and (Person ?pp) (= ?s2 (setof (?b) (son ?pp ?b))) (= ?s3 (setof (?g) (daughter ?pp ?g))) (cardinality ?s2 ?card2) (cardinality ?s3 ?card3) (> ?card2 ?card3)))) more sons than daughters

Structural Mapping and Substitution To prove that At-Least-One-Son subsumes MoreSons-Than-Daughters, we look for a substitution mapping nodes in [1] to nodes in [2] such that for each edge in the graph [1] there is a corresponding edge in the graph [2]. The correct substitution is ?p ?pp; ?s1 ?s2; set of sons

?card1 ?card2 number of sons except that there is a problem - no edge in graph [2] corresponds to the edge (>= ?card1 1) in graph [1]. Elaboration However, a constraint representing the missing edge (>= ?card2 1) is logically derivable from the existing constraints/edges present in graph [2] The addition of this missing edge would result in a set expression logically equivalent to the expression [2].

Using a process we call elaboration, the PC classifier applies forward chaining rules to augment each graph with edges that logically follow from the existence of other edges already present in the graph. A graph is elaborated by applying elaboration rules (see Tables on following slides) repeatedly until no additional structure can be produced. Result for Sons-and-Daughters In the case of graph [2], the following edges would be added during elaboration: (Integer ?card2), (>= ?card2 0),

(Integer ?card3), (>= ?card3 0), (>= ?card2 1) This last edge represents our missing edge. It is derived from the fact that ?card3 is non-negative, ? card2 is strictly greater than ?card3, hence greater than zero, and that ?card2 is an integer. Inequality Rules Cardinality Rules Contained-in and Other Rules

PowerLoom Notation A conversion of the DL examples given in the notes into PowerLoom notation is following on the next slides. Examples in PowerLoom (PL) Notation Slide 6: father (AND (Parent Man)) PL: (defconcept father (and (Parent Man))) Biped (AND (Animal (exactly 2 has-legs Legs))) PL: (defconcept Biped (and (Animal (exactly 2 has-legs Legs))))

Slide 7: (Human (AND (Animal Biped Featherless)) PL: (defconcept Human (AND (Animal Biped Featherless))) Examples in PowerLoom (PL) Notation Slide 8: (defconcept Parent (AND Person (has-child.Person)) PL: (defconcept Parent (?p) (and (?p Person) ((?p has-child):-> (?c Person)))) Note: has-child has to be defined beforehand. (defconcept Man (AND Person (gender.Male))

PL: (defconcept Man (?m) (and (?m Person) ((?m gender):-> (Male)))) Gender has to be defined beforehand. References Description Logic Home Page, http://www.dl.kr.org/ J. Heinsohn

et al.: An Empirical Analysis of Terminological Representation Systems, Artificial Intelligence 68(2):367-397, 1994. http://www. cs.umanitoba.ca/~cs419/2004/Papers/ heinsohn-etal-aij-94.pdf LOOM Home Page, http://www.isi.edu/isd/LOOM/LOOM-HOME.html Robert M. MacGregor

: A Description Classifier for the Predicate Calculus. Proc. Twe lfth National Conference on Artificial Intelligence, (AAAI 94), pp. 213-220, 1994. http://www.isi.edu/isd/LOOM/papers/macgrego r/aaai94.pdf Ian Horrocks and Ulrike Sattler, DL Presentations, http:// www.cs.man.ac.uk/~horrocks/Slides/index.html