12 Março 2003 Departamento de Informática Universidade do Minho Departamento de Informática Lic....

12 Março 2003Departamento de Informática

Universidade do Minho


Departamento de Informática

Lic. Matemática e Ciências de Computação

Laboratório de Métodos Formais

Marlene Azevedo

{[email protected]}



Integration of OntoClean in XOL

XOL++



The Objectives

Motivations

Ontology

XOL Language

OntoClean Method

XOL++

Example

Future Work



Motivations

Know How acquired;

Stimulant subject;

Topic Maps specification;



Ontology

“…an ontology is, simply, a specification of a conceptualization…”

by Gruber

An ontology is a description (like a formal specification of a program) of the concepts and relationships that can exist for an agent or a community of agents;

Ontologies are about languages for expressing contracts between entities;

Ontologies provide a way of capturing a shared understanding of terms that can be used by humans and programs to aid in information exchange and gives a method of providing a specification of a controlled vocabulary.



XOL LanguageIntroduction

Invariants

The language, called XOL, is designed to provide a format for exchanging ontology definitions among a set of interested parties;

The syntax of XOL is based on XML;

The design of XOL deliberately uses a generic approach to define ontologies, meaning that the single set of XML tags (defined by a single XML DTD) defined for XOL can describe any and every ontology.

Significant differences between an ontologyand an DTD.



XOL LanguageComparing DTD and Ontologies

There is nothing in a DTD that corresponds to the is-a relationship of classes that is usually central in an ontology;

DTDs lack any notion of inheritance;

DTDs provide a rather poor means for defining the semantics of elementary tags;

DTDs define the order in which tags appear in a document.



XOL Language<ontology>

<name>...</name><kb-type>...</kb-type><package>...</package><version>...</version><documentation>...</

documentation><class>...</class><class>...</class>...<slot>...</slot><slot>...</slot>...<individual>...</individual><individual>...</individual>...

</ontology>



<!ELEMENT (module | ontology | kb | database | dataset) (name, ( kb-type | db-type)?, package?, version?, documentation?, class*, slot*, individual*)>

– module, ontology, kb, database, dataset are all synonymous

Ontology : : N : Name C1: [Kb-type | Db-type] P : [Package] V : [Version] D : [Documentation] C : Classes S : Slots I : Individuals

inv ont == snameCC(ont) and snameSS(ont) and snameII(ont) and

snameCS(ont) and snameCI(ont) and snameSI(ont) and subClass(ont) and transClass(ont);

XOL LanguageTypes Specification



XOL Language

<class><name>...</name><documentation>...</

documentation><subclass-of>...</subclass-of>

</class>



