A Practical Implementation of Contextual Reasoning

for the Semantic Web

Sahar Aljalbout, Gilles Falquet and Didier Buchs

Centre Universitaire d’Informatique, University of Geneva, 7 route de Drize, Geneva, Switzerland

Keywords:

Contextual Reasoning, Contexts, Contextual OWL.

Abstract:

Dealing with context-sensitive information is a crucial aspect in the management of semantic web data.

Despite the importance of this topic, there is so far no accepted consensus regarding the precise way of enco-

ding and even more reasoning on contextual knowledge. In this paper, we introduce an approach to reason over

contextual knowledge in RDF, while committing to the semantics of a contextual description logic. The lines

of this paper are many folds. First, we present an extension of OWL 2 DL for contexts, that we call OWL 2

. It is a two-dimensional web ontology language with one dimension for contextualized object knowledge

and one dimension for contexts. Second, we deﬁne an OWL

proﬁle for contextual reasoning, similar to OWL

2 RL. And ﬁnally, we demonstrate that the model can be practically implemented using existing semantic web

technologies, especially using SPIN rules.

1 INTRODUCTION

The contextuality of knowledge is the problem of

the general inability of determining the meaning of

a piece of information or verifying its validity, wit-

hout assuming the context in which this information

has been stated, and thereby, in which it should be

interpreted (Klarman and Guti

errez-Basulto, 2011).

The primary role of contexts in the semantic web is

to provide additional knowledge about individual tri-

ples, such as the source, the occurring time or place,

certainty etc.

Although many data providers and semantic web

practitioners have attempted local approaches for tre-

ating contexts representation; there is, so far, no con-

sensus regarding the precise ways of encoding and

much less reasoning, on contextual knowledge. Ne-

vertheless, the representation of contexts in the se-

mantic web has been considered separately as, ﬁrst,

a data problem, giving rise to several proposals to en-

code contexts into RDF (Nguyen et al., 2014)(Welty

et al., 2006) (Noy et al., 2006), and second, as a theo-

retical problem where several attempts to include the

context dimension to description logics have emerged

(Kutz et al., 2004) (Benslimane et al., 2006) (Klarman

and Guti

errez-Basulto, 2011) .

In this paper, we propose an approach to rea-

son over contextual knowledge in RDF using SPIN

http://spinrdf.org

while committing to the semantics of a contextual

description logic. The key idea behind this approach

is the deﬁnition of a formally solid contextual model,

but also practically applicable to data while using ex-

isting semantic web languages and tools. Throughout

this work, we adopted McCarthy's theory of contexts

(McCarthy, 1987), primarily because this theory of-

fers an instrumental view of contexts, where contexts

are considered as formal objects, describable in ﬁrst-

order logic languages. In order to achieve our goal,

we do the following:

• First, we propose a two-dimensional web onto-

logy language OWL 2 DL

, similar to OWL 2

but based on a two dimensional descrip-

tion logic (2DL) (Klarman and Guti

errez-Basulto,

2011). The idea is to have two interacting lan-

guages: the core and the context language that we

present in section 3.

• Second, in section 4, we propose a proﬁle aimed

at applications that require scalable reasoning wit-

hout sacriﬁcing too much expressive power that

we call OWL

• Finally, the practical implementation of the for-

mal model arises two important questions: how

to encode the contexts in the RDF data model?

And how to practically implement the new con-

http://www.obitko.com/tutorials/ontologies-semantic-

web/owl-dl-semantics.html

Aljalbout, S., Falquet, G. and Buchs, D.

A Practical Implementation of Contextual Reasoning on the Semantic Web.

DOI: 10.5220/0006936802550262

In Proceedings of the 10th International Joint Conference on Knowledge Discovery, Knowledge Engineering and Knowledge Management (IC3K 2018) - Volume 2: KEOD, pages 255-262

ISBN: 978-989-758-330-8

255

textual rules correlated with the generation of new

objects? As a ﬁrst attempt, we extended the ﬂu-

ent model (Aljalbout and Falquet, 2017) to re-

present many dimensions of contexts. We also

demonstrate, that using SPIN, the contextual en-

tailments rules can be feasibly implemented wit-

hout the need for creating new contextual reaso-

ners (section 5).

2 REQUIREMENTS FOR

CONTEXTS REPRESENTATION

AND REASONING

In the search for a suitable knowledge representation

and reasoning model, a relevant question arises about

the requirements that would serve best achieving a

community consensus on this topic. According to

our opinion, the following requirements should be

considered. The following list should therefore not

be considered as ﬁnal, but rather as a starting point

in this discussion. The requirements are divided

into two groups respectively: requirements for

contextual knowledge representation and reasoning

requirements.

Contextual Knowledge Representation Requi-

rements:

• Distinction between the object knowledge and the

contexts knowledge: the union of the vocabula-

ries used for each level must be disjoint. One

should unequivocally recognize if a statement be-

longs to the contextualized object knowledge, or

to the contexts’ knowledge.

• Expressiveness of the model: the model must be

able to deal with polymorphism when adding new

dimensions of contexts. Additionally, relations

between contexts must be clearly and explicitly

speciﬁed within the model.

• Representation compactness: Technically spea-

king, a model that introduces many properties and

objects can lead to undesirable graph size increa-

ses, which oftentimes cause detrimental memory

performance. The worst-case scenario could lead

to an explosion of the number of triples.

Contextual Reasoning Requirements:

• Reasoning should take into the account the con-

textual meta-knowledge and relations between

contexts.

• The contextual layer should not increase the com-

plexity of reasoning. Given the fact that some

of the semantic web languages already exhibit

quite high complexity (e.g., OWL 2, based on the

SROIQ DL, is 2NExpTime-complete (Kazakov,

2008)), we believe that the contextual layer must

be added without any increase in complexity.

3 OWL 2 DL

: A CONTEXTUAL

TWO- DIMENSIONAL WEB

ONTOLOGY LANGUAGE

OWL 2 DL was designed to support the existing

description logic business segment and has desira-

ble computational properties for reasoning systems.

OWL 2 DL is so named due to its correspondence

with description logics. In this section, we introduce

an extension of OWL 2 DL for contexts, that we call

OWL 2 DL

. It contains new contextual construc-

tors and is based on a two-dimensional description lo-

gic (Klarman and Guti

errez-Basulto, 2011) with two

interacting languages: the core language intended to

deﬁne a context-dependent description of the domain

concepts, roles, axioms and the context language used

to express knowledge about contexts.

A contextualized vocabulary is therefore a pair of

DL signatures (

, N

) where

(resp. N

) is a set of domain (resp. context) con-

cept names, N

) is a set of domain (context) role

names, and N

) is a set of domain (context) indi-

viduals names.

3.1 General Syntax

A concept (resp. role) expression is either

• a DL concept expression (resp. role) on the core

signature

, N

• or an expression of the form [K]C or

C (resp.

[K]R or

R) where K is a concept expression on

the context signature

, N

, and C is a

concept expression (resp. role expression) on the

core signature

, N

An axiom expression is either

• a DL axiom expression on the core signature

, N

• an expression of the form K : φ where K is a con-

text name (an element of N

) or a concept ex-

pression on the context signature

, N

and φ is a concept axiom (C v D, C ≡ D,

C dis joint D) or a role axiom (R v S, ,

f unctional(R), transitive(R),. . .) or a class or role

assertion (C(a) , R(a, b)) deﬁned on the core sig-

nature with contextual concept and role expres-

sions. Such an expression states that the axiom

KEOD 2018 - 10th International Conference on Knowledge Engineering and Ontology Development

256

φ holds in the contexts that belong to the context

class K. For instance

before1970 : CanVote v Aged21orMore

states that the axiom CanVote v Aged21orMore

holds in the temporal context before1970.

3.2 Semantics

A contextual interpretation is a pair of interpretations

M = (I, J ) where I = (∆, ·

I[.]

) is the core interpre-

tation, J = (Ω, ·

) is the context interpretation, and

∆ ∩ Ω =

0. ·

I[.]

is a family of interpretation functions,

one for each context k ∈ Ω. .

is the (non-contextual)

interpretation function of every context in the context

language.

The interpretation of the class constructors of the

core language are the following:

• >

I[k]

= ∆

• ⊥

I[k]

• (C t D)

I[k]

= C

I[k]

∪ D

I[k]

• (C uD)

I[k]

= C

I[k]

∩ D

I[k]

• (¬C)

I[k]

= ∆

I[k]

• (∀R.C)

I[k]

= {x ∈ ∆|∀y : (x, y) ∈ R

I[k]

→ y ∈ C

I[k]

}

• (∃R.C)

I[k]

= {x ∈ ∆|∃y ∈ ∆ : (x, y) ∈ R

I[k]

∧ y ∈

I[k]

}

• {i

, i

, . . . , i

}

I[k]

= {i

I[k]

, i

I[k]

, . . . , i

I[k]

}

where C ∈ N

, D ∈ N

, R ∈ N

and i

∈ N

In the following we will consider only contextual

interpretations that satisfy the rigid designator hypot-

hesis (LaPorte, 2006), i.e. i

I[k]

= i

I[k

]

for any i ∈ N

k ∈ Ω, and k

∈ Ω.

The interpretation of the context-based concept

and role forming operators is as follows:

• (

I[k]

={x ∈ ∆|∃y ∈ C

: x ∈ D

I[y]

}

• ([C]D)

I[k]

={x ∈ ∆|∀y ∈ C

→ x ∈ D

I[y]

}

• (

I[k]

={(x, z) ∈ ∆ × ∆|∃y ∈ C

: (x, z) ∈

I[y]

}

• ([C]R)

I[k]

={(x, z) ∈ ∆ × ∆|∀y ∈ C

→ (x, z) ∈

I[y]

}

One can observe that the interpretations of these

constructors are independent of the context k. In

fact, these constructors yield concepts that are non-

contextual (or context independent).

On the other hand, the great appeal of the con-

text theory (McCarthy, 1987) stems from the postu-

late that declares a context as a formal object, as a

consequence it can have its own properties and rela-

tions with other contexts. The axioms of the contexts

language are formulas:

A v B | C(a)

where A ∈ N

, B ∈ N

, C ∈ N

, a ∈ N

. As we

can see, the interpretation of the context language is

standard (non-contextual).

A contextual axiom K : φ is satisﬁed by an inter-

pretation M if in every context k that belongs to the

interpretation of K, the interpretation in k of the con-

cepts, roles and individuals that appear in φ satisfy the

axiom condition

• M |= K :C v D iff ∀k ∈ K

: C

I[k]

⊆ D

I[k]

, where

C ∈ N

and D ∈ N

• M |= K : R v S iff ∀k ∈ K

: R

I[k]

⊆ S

I[k]

, where

R ∈ N

and S ∈ N

• M |= K : prop(R) iff ∀k ∈ K

: R

I[k]

has the

property prop, where prop can be f unctional,

transitive, re f lexive, etc.

• M |= K : C(a) iff ∀k ∈ K

: C(a)

I[k]

• M |= K : R(a, b) iff ∀k ∈ K

: R(a, b)

I[k]

(if K is not a concept expression but a context name

k, K

designates the singleton {k

} in the above ex-

pressions).

3.3 OWL 2 DL

Abstract Syntax

The contextual extension of the web ontology lan-

guage OWL 2 DL

is done systematically by adding

four new abstract syntax constructors whose seman-

tics is given in table 1. The OWL frame-like abstract

syntax is given in the ﬁrst column, and the contextual

description logic (CDL) syntax is given in the second

column.

Table 1: New constructs of the OWL language.

OWL 2 DL

Abstract syntax CDL syntax

SomeConceptValuesFromContext(D[C])

AllConceptValuesFromContext(D[C])) [C]D

SomePropertyValuesFromContext(p[C])

AllpropertyValuesFromContext(p[C]) [C]p

A Practical Implementation of Contextual Reasoning on the Semantic Web

257

4 OWL

: A PROFILE FOR

SCALABLE CONTEXTUAL

REASONING

The evolving OWL 2 standard comes with a proﬁle

called OWL 2 RL. According to the OWL 2 RL W3C

page

, the OWL 2 RL proﬁle is aimed at applications

that require scalable reasoning without sacriﬁcing too

much expressive power. In this section, we deﬁne a

proﬁle for the contextual web ontology language that

we deﬁned in section 3, by adapting the idea of OWL

2 RL to OWL 2 DL

. This is achieved by restricting

the use of constructs to certain syntactic positions,

exactly as in OWL 2 RL

. We limit our description

to the ALCO fragment which is proven to be deci-

dable, with a complexity of reasoning NEXPTIME-

complete (Klarman and Guti

errez-Basulto, 2011).

Reasoning with OWL

is divided into two parts:

reasoning for the object knowledge and reasoning for

the contexts knowledge. However, reasoning for the

contexts language is similar to classical reasoning in

OWL 2 RL, so we will introduce the rules of the

core language. In the original version of OWL 2 RL,

the rules are given as universally quantiﬁed ﬁrst-order

implications over a ternary predicate T. This predi-

cate represents a generalization of RDF triples thus,

T(s,p,o) represents a generalized RDF triple with the

subject s, predicate p, and the object o. Variables in

the implications are preceded with a question mark.

To be able to represent contexts, we introduce a qua-

ternary predicate Q(s, p, o, co) where s is the subject,

p is the predicate, o is the object and co is the con-

text for which the predicate holds. If the ontology has

multiple contextual dimensions (e.g. time and pro-

venance) co must be understood as co

, . . . , co

and

hence Q as a m + 3-ary predicate.

We divided the rules into two categories. In table

2, we redeﬁne the semantics of the classical OWL 2

RL rules of the ALCO fragment by including the con-

textual semantics described in section 3 and in table

3, we introduce new contextual rules for the new con-

cept forming operators that we presented in the pre-

vious section. Syntactic restrictions are applied to the

new constructors: an existential contextual restriction

(

R) may only appear in the left-hand side

of a subclass axiom, whereas a universal contextual

restriction ([C]D, [C]R) may only appear in the right-

hand side.

https://www.w3.org/TR/owl2-proﬁles/

#Feature Overview 3

Figure 1: The design pattern for contextual property asser-

tions.

Figure 2: The design pattern for contextual class assertions.

5 IMPLEMENTATION

In this section, we apply the logical model proposed

in section 3 and 4 on the RDF data model. This invol-

ves the following: i) the choice of a context represen-

