Overview

What is DLITE?

• DLITE is an easy way to add description logic (DL) reasoning capabilities to any application.
• DLITE is released as a set of C++ libraries and supporting tools.
• DLITE implements a Tableau-based reasoning algorithm.
• DLITE implements its own ontology language, an easy way to specify the reasoner's rule set.

What is an ontology?

• An ontology is the formal representation of a domain of knowledge.
• The main components of an ontology are:
  • Concepts that are the equivalent of classes in an object model.
  • Roles that describe relationships between concepts
• A concept can be atomic or composed
• Composed concepts are defined with roles and concepts combined using logic connectors.

What is the purpose of a DL reasoner?

• A description logic reasoner is basically a classifier.
• A description logic reasoner can be use to perform subsumption tests between concepts (TBox reasoning).

DLITE components

• DLITE provides its own ontology language.
• Ontologies are stored in ontology stores.
• Ontologies are loaded in stores using the dltools API (see dltools/session.h) or the dlutil command line utility.
• DLITE can be invoked in few lines of code using its high level API.
• DLITE also provides a low level API.

DLITE ontology language

• DLITE implements its own ontology language.
• The DLITE langage offers a convenient way to write simple ontologies.
• The DLITE system can be easily extended to other ontology format. See dlparser/context.h and dlparser/context.cpp for an example of parser/store interface.

The following is an example of ontology that describes familly relationships:

animal   = being & ~human;

human    = being & ~animal;

male     = animal & ~female & ~hermaphrodite;

female   = animal & ~male & ~hermaphrodite;

hermaphrodite = animal & ~male & ~female;

man      = human & ~woman;

woman    = human & ~man;

parent   = human & (?has_child/human | ?married_to/parent);

mother   = parent & woman;

father   = parent & man;

husband  = man & ?married_to/woman;

wife     = woman & ?married_to/man;

married  = human & ?married_to/human;

child    = human & ?has_parent/human;

son      = child & man;

daughter = child & woman;

grand_parent = human & ?has_child/parent;

grand_father = man & grand_parent;

grand_mother = woman & grand_parent;

Ontology store

• A store can contain several ontologies
• A store is database that contains a symbol table and concept definition encoded as binary blobs.
• The DLITE high level API uses the symbol table to interpret reasoning queries written in the DLITE langage syntax.
• The DLITE low level API uses directly the binary blobs. The symbol table is repesented as a list of C preprocessor macros
• Ontologies can be loaded in stores using the dltools API (see iSession::Load in dltools/session.h)
• Ontologies can be loaded in stores using the dlutil command line tool

The following is an example of low-level symbol table:

#ifndef __STORE__
#define __STORE__

// ................................................................................
// Ontologies

#define                                 O_family (0x01000001)

// ................................................................................
// Roles

#define                              R_has_child (0x08000014)
#define                             R_married_to (0x08000017)
#define                             R_has_parent (0x08000028)

// ................................................................................
// Concepts

#define                                  C_being (0x06000002)
#define                                  C_human (0x06000003) // ~animal&being
#define                                 C_animal (0x06000005) // ~human&being
#define                                 C_female (0x06000007) // ~hermaphrodite&~male&animal
#define                          C_hermaphrodite (0x06000009) // ~female&~male&animal
#define                                   C_male (0x0600000b) // ~hermaphrodite&~female&animal
#define                                  C_woman (0x06000010) // ~man&human
#define                                    C_man (0x06000012) // ~woman&human
#define                                 C_parent (0x06000016) // (?married_to/parent|?has_child/human)&human
#define                                 C_mother (0x0600001c) // woman&parent
#define                                 C_father (0x0600001e) // man&parent
#define                                C_husband (0x06000021) // ?married_to/woman&man
#define                                   C_wife (0x06000024) // ?married_to/man&woman
#define                                C_married (0x06000027) // ?married_to/human&human
#define                                  C_child (0x0600002b) // ?has_parent/human&human
#define                                    C_son (0x0600002d) // man&child
#define                               C_daughter (0x0600002f) // woman&child
#define                           C_grand_parent (0x06000032) // ?has_child/parent&human
#define                           C_grand_father (0x06000034) // grand_parent&man
#define                           C_grand_mother (0x06000036) // grand_parent&woman

#endif //__STORE__

Ontologies can be loaded in stores in few lines of code:

const string stDB = "sample.db";
if (tFile::exist(stDB))
{
        cout << "Erase ontologies store" << endl;
        tFile::erase(stDB);
}
                
cout << "Create new store" << endl;
spiSession spSession = iSession::Create(stDB);

cout << "Load ontology in store" << endl;
if (!spSession->Load("family.txt", "family"))
{
        cout << "Parsing errors : " << endl << endl;
        const list<string>& oErrors = spSession->Errors();

        for(list<string>::const_iterator p = oErrors.begin(); p != oErrors.end(); p ++)
        {       
                cout << *p << endl;
        }
}

cout << "Dump store" << endl;
spSession->Dump("sample.h");

DLITE reasoner invocation using the high-level API

This is an example of reasoner invocation using the high-level API:

// Create store session
spiSession spSession = iSession::Create("sample.db");

// Parse concept
sptExpression spExpr = iSession->Parse("father&~animal");

// Check concept satisfiability
bool fRes = iSession->Satisfiable(spExpr);

DLITE reasoner invocation using the low-level API

This is an example of reasoner invocation using the low-level API:

// Create store object
spiStore sp = StoreFactorySQLite::Create("test.db");

// Open store
sp->Open();

// Create reasoner object
spiReasoner spReasoner = iReasoner::Create(sp);

// Build concept "grand_parent& ~animal"
tExprFactory oFact;
oFact.concept(C_grand_parent);
oFact.concept(OP_NEG(C_animal));
oFact.andop();
sptExpression spExpr = oFact.expr();

// Check concept satisfiablity
bool fRet = spReasoner->Satisfiable(spExpr);