Knowledge Representation and Reasoning using PowerLoom

PresenterShamima Mithun

Overview

Introduction Terminology and Propositions PowerLoom Knowledge Base (KB) Construction

Process Reasoning in PowerLoom KB Constructions and Query using PowerLoom Conclusion

Introduction

PowerLoom is a Description Logics system. is a highly expressive language for knowledge

representation. is the successor to the Loom knowledge

representation system. uses a fully expressive, logic-based

representation language (a variant of KIF). provides language and environment to develop

intelligent applications [1].

Introduction (contd.)

uses a Prolog-style backward chainer as its inference engine [1].

is not a complete theorem prover, but it can handle complex rules, negation, subsumption, and restricted forms of higher order reasoning.

handles recursive rules without the risk of infinite recursion.<sentence>::= <constant>│<longsent> │<equation> │…

<longsent>::= (not<sentence>) │(and <sentence>*) │…

T-Box & A-Box Knowledge base comprises two components

The T-Box introduces terminologies (concept, role/relation).

Concepts: denote sets of individuals (e.g. person). Relations: denote binary relations between individuals (e.g. is_married_to).

The A-Box asserts on the constants.Two kinds of assertions:

Concept assertion, e.g. person (Mary), person (Peter).

Role assertion, e.g. is_married_to (Peter, Mary).

Terminology and Propositions

In PowerLoom KB represents physical or virtual world.

Term are KB objects that models real world entities. Every term must have distinct name (e.g. person).

Terms are categorized or related to one another by object called relations.

“A proposition is a logical sentence that has an associated truth value” (e.g. John is a person).

PowerLoom KB Construction Process

PowerLoom KB is constructed by first defining the terminology (concepts and

relations) for a domain. then asserting additional rules and facts about

that domain. fact can be asserted and later retracted, so

the answers returned by the queries may change over time.

PowerLoom Commands

Defines concept, relation, function and rules using

defconcept, defrelation, deffunction, defrule.

Add/Remove facts from KB withassert and retract

Query KBask, retrieve

Note: Relations should be defined before they are used within association and queries.

More on syntactic construct

Adopt a prefix notation (similar to KIF). For example, (=(+ 2 3)5)

Construct complex sentence from simpler forms using the logical connectives and, or, not, ,+, =>, <=, and the quantifiers exists and forall.

In PowerLoom concepts and instances of concept are organized hierarchically.

Knowledge inherits down the hierarchy from parent to children. Fix Furniture and Movable Furniture

inherit all facts asserted on their

parent Furniture. Door, Window,

Chair, and Sofa also inherit facts

from their parents but they do

not have access facts

asserted to their siblings.

PowerLoom KB Organization

Furniture

FixFurniture

MovableFurniture

Door Window Chair Sofa

Reasoning in PowerLoom A reasoner, PowerLoom’s description classifier,

uses technology derived from the Loom classifier[1].

Classifier computes the subsumption relation between concepts using their description.

SubsumptionSubsumption is typically written as C D. Determining subsumption is the problem of checking whether the concept denoted by D (the subsumer) is considered more general than the one denoted by C (the subsumee), e.g. student person.

Reasoning in PowerLoom (contd.)

Satisfiability

During modeling a domain we construct terminology (by defining new concepts). The new concept could not be contradictory with defined concepts.

Building and Querying KB using PowerLoom

Model Domain

Color

Fixed-Furniture

Movable-Furniture

Furniture

Age

Size

BigSmall

GreenRed NewOld

IS-A

Door Window Chair Sofa

Define Concept|=(defconcept furniture)

|c| FURNITURE

|= (defconcept movable-furniture (?f furniture))

|c| MOVABLE-FURNITURE

|= (defconcept fixed-furniture (?f furniture))

|c| FIXED-FURNITURE

|=(defconcept chair (?f movable-furniture))

|c| CHAIR

|= (defconcept sofa (?f movable-furniture))

|c| SOFA

Define Concept (contd.)

|= (defconcept window (?ff fixed-furniture))|c| WINDOW|= (defconcept door (?ff fixed-furniture))|c| DOOR|= (defconcept age (?a) :<=> (member-of ?a (setof new old))) |c| AGE|= (defconcept color (?c) :<=> (member-of ?c (setof green

red blue)))|c| COLOR|= (defconcept size (?s) :<=> (member-of ?s (setof small big)))|c| SIZE

Model Domain

Color

Fixed-Furniture

Movable-Furniture

Furniture

Age

Size

BigSmall

GreenRed NewOld

IS-A

Door Window Chair Sofa

has-colorhas-age

has-size

Define Relation

|= (defrelation has-age ((?f furniture) (?a age))) |r| HAS-AGE|= (defrelation has-color ((?f furniture) (?c color))) )|r| HAS-COLOR|= (defrelation has-size ((?f furniture) (?s size)))|r| HAS-SIZE

Model Domain

Color

Fixed-Furniture

Movable-Furniture

Furniture

Age

Size

has-size

has-age

has-color

BigSmall

GreenRed NewOld

IS-A

Door Window Chair Sofa

Value Assertion

|= (assert(has-size chair big))|P|(HAS_SIZE CHAIR BIG) |= (assert(has-color sofa red))|P|(HAS_COLOR SOFA RED) |= (assert(has-age chair new))|P|(HAS_AGE CHAIR NEW) |= (assert(has-age door old))|P|(HAS_AGE DOOR OLD) |= (assert(has-color window green))|P|(HAS_COLOR WINDOW GREEN)

Query the KB: Ask

|= (ask (has-size chair big))

TRUE

|= (ask (has-age door new))

FALSE

|= (ask (has-color door red))

UNKNOWN

Query the KB: Retrieve & Retract|= (retrieve all (furniture ?x))There are 4 solutions: #1: ?X=CHAIR #2: ?X=SOFA #3: ?X=WINDOW 4: ?X=DOOR

|=(retrieve (has-color sofa ?x))There is 1 solution so far: #1: ?X=RED

|= (retract (has-color sofa red)) |P?|(HAS-COLOR SOFA RED)

|= (retrieve (has-color sofa ?x)) No solutions.

Others

|= (all-facts-of chair)

(|P|(CONCEPT CHAIR) |P|(HAS-SIZE CHAIR BIG)

|P|(HAS-AGE CHAIR NEW) |P|(FORALL (?x1)(<=

(MOVABLE-FURNITURE ?x1) (CHAIR ?x1)))

|P|(FURNITURE CHAIR)

Conclusion

PowerLoom is a very expressive language which assists to develop intelligent applications.

Even though its backward chainer is not completely implemented it can handle most of the inference rules as well as recursive rules.

It provides API for easy integration with programs in Java, C++, and Lisp.

References

PowerLoom Homepage

http://www.isi.edu/isd/LOOM/PowerLoom/ Daniele Nardi and Ronald J. Brachman. An introduction to

Description Logics. In Baader, Calvanese, McGuinnes Nardi and Patel-Schneider, (eds). The Description Logics Handbook, chapter 1. Cambridge University Press, 2003.

Franz Baader and Werner Nutt. Basic Description Logics. In Baader, Calvanese, McGuinnes Nardi and Patel-Schneider, (eds). The Description Logics Handbook, chapter 2. Cambridge University Press, 2003.

Thanks