tation method that ﬁts the requirements of section 2 ii)

mapping the 2DL to the chosen method iii) choosing

a way to implement the entailment rules.

5.1 Contexts Representation

We previously presented in (Aljalbout and Falquet,

2017) a pattern for the representation of temporal pro-

perties (i.e. ﬂuent) in RDF. This pattern was imple-

mented in a historical knowledge base (Aljalbout and

Falquet, 2018). In this section, we extend this pat-

tern to represent contextual classes and properties as-

sertions with many dimensions of contexts. Figure

1 shows the design pattern of a contextual property

assertion and ﬁgure 3 shows the design pattern of a

contextual class assertion.

We used the standard mapping of OWL to RDF

to map the DL formalization presented in section 3

with the RDF pattern presented in section 5.1. Table

4 and 5 illustrates respectively the mapping of the

two languages to RDF :

• CE[co] denotes a contextual class expression;

• OPE[co] denotes a contextual object property ex-

pression;

• T : O → T (O) where T maps a structural element

speciﬁcation E from the ontology O to a set of

triples T (E) in the RDF graph.

Due to space limitations in the table, we use the preﬁx

owl

instead of owl-contextual.

https://www.w3.org/TR/owl2-mapping-to-rdf/

KEOD 2018 - 10th International Conference on Knowledge Engineering and Ontology Development

258

Table 2: Part of the entailment rules for the core language.

IF THEN

cls-com

¬C

T(?c

, owl:complementOf, ?c

)

Q(?x, rdf:type, ?c

, ?co)

Q(?x, rdf:type, ?c

, ?co)

false

cls-int1

C u D

T(?c, owl:intersectionOf, ?x)

LIST[?x, ?c1, ..., ?cn]

Q(?y, rdf:type, ?c1, ?co)

Q(?y, rdf:type, ?c2, ?co)

...

Q(?y, rdf:type, ?cn, ?co)

Q(?y, rdf:type, ?c, ?co)

cls-int2

C u D

T(?c, owl:intersectionOf, ?x)

LIST[?x, ?c

, ..., ?c

]

Q(?y, rdf:type, ?c, ?co)

Q(?y, rdf:type, ?c

, ?co)

Q(?y, rdf:type, ?c

, ?co)

...

Q(?y, rdf:type, ?c

, ?co)

cls-uni

C t D

T(?c, owl:unionOf, ?x)

LIST[?x, ?c

, ..., ?c

]

Q(?y, rdf:type, ?c

, ?co)

Q(?y, rdf:type, ?c, ?co)

cls-svf1-1

∃R.C

T(?x, owl:someValuesFrom, ?y)

T(?x, owl:onProperty, ?p)

Q(?u, ?p, ?v, ?co)

Q(?v, rdf:type, ?y, ?co)

Q(?u, rdf:type, ?x, ?co)

cls-svf1-2

∃R.C

T(?x, owl:someValuesFrom, ?y)

T(?x, owl:onProperty, ?p)

T(?u, ?p, ?v)

Q(?v, rdf:type, ?y, ?co)

Q(?u, rdf:type, ?x, ?co)

cls-svf1-3

∃R.C

T(?x, owl:someValuesFrom, ?y)

T(?x, owl:onProperty, ?p)

Q(?u, ?p, ?v, ?co)

T(?v, rdf:type, ?y)

Q(?u, rdf:type, ?x, ?co)

cls-avf-1

∀R.C

T(?x, owl:allValuesFrom, ?y)

T(?x, owl:onProperty, ?p)

Q(?u, rdf:type, ?x, ?co)

Q(?u, ?p, ?v, ?co)

Q(?v, rdf:type, ?y, ?co)

cls-avf-2

∀R.C

T(?x, owl:allValuesFrom, ?y)

T(?x, owl:onProperty, ?p)

Q(?u, rdf:type, ?x, ?co)

T(?u, ?p, ?v)

Q(?v, rdf:type, ?y, ?co)

cls-avf-3

∀R.C

T(?x, owl:allValuesFrom, ?y)

T(?x, owl:onProperty, ?p)

Q(?u, rdf:type, ?x, ?co)

Q(?u, ?p, ?v, ?co)

T(?v, rdf:type, ?y)

5.2 Reasoning with OWL

using Spin

SPIN

or in other terms SPARQL rules can run di-

rectly on RDF data. It can be used to encapsulate

reusable SPARQL queries as templates. One advan-

tage of the templates is that they are ﬂexible enough

that you can simply pass parameters to them to custo-

mize their behavior. Then, they can be instantiated in

http://spinrdf.org

any RDF or OWL ontology to add inference rules!

Using TopBraid Composer

, we converted

the OWL

rules, presented in section 4, into

SPIN templates available at the following link

http://cui.unige.ch/isi/owl-rlc. The structure of the

templates is based on the previously deﬁned patterns

in section 5.1. In order to perform contextual reaso-

https://www.topquadrant.com/tools/ide-topbraid-

composer-maestro-edition/

A Practical Implementation of Contextual Reasoning on the Semantic Web

259

Table 3: Entailment rules for the new contexts-based forming operators.

IF THEN

cxt-svf