<!ELEMENT class ( (name, documentation?, ( subclass-of |instance-of | slot-

values)*)>

Classes = C-Id Class;

C-Id = token;

Class : : N : Name

D : [Documentation]

C2 : (C-Id | Slot-values)-set

P : [C-Id-set];




<slot><name>...</name><documentation>...</

documentation><domain>...</domain><slot-value-type>...</slot-

value-type></slot>

XOL Language



<!ATTLIST slot type ( template | own ) "own">

SlotAtt : : T : (Template | OWN);

Template = token;




XOL Language

<individual><name>...</name>

<documentation>...</documentation><instance-of>...</

instance-of><slot-values>

<name>...</name>

<value>...</value>

</slot-values></individual>



<!ELEMENT individual (name, documentation?, (type | slot-

values)*>

Individuals = I -Id Individual;

I -Id = token;

Individual : : N : Name

D : [Documentation]

C4 : (Type | Slot-values)-set

P : [C-Id-set];




XOL LanguageInvariants Specification

Function snameCC

Specification:

snameCC : Ontology -> bool

snameCC(ont) == forall c1 in set dom ont.C &

(forall c2 in set (dom ont.C)\{c1} & ont.C(c1).N <> ont.C(c2).N);

Description:

The same name may not be used for two classes




Function snameSS

Specification:

snameSS : Ontology -> bool

snameSS(ont) == forall s1 in set dom ont.S &

(forall s2 in set (dom ont.S)\{s1} & ont.S(s1).N <> ont.S(s2).N);

Description:

The same name may not be used for two slots




Function snameII

Specification:

snameII : Ontology -> boolsnameII(ont) == forall i1 in set dom ont.I & (forall i2 in set (dom ont.I)\{i1} & ont.I(i1).N <> ont.I(i2).N);

Description:

The same name may not be used for two individuals




Function snameCS

Specification:

snameCS : Ontology -> bool

snameCS(ont) == forall s in set rng ont.S & (forall c1 in set dom ont.C & ont.C(c1).N <> s.N);

Description:

The same name may not be used for class and a slot




Function snameCI

Specification:

snameCI : Ontology -> bool

snameCI(ont) == forall i in set rng ont.I & (forall c1 in set dom ont.C & ont.C(c1).N <> i.N);

Description:

The same name may not be used for class and an individual




Function snameSI

Specification:

snameSI : Ontology -> bool

snameSI(ont) == forall i in set rng ont.I & (forall s1 in set dom ont.S & ont.s(s1).N <> i.N);

Description:

The same name may not be used for a slot and an individual




Function subClass

Specification:

subClass : Ontology -> boolsubClass(ont) == (forall c in set rng ont.C & (forall tid in set c.C2 & is_Class(ont.C(tid)) => tid in set dom

ont.C and is_Slot(ont.S(tid)) => tid in set dom ont.S and is_Individual(ont.I(tid)) => tid in set dom ont.I) and c.P <> nil => c.P subset dom ont.C) and (forall s in set rng ont.S & s.P <> nil => s.P subset dom ont.C)

and (forall i in set rng ont.I & i.P <> nil => i.P subset dom ont.C) ;

Description: Each class must be defined earlier than a subclass




Function transClass

Specification:

transClass : Ontology -> booltransClass(ont) == forall c in set (rng ont.C union rng ont.S union rng ont.I) & dinter getParentsC(ont.C, c) = {} and dinter getParentsS(ont.C, c) = {} and dinter getParentsI(ont.C, c) = {} ) ;

Description: If class A is a subclass of class B, which in turn is a subclass of class C,

only the subclass-of link between A and B should be included in the XOL file.

The getParents function is defined for each kind of possible element in an Ontology, i.e., Class, Slot and Individual. This way, it calculates a set of set of parents of the current node, using the relative level of each parent to decide in witch set to put him. The result is a structure describing each different level of parents the node has.



OntoClean MethodMeta-Properties

It is a method to clean taxonomies according to notions such as: rigidity, identity, unity and dependence. The definition of that notions refer to properties of properties and that are called meta-properties.

Meta-Properties : : R : Rigidity

I : Identity

U : Unity

D : Dependence;



OntoClean MethodRigidity

A property P is:

Rigid (+R), if and only if is necessarily essential to all instances;

Non-rigid (-R), if and only if is not essential to some of its instances;

Anti-rigid (~R), if and only if is not essential to all its instances.

Rigidity = RIGID | NON RIGID | ANTI RIGID;



OntoClean MethodIdentity

A property P:

Carries an IC (+I or -I otherwise), if and only if all its instances can be (re)identified by means of suitable ”sameness” relation;

Supplies an IC (+O or -O otherwise), if and only if such criterion is not inherited by any subsuming property.

Identity = CARRIES_IC | NOTCARRIES_IC |

SUPPLIES_IC | NOTSUPPLIES_IC;



OntoClean MethodUnity

A property P:

Carries unity (+U or -U otherwise), if there is a common unifying relation R such that all the instances of P are wholes under R;

Carries anti-unity (~U), if all its instances can possible be non-wholes (~U implies -U).

Unity = CARRIES_UC | NOTCARRIES_UC | ANTI-UNITY;



OntoClean MethodDependence

A property P is:

Constantly dependent (+D or -D otherwise), if and only if, for all its instances, there exists something they are constantly dependent on.

Dependence= DEPENDENT | NON_DEPENDENT



OntoClean Method Constraints and Assumptions

~R must subsume ~R, i.e., +R can’t subsume ~R;

+U must subsume +U, i.e., -U can’t subsume +U;

~U must subsume ~U, i.e., +U can’t subsume ~U;

+I must subsume +I, i.e., -I can’t subsume +I;

+D must subsume +D, i.e., -D can’t subsume +D;

Properties with incomplete ICs/UCs are disjoint.



OntoClean Method All possible combinations of the meta-properties



XOL++Architecture

OntoClean XOL

XOL++

Specification



1. Class alteration:

Classes = C-Id Class;

C-Id = token;

Class : : N : Name D : [Documentation] C2 : (C-Id | Slot-values)-set P : [C-Id-set] M : Meta-Properties;

XOL++Types Specification



XOL++Invariants Specification

2. Addiction meta-properties invariants:

Function antiRig

Specification:

antiRig : Ontology -> boolantiRig(ont) == forall c in set rng ont.C & (c.M).R = <Anti_Rigid> => forall cid in set c.C2 & cid in set dom ont.C => (ont.C(cid).M).R <> <Rigid> ;

Description: An Anti-Rigid class cannot have a Rigid subclass




Function unity

Specification:

unity : Ontology -> boolunity(ont) == forall c in set rng ont.C & (c.M).U = <Carries_UC> => forall cid in set c.C2 & cid in set dom ont.C => (ont.C(cid).M).U <> <NotCarries_UC> ;

Description: A Carries-UC class cannot have a NotCarries_UC subclass




Function antiUnity

Specification:

antiUnity : Ontology -> boolantiUnity(ont) == forall c in set rng ont.C & (c.M).U = <Anti_Unity> => forall cid in set c.C2 & cid in set dom ont.C => (ont.C(cid).M).U <> <Carries_UC> ;

Description: An Anti-Unity class cannot have a Carries_UC subclass




Function ident

Specification:

ident : Ontology -> boolident(ont) == forall c in set rng ont.C & (c.M).I = <Carries_IC> => forall cid in set c.C2 & cid in set dom ont.C => (ont.C(cid).M).I <> <NotCarries_IC> ;

Description: An Carries_IC class cannot have a NotCarries_IC subclass




Function depend

Specification:

depend : Ontology -> booldepend(ont) == forall c in set rng ont.C & (c.M).D = <Dependent> => forall cid in set c.C2 & cid in set dom ont.C => (ont.C(cid).M).D <> <Non_Dependent> ;

Description: An Dependent class cannot have a Non_Dependent subclass



XOL++3. Consider some basic design principles:

be clear about the domain take identity seriously isolate a basic taxonomic structure make an explicit

distinction between types and roles ( and other property kinds);

WELL-FOUNDED ONTOLOGY.



XOL++Example ontology: OntologyÒntology = mk_OntologyÒntology( "Genealogy", "ocelot", "user", "", "", {1 |-> mk_Ontology`Class ( "Person", "The class of all persons", {2,3}, nil, mk_Ontology`Meta_Properties(<Rigid>,<NotCarries_IC>, <Carries_UC>,<Non_Dependent>))}, {1 |-> mk_Ontology`Slot( "year-of-birth", "An integer that represents the year the person was born", {"person","1","1800","integer"}, mk_Ontology`SlotAtt(<own>)}, {1} ), {1 |-> mk_OntologyÌndividual( "John", nil, {mk_Ontology`Slot_values("year-of-birth", {"1987"}, {})});



XOL++

The main contributions that my work has accomplished are:

to provide a stronger ontological commitments in order to get a ”disciplined” taxonomy;

to reduce the risk of classification mistakes in the ontology development process;

to simplify the update and maintenance process.



Future Work

Adding OntoClean top-level to XOL++;

XOL++2VDM;

VDM2XOL++;

Graphic Interface.

12 Março 2003 Departamento de Informática Universidade do Minho Departamento de Informática Lic....

Documents

Transcript of 12 Março 2003 Departamento de Informática Universidade do Minho Departamento de Informática Lic....