(

T(?e, owl

: onClass, ?d)

T(?e, owl

: inSomeContextOf, ?co)

Q(?x, rdf:type, ?d, ?y)

T(?y, rdf:type, ?co)

T(?x, rdf:type, ?e)

cxt-avf

([C]D)

T(?e, owl

: onClass, ?d)

T(?e, owl

: inAllContextOf, ?co)

T(?x, rdf:type, e)

Q(?x, rdf:type, ?d, ?y)

T(?y, rdf:type, ?co)

cxt-svf

(

T(?e, owl:onProperty, ?p)

T(?e, owl

:inSomeContextOf, ?co)

Q(?x1, ?p, ?x2, ?y)

T(?y, rdf:type, ?co)

T(?p, rdf:type, ?e)

cxt-avf

([C]P)

T(?e, owl:onproperty, ?p)

T(?e, owl

: inAllContextOf, ?co)

T(?p, rdf:type, ?e)

Q(?x1, ?p, ?x2, ?y)

T(?y, rdf:type, ?co)

Table 4: Samples of the mapping of the core language to RDF.

Element E of the Structural Speciﬁcation

Triples Generated in an Invocation of

T(E)

ClassAssertion( CE[co] a )

T(a) owl

:representedBy :x.

:x rdf:type T(CE) .

:x rdf:type owl

:contextualRelation.

:x owl

:contextualExtent T(co).

ObjectPropertyAssertion( OP[co] a1 a2 )

T(a1) T(OP) :x.

:x rdf:type owl

:contextualRelation .

:x T(OP) T(a2).

:x owl

:contextualExtent T(co).

Table 5: Mapping the context language to RDF.

Element E of the Structural Speciﬁcation

Triples Generated in an Invocation of

T(E)

SomeConceptValuesFromContext(CE[co ])

:x rdf:type owl

:ContextRestriction .

:x owl

:onClass T(CE) .

:x owl

:inSomeContextOf T(co) .

AllConceptValuesFromContext(CE[co ])

:x rdf:type owl

:ContextRestriction .

:x owl

:onClass T(CE) .

:x owl

:inAllContextOf T(co) .

SomePropertyValuesFromContext(OPE[co ])

:x rdf:type owl

:ContextRestriction .

:x owl:onProperty T(OPE) .

:x owl

:inSomeContextOf T(co) .

AllPropertyValuesFromContext(OPE[co ])

:x rdf:type owl

:ContextRestriction .

:x owl:onProperty T(OPE) .

:x owl

:inAllContextOf T(co) .

KEOD 2018 - 10th International Conference on Knowledge Engineering and Ontology Development

260

Figure 3: Template of the cls-int rule.

ning with OWL

, the user has to:

(1) create his triples following the syntax described

in section 5.1.

(2) instantiate the rules under the contextualEntity

form

Figure 3 shows the example of the cls-int rule

encapsulated as a SPIN template. This template, si-

milarly to all others, is implemented using a SPARQL

INSERT request. It declares that the assertion of the

same individual in two classes, holding for the same

context, generates an assertion for this individual

in the intersection of those classes, but also for the

same holding contexts. Notice two things: ﬁrst, the

classes are declared as spin:constraint and second,

the query contains a ﬁlter. The existence of the ﬁlter

is of a major importance because it guarantees that

an existing triple is not generated again and again,

whenever the rules are running.

6 RELATED WORKS

Related works can be divided in two groups: theore-

tical and practical. In the theoretical group, in 2001,

(Ghidini and Giunchiglia, 2001) introduced the idea

of locality and compatibility where reasoning is con-

sidered mainly local and compatibility is argued to be

You can ﬁnd all the rules under spin:modules/

spin:templates

used among the reasoning performed in different con-

texts. In 2003, (Borgida and Seraﬁni, 2003) introdu-

ced the concept of distributed description logics. An

advantage of DDLs is its support for multiple ontolo-

gies. However, the coordination between a pair of on-

tologies can only happen with the use of bridge rules.

In 2004, a new concept called E-connections (Kutz

et al., 2004) emerged: ontologies are interconnected

by deﬁning new links between individuals belonging

to distinct ontologies. One major disadvantage is that

it does not allow concepts to be subsumed by concepts

of another ontology, which limits the expressiveness

of the language. Then, in 2006, (Benslimane et al.,

2006) attempted to extend description logics with new

constructs with relative success. In 2011, a proposi-

tion was argued to use a two dimensional- description

logics. Results showed that this approach does not

necessarily increase the computational complexity of

reasoning. In 2012, (Bozzato et al., 2012) argues that

treating contexts in the semantic web needs more ad-

vanced means, such that contexts should be explicitly

presented and logically treated...

In the practical group, many attempts to ﬁnd a so-

lution to the syntactic restriction of RDF binary rela-

tions emerged. Two types of works were proposed:

(a) Extending the data model or the semantic of RDF

(Dividino et al., 2009) (Hartig and Thompson,

2014) (Nguyen et al., 2014)

(b) Using design patterns: It could be categorized al-

ong three axis (similarly to (Hayes, 2004)): 3D,

3D+1, 4D.

• 3D representation: the contextual index co is

attached to the sentence R(a,b) and thus R(a,b)

holds for co such as RDF reiﬁcation (Berners-

Lee et al., 2001).

• 3D+1 representation: the contextual index co is

attached to the relation R(a,b,co) (Gangemi and

Mika, 2003) (Aljalbout and Falquet, 2017).

• 4D representation: the contextual index co is

attached to the object terms R(a@co, b@co)

where co is the contextual-slice of the thing na-

med (Welty, 2010) (Welty et al., 2006)

7 CONCLUSION

In this paper, we intended to push forward the task

of contextual reasoning in the semantic web. The-

refore, we highlighted in section 2 the requirements

that a contextual reasoning formalism must have, in

order to best serve its purpose. To comply with those

requirements, we proposed OWL 2 DL

, an exten-

sion of OWL 2 DL. The particularity of this web on-

A Practical Implementation of Contextual Reasoning on the Semantic Web

261

tology language is that it consists of two dimensi-

ons: a context-dependent object dimension and a con-

text dimension. Additionally, we deﬁned a proﬁle for

applications that require scalable reasoning that we

call OWL

. It contains new context-dependent rules

and novel rules for handling the new contextual con-

structs. The model does not increase the complexity

of reasoning making it conform to the requirements.

A practical implementation of the model was provi-

ded in section 5 using spin rules and an extension of

the ﬂuent pattern we introduced in a previous work

(Aljalbout and Falquet, 2017). In the future works,

we tend to update OWL

by considering the semantic

relations that could exist between the contexts.

REFERENCES

Aljalbout, S. and Falquet, G. (2017). Un modele

pour la representation des connaissances temporel-

les dans les documents historiques. arXiv preprint

arXiv:1707.08000.

Aljalbout, S. and Falquet, G. (2018). A semantic

model for historical manuscripts. arXiv preprint

arXiv:1802.00295.

Benslimane, D., Arara, A., Falquet, G., Maamar, Z., Thiran,

P., and Gargouri, F. (2006). Contextual ontologies.

Advances in Information Systems, pages 168–176.

Berners-Lee, T., Hendler, J., Lassila, O., et al. (2001). The

semantic web. Scientiﬁc american, 284(5):28–37.

Borgida, A. and Seraﬁni, L. (2003). Distributed description

logics: Assimilating information from peer sources. J.

Data Semantics, 1:153–184.

Bozzato, L., Homola, M., and Seraﬁni, L. (2012). Con-

text on the semantic web: Why and how. ARCOE-12,

page 11.

Dividino, R., Sizov, S., Staab, S., and Schueler, B. (2009).

Querying for provenance, trust, uncertainty and other

meta knowledge in rdf. Web Semantics: Science, Ser-

vices and Agents on the World Wide Web, 7(3):204–

219.

Gangemi, A. and Mika, P. (2003). Understanding the se-

mantic web through descriptions and situations. In

OTM Confederated International Conferences” On

the Move to Meaningful Internet Systems”, pages

689–706. Springer.

Ghidini, C. and Giunchiglia, F. (2001). Local models se-

mantics, or contextual reasoning= locality+ compati-

bility. Artiﬁcial intelligence, 127(2):221–259.

Hartig, O. and Thompson, B. (2014). Foundations of an al-

ternative approach to reiﬁcation in rdf. arXiv preprint

arXiv:1406.3399.

Hayes, P. (2004). Formal unifying standards for the re-

presentation of spatiotemporal knowledge a report

on arlada task 02ta4-sp1-rt1” formalisms for spatio-

temporal reasoning” advanced decision architectures

alliance.

Kazakov, Y. (2008). Riq and sroiq are harder than shoiq. In

KR 2008. AAAI Press.

Klarman, S. and Guti

errez-Basulto, V. (2011). Two-

dimensional description logics for context-based se-

mantic interoperability. In AAAI.

Kutz, O., Lutz, C., Wolter, F., and Zakharyaschev, M.

(2004). E-connections of abstract description systems.

Artiﬁcial intelligence, 156(1):1–73.

LaPorte, J. (2006). Rigid designators.

McCarthy, J. (1987). Generality in artiﬁcial intelligence.

Communications of the ACM, 30(12):1030–1035.

Nguyen, V., Bodenreider, O., and Sheth, A. (2014). Don’t

like rdf reiﬁcation?: making statements about state-

ments using singleton property. In Proceedings of the

23rd international conference on World wide web, pa-

ges 759–770. ACM.

Noy, N., Rector, A., Hayes, P., and Welty, C. (2006). Deﬁ-

ning n-ary relations on the semantic web. W3C wor-

king group note, 12(4).

Welty, C. (2010). Context slices: representing contexts in

owl. In Proceedings of the 2nd International Confe-

rence on Ontology Patterns-Volume 671, pages 59–60.

CEUR-WS. org.

Welty, C., Fikes, R., and Makarios, S. (2006). A reusable

ontology for ﬂuents in owl. In FOIS, volume 150,

pages 226–236.

KEOD 2018 - 10th International Conference on Knowledge Engineering and Ontology Development

262