Survey of Temporal Knowledge Representation

(Second Exam)

Sami Al-Dhaheri

The Graduate Center, CUNY

Department of Computer Science

June 20, 2016

Abstract

Knowledge Representation (KR) is a subfield within Artificial Intelligence that aims to represent,

store, and retrieve knowledge in symbolic form that is easily manipulated using a computer.

The vision of Semantic Web has recently increased because of the interest of using and a applying

the Knowledge Representation methodology in both academia and industry. Knowledge

Representation formalism are often named as one of the main tools that can support the

Semantic Web.

Knowledge Representation has many forms, including logic-based and non-logic based

formalisms. This survey will only be concerned with logic-based KR. The review will present

various methods authors have used in applying logic-based KR. We will present each

methodology with respect to its formalism, and we will present the reasoning in Description logic.

The survey will also discuss possible temporal extensions of Description Logic, RDF and OWL.

1 Introduction

Knowledge Representation and Reasoning is a scientific domain within the area of Artificial

Intelligence in Computer Science. It aims to encode human knowledge in a computerized

fashion using formal models that allow the computer to take human knowledge and represent

it in a meaningful manner [1]. In this context, computers are able to represent implicit

knowledge found within the encoded body of human knowledge provided to the system, thus

resulting in a behavior that is known as “Intelligent” one. Computer Scientists have devised

systems to represent knowledge and make inferences based on the encoded knowledge. Such

systems have been referred to as Knowledge Base Systems; their main components are a

knowledge base and a reasoning engine.

Mathematicians were the first to explore and apply logic-based Knowledge Representation

before the computers revolution. However, the field acquired more recognition during the

1970s with the rise of the field of Computer Science in the academy and industry. Two forms of

Knowledge Representation emerged: logic based and non-logic based. With the introduction of

the World Wide Web in 1989, Knowledge Representation became of crucial importance to

achieve its goal of representing implicit knowledge found within the wide array of information

created and shared by people [2].

Knowledge Representation has played a significant role in the development of Semantic Web.

One of the areas KR has been active in within Semantic Web is Ontologies. Ontologies provide

vocabulary for annotations of semantics in application domains. The first and foremost

significant aim of Knowledge Representation is creating new forms of knowledge and reasoning

by using existing ones. Computers can be taught to use encoded human languages to extract

implicit trends, dimensions, semantics and other forms of knowledge. The formal specification

of things is also accessible to machines. Practically, a standard web ontology language is needed

and have been developed for the above applications.

Knowledge Representation becomes useful in many fields including medical decisions’ support,

financial decision making, institutional research frameworks and others. The developed

Knowledge Based Systems can be used to not only extract knowledge, but also instruct to make

decisions based on such knowledge. Therefore, the wide application of Semantic Web renders

Knowledge Representation as one of the most worthy topics of research and development.

Science not only strives to explain variance in a given variable, it also tries to develop an

understanding of a particular phenomenon. One element scientists consider in their analyses is

the effect of time. As in social sciences, time matters and witnesses many outcomes. It is also of

utmost significance to Computer Scientists, especially in Semantic Web. For instance, the

description of a concept in ontology often reference to temporal patterns. e.g., the definition of

salary in employee ontology that changes over time. Similarly, time plays a critical role when

using Description logics (DL) to represent and reason about conceptual representation of

temporal knowledge. Therefore, models used in Knowledge Representation includes time as an

important element.

We can represent “static knowledge" that means not changing. Besides that, "temporality" is an

important issue imposed by the flows of time. The issue comes when the represented

knowledge changes over time. Which is called dynamic knowledge. Dynamic knowledge is

maintained by updating, deleting, or putting "outdated flag" on the "old" knowledge. In the

past two decades, temporal databases have been extensively researched. They cover several

dozens of temporal data models that are mainly extension of the relational model. Temporal

query languages are proposed. Issues of representing time have also been tackled. In general, a

knowledge representation formalism can be extended to cover the temporal part of the

knowledge. There are two basic strategies: one is to formally extend the model. For instance,

extend the Description Logics to Temporal Description Logics. The other is that the temporal

extension is added on top of the formalism. Ontology versioning is an example. The reification

approach is somewhat between these two extremities [3].

In this survey we review the recent research and developments in KR. We examine various

logic-based knowledge representation approaches with the aim of deciding upon a better

approach for temporal knowledge representation. Our focus is on temporal aspect of

knowledge representation within semantic web. It’s worth mentioning that much of this survey

is concerned with logic-based knowledge representation.

In this survey, we will explore important issues in knowledge representation formalisms,

including their formal semantics when a syntax is referred, and reasoning and inference

services provided. Temporal extensions will be presented next. The survey paper is organized as

follows: in section 2, different logic-based knowledge representation formalisms are

introduced. Section 3 discusses various nonlogic-base knowledge representation technologies

associated with the Semantic Web .Section 4 covers the temporal extension to Description

logics, Temporal RDF and Temporal OWL. Section 5 provides a brief comparisons between the

formalisms. Section 6 general discussion. Finally, in Section 7, we draw conclusion.

2 Logic-based Knowledge Representation Formalisms

One may classify knowledge by its nature: declarative or procedural. Declarative knowledge

represents simple facts, it includes the truth of propositions or statements about the world. For

instance, humans can eat at any given time of the day. Declarative knowledge can be easily

retrieved from a knowledge base using a simple operation, a look up process. The retrieval of

declarative knowledge could be the solution for a problem a user has, or it could be part of a

larger solution.

Conversely, procedural knowledge involves knowing HOW to do something. It details a set of

processes as opposed to facts. Procedural knowledge outlines a step by step process for

reaching a particular end or solution to a problem facing the user. For instance, operating a

vehicle on the road necessitates procedural knowledge allowing a driver to fulfill the end of

driving a car on a certain road. Unlike declarative knowledge, simple look up operations are

inadequate to retrieve procedural knowledge. To retrieve procedural knowledge one may

resort to the use and implementation of algorithms. Moreover, procedural knowledge involves

implicit learning.

Researchers developed a number of knowledge representation formalisms within the semantic

web context. The decision of choosing a particular formalism heavily depends on the need and

nature of the problem faced by the user. Semantic networks, production rules and formal logic

provide the main knowledge representation formalisms in semantic web. RDF graphs can be

utilized to specify models of semantic networks [4]. Logic is used to recognize a precise

semantic interpretation for both of the other forms. By providing formal semantics for

knowledge representation languages.

A Knowledge representation formalism help in representing the relevant knowledge of a

specific domain as facts and rules in such a way that make it efficiently retrievable. Despite this

useful application of KR, one may be interested in retrieving knowledge that is not explicit in

the knowledge base. One may be interested not only in facts or rules, but also in reasoning

based on a combination of declarative, as well as procedural knowledge. In retrieving explicit

knowledge from a knowledge base, one may need extra programs in order to specify what is

wanted from the machine. In the case of implicit knowledge representation, this process

becomes more complex. The process of asking the machine to produce implicit knowledge

based on explicit knowledge in a KB is referred to as reasoning or inferences. Two main

categories of inference problems are: subsumption and instance problems. The former is to

check whether one concept is more specific than the other. The latter is to check if a given

individual is an instance of a particular class [5]. In this survey, whenever reasoning and/or

inference are mentioned, they correspond to similar concepts stated above.

A knowledge-based system is based on acquired knowledge of a specific domain represented

using some formalism. Basic components of a knowledge-based system are: knowledge base

(KB) and an inference engine/reasoning mechanism that simulates the problem solving process.

The knowledge acquisition is also a core component. Reference [6] provides a survey of

fundamental knowledge acquisition models and techniques. The acquisition of knowledge is not

a trivial task. Each Knowledge Representation formalism has an expressive power and a

complexity for retrieving and reasoning about a specific knowledge. An efficient knowledge

based system that is a component of knowledge base and an inference engine should have high

expressive power and low complexity.

The knowledge representation formalism in this survey will be outlined as follows. In Section

2.1 we give a brief introduction about first-order logic, which has an advantages over the

varieties of other logics due to its expressivity, however it has a decidability problem. In Section

2.2 we introduce modal logic. Modal logic is appropriate for small knowledge-based system,

knowledge representation is more restricted in modal logic. Section 2.3 focuses on description

logics, an extension of the semantic network and frame formalism. Section 2.4 concentrates on

temporal logics.

2.1 First-Order Logic

First-Order Logic (FOL) is the most commonly studied and implemented logic, it is one of the

widely used Knowledge Representation formalisms. Computer scientists, especially those

working within the umbrellas of Artificial Intelligence picked up the most applied form of logic

FOL [7]. It comes out of propositional logic that postulates the existence of real facts that could

be obtained using predicates. This formalism mostly concerns declarative knowledge.

Nevertheless, it could be used to represent complex facts or concepts by combing two simple

declarative facts by logical connectives such as AND, OR. With the first order logic, problem

solving could be achieved by applying logic inference to facts and sentences. The mostly

involved operation would be "look-up" operations, followed by some reasoning algorithm such

as Tableau algorithm or resolution proof methods, which are the two main methods of

reasoning in FOL.

One of the greatest concern when applying FOL is in determining the validity of formulae

involving sentences. In particular, we are interested in whether a set of sentences S logically

entails a sentence R. The set S of sentences used as a basis for calculating entailment can be

thought of as a knowledge base (KB). This pertains to whether the specified mathematical

formulae are doing what they are intending to do. The application of FOL is intended to

produce meaningful representation of knowledge based on a knowledge base, body of facts.

FOL usually rely on half a dozen symbols to draw a given reasoning based on a given knowledge

base. Depending on the choice of predicates, highly expressive knowledge representations can

be constructed using these elements .Nevertheless, FOL does not perform greatly when

considering its complexity. FOL faces a challenge when it comes to its reasoning algorithm,

when we represent a lot of domain knowledge and the knowledge-base gets large, FOL will

eventuality become undecidable. Therefore, FOL is not the most preferred formalism when it

comes to the current practice of knowledge representation.

We first define a syntax for the first-order logic and then we define its meaning (semantics). We

incorporate the syntax and semantic as outlined in [8].

A vocabulary of a first-order logic is comprised of the following.

• A set of unique predicate symbols of arity n. These predicate symbols are often denoted using

capitalized letters, or more commonly using P, and Q.

Usually (but not always) the vocabulary also contains:

• A set of unique constant symbols. These symbols are often denoted using lower case, or more

generally using a, and b.

• A set of unique function symbols of arity m. These symbols are often denoted using lower

case letters, or more generally using f, and g.

Depending on the choice of vocabulary, we can construct a first-order language over that

vocabulary by using terms and formulas, the two syntactic atomic expressions in FOL. Both

terms and formulas are built by the following rules:

• An infinite set of variable symbols, often denoted using x, y and z.

• The logical connectives ￢ (negation), ∧ (conjunction), ∨ (disjunction) and ⇒ (implication).

• The variable-binding quantifiers ∀ (universal) and ∃ (existential).

• Left and right parenthesis and the comma.

We now define formulas, more precisely WFFs, or well-defined formulas:

• An atomic formula is a WFF.

• If ϕ and ψ are WFFs, then so are ￢ϕ, ϕ ∧ ψ, ϕ ∨ ψ and ϕ ⇒ ψ .

• If ϕ is a WFF and x is a variable, then ∀x.ϕ and ∃x.ϕ are WFFs.

• Nothing else is a WFF.

A formula is said to be a FOL sentence if all the variables in the formula are within the scope of

some quantifier, i.e., if all the variables in the formula are bound. Formulas can be seen as

descriptions within FOL, while sentences can be seen as representing knowledge.

A language here can be seen as a string of symbols put together according to the precise rules

given by the syntax of the language. These strings do not have any intrinsic meaning or content

assigned to them; a meaning is assigned to them through a preassigned notion of meaning in a

precise sense. A model or an interpretation is an associated semantics consisting of additional

information that allows us to assign a truth value to any such string (meaning sentence here; in

the case of FOL, the truth value is either true or false; in other logics there are other options.)

This assignment is done recursively, from the assignment of world/domain elements to

constants to the assignment of meaning to n-ary predicates for all values of n. Notice that the

truth value assigned to a sentence is dependent on our choice of interpretation.

In order to define a semantics or meaning for first-order logic, the author in [18] introduced the

notion of a model. A model for a given vocabulary can be thought of as a concrete example

where axioms (elements of the syntax) are verified or realized, in a precise sense (given by an

interpretation function F; please see below) together with a specification of the objects we are

referring-to, i.e., the world of discourse, e.g., a model for the axioms of group theory is a group.

We can also see a model as a possible world in which the axioms are verified with respect to

some pre-specified meaning (again, given by the function F).

Formally, a model for a given first-order logic language is a pair (D, F) specifying a non-empty

domain D and an interpretation function F. The domain contains the kinds of things we want to

talk about, e.g. group elements, individuals, organizations, events, places, or objects; notice

that different models may assume different domains (and different functions F). The

interpretation function assigns a meaning to each symbol in the vocabulary in such a way that

we can use Tarski’s truth definition to unambiguously decide and determine the truth of a

sentence. Basically, the function F assign an interpretation for each symbol in the vocabulary.

Each of the constant symbols a,b , etc. are interpreted as an element of the domain and each

predicate is assigned a meaning, e.g., the 2-ary predicate expression B(a,b) , defined in the

domain of all people , can be interpreted as meaning “ Andrew is the brother of Bob” , by first

assigning elements (Andrew, Bob respectively) to each of the constants a,b and then assigning,

through our function F, the meaning “ Is a brother of” , to the 2-ary predicate B. Then through

our truth function we can determine whether, in our world our sentence is true. Collection S of

sentences in which these sentences are true is said to be a model for such set of sentences.

For example F(Student) is some subset of D, which we can specify as the set of students within

the domain. Another example is F(Enrolled) which is some subset of D1 × D2, which we can

specify as being the set of individual student of the domain D1 who are enrolled in a set of

individual courses of the domain D2. Each function symbol f of arity m is interpreted as an m-ary

function over the domain. For example F(BrotherOf) is some function D → D, which we can

specify as being the function which maps an individual to his or her brother.

Note again that a given vocabulary can be mapped to the same (or even different) domain via

a different interpretation function, henceforth it is probable to create multiple models for a

given vocabulary .There are also considerations here such as the Compactness theorem in

Logic, whereby the existence of a model of a given infinite cardinality implies the existence of

models of all different infinite cardinalities.

The main limitations of knowledge representation using First Order Logic comes from the

complexity of its reasoning algorithm. In [9] Drew wrote a critique of pure reason and he

argued that most reasoning about the world is not deductive. He also mentioned that theorem

prover or proving things in FOL generally happens from vague intuition which is far from human

experts reasoning mode. Thus, it might not be appropriate to use logical deduction as a main

mechanism for inference in logic based knowledge system.

Another limitation First Order Logic reasoning suffers from is the lack of rigorous reasoning

presented by the binary true or false formulae used in FOL inference. This result in no space for

deciding about uncertainty which is a common in real life problems. For instance in clinical

diagnosis, if a patient had a breast cancer and she would like to be clear about the cause of

such illness, the doctor may observe her and analyze her history of her medical records. Finally,

the doctor could come to a conclusion that the possible reason for her illness results from 80%

of excessive stress and 20% of environmental factors. This conclusion can’t be easily handled by

first order logic. Variations of other logic such as multi-value logic and fuzzy logic were

developed to handle such deficiency of first order logic [9].

Third limitation of knowledge representation using First Order Logic comes from the

monotonicity property of FOL. Some researchers argued that monotonicity is a deficiency of

FOL in both representing and reasoning about knowledge. To illustrate the problem let’s

suppose we have a simple domain defined by a set of axioms. Any additional axioms must be

consistent with the original axioms, otherwise the system stops working. The following

demonstrates the argument:

x[bird(x)] → flies(x)

bird(duck)

There would be a conflict and the system would break down if we add ¬flies(duck) to the set of

axioms. This deficiency can somewhat be augmented by using other instruments such as

temporal logic if the inconsistency is introduced because the known fact changes over time.

2.2 Modal Logic

Model logics are designed to reach the objective reality of a specific phenomenon in the world.

While First-order logic FOL semantics only allow us to talk about truths within the range {T, F}

(true or false), Modal logics are designed for reasoning about different modes of truth. For

example, they allow us to specify what is necessarily true, known to be true, or believed to be

true [10]. These diverse modes usually denoted to as modalities – include possibility, necessity,

knowledge, and belief. The most important mode among these are what ‘must be true’

(necessity) and what ‘may be true’ (possibility).

As discussed in [10], the interpretation of such modes gives rise to different variations of modal

logics. For example, alethic modal logic deals with the two basic common modes necessity and

possibility which are interpreted as necessary (possible) truth. We say we are in epistemic logic

if the necessity or the possibility is interpreted as stating that which is known (not known) to be

true. Finally, if the mode has a time dimension, such that if necessity or possibility is interpreted

as stating that which always has been or to which will always be (possibly) true, we have

temporal logic.

Note that much of the following section is derived from [11, 12].Modal logic is often formulated

by augmenting any existing logic such as propositional or even non-classical logic with logical

operators referring to modalities. The following example illustrates the formation of modal

logic. There are two modal operators of the first-order modal logic that are syntactically

represent a formula in modal logic. These modal operators are the diamond ◊ symbol for the

possibility and box □ symbol for necessity. The author in [12] define a well-formed formula (or

WFF, or simply ‘a formula’) of the logic as follows.

• An atomic formula is a WFF.

• If ϕ and ψ are WFFs, then ￢ϕ, ϕ ∧ ψ, ϕ ∨ ψ, ϕ ⇒ ψ, ◊ϕ and □ ϕ are WFFs.

• If ϕ is a WFF and x is a variable, then ∀x.ϕ and ∃x.ϕ are WFFs.

• Nothing else is a WFF.

Given ϕ as a formula, then the modal logic formula ◊ ϕ interpreted as ‘ϕ is possibly true’,

whereas □ ϕ interpreted as ‘ϕ is necessarily true’. With such a logic we can, for example,

represent the following sentences.

• It is possible that the Professor is late.

• It is possible that DB course will be offered in the Fall.

• It is not possible that: every Student is Smart, Tom is a student, and Tom is not Smart.

• It is necessary that Alice pass the exam or Alice does not pass the exam.

Other modal logics usually have different modal operators. For example in epistemic logic, we

need to represent what is known (not known) to be true. The two basic epistemic logic modal

operators are K and C. The modal operator K represent ‘it is known that’, and the modal

operator C represent ‘it is common knowledge that’. A formula such as KTom∃x.Late(x)

represents Tom knows that someone is late, whereas ∃x.KTomLate(x) represents Tom knows

someone who is late. A formula such as CSmart(John) represents the common knowledge that

John is smart. By common knowledge we mean that everyone knows that John is smart,

everyone knows that everyone knows that John is smart, everyone knows that everyone knows

that everyone knows that John is smart, and so on. We will discuss the modal temporal logic in

section 2.4.

Attributable to [13], the semantics of modal logic is defined as the following. Any modal logic

can be assigned a possible world semantics. Essentially, a possible world is any world which is

considered possible. This includes not only our own, real world, but any imaginary world whose

characteristics or history is different. Here we will supply a semantics for our example first

order modal logic. Given a modal logic language vocabulary of unique constant and predicate

symbols, a model M for that vocabulary consists of 4 elements (W, R, D, F) which comprises the

following: the first element of the model M is a non-empty set W of possible worlds. The

second element of the model M is an accessibility relation R ⊆ W ×W between two worlds,

where the relation R(w,w’) represents that world w has access to world w’, or that w’ is

accessible from w. The third element of the model M is a domain D of the kinds of individuals,

places or objects we want to talk about, and which is common to all worlds. And the fourth

element of the model M is an interpretation function F which assigns a semantic value in D to

each symbol in the vocabulary at each world of W.

One assumption the author made in their example modal logic is that the constants are rigid. By

this it means the interpretation of a constant symbol is the same at every world. Hence if we

interpret F(Professor) as being an individual called the Professor in some world, then

F(Professor) is interpreted as the same individual in any other world. Note however that the

interpretation of a predicate symbol at some world may differ from its interpretation at some

other world.

The domain of individuals in Modal logic may change from state to state (or world to world).

Also if we ignore the common domain requirement, modal logic even may allow for things to

exist in one world but not another.

2.3 Description Logics

Description logics which is earlier called terminological logics firstly developed for a purpose of

providing a formal foundation for semantic networks. Semantic networks were first proposed

by Charles Peirce’s under the name existential graphs in 1909. Semantic networks represent

semantic relations between concepts. It is a directed graph consisting of vertices, and edges.

Vertices represent concepts; concepts could be an objects, individuals, or abstract classes; and

the edges represent semantic relations between these concepts. Semantic networks have long

been used in philosophy, psychology and linguistics. However It has been introduced as a

knowledge representation formalism in early 1960s [16].

One of the features of the Semantic Networks is the inferential dependencies which are type of

semantic information that relates two or more concepts, such as IS-A, TYPE-OF edges. Due to

their hierarchical nature and ability to represent class relationships through links, semantic

networks can easily model the inheritance relationship. Another important feature of semantic

networks is that the representation tends to cluster information relating to an object around

that object. This feature not only has useful consequence for computational efficiency, but is

also claimed to be the way human memory works. Semantic Networks can also be used to

represent events and natural language sentences [17].

Description Logics (DLs) are a well-known family of logic-based knowledge representation

formalisms that represent the conceptual knowledge as well as the instances of knowledge of

an application domain. The representation of such knowledge start by first defining the relevant

concepts of the domain, and then defining properties of objects and individuals of these

concepts occurring in the domain.

It has numerous applications in the semantic web field. For instance, DLs is a standard for the

W3C's web ontology language OWL. Other relevant applications of DLs include the

representation of and reasoning about conceptual database models. Strictly speaking, extended

entity-relationship (EER) model and UML class diagrams can be embedded into DLs, and DL

reasoners can be used to verify their consistency and to derive implicit consequences of the

model [14].

Description logics focuses on representing the terminological knowledge of an application

domain. The central ingredients to such a representation are concepts, roles and individuals. In

DL a knowledge base is a finite set of TBox (terminological box) and the ABox (assertional box).

In general, the TBox contains sentences describing concept hierarchies (i.e., relations between

concepts) while the ABox contains ground sentences stating where in the hierarchy individuals

belong (i.e., relations between individuals and concepts) [14]. For example, the statement

“every manager is employee” belongs in the TBox, while the statement “Bob is an employee”

belongs in the ABox.

In this section, we briefly introduce the formal framework of DLs which will serve as the basic

representation language for the non-temporal knowledge. There are different description

languages in the DL family. The description of ontologies and knowledge in description logics

uses constructs that have semantics given in predicate logic. However, due to historical

reasons, different notation is used. Typically, the notation is much closer to notations in

semantic networks and frame based systems. The presentation of Description logic formal

framework will strictly follow the ALC (Attributive Concept Language) notation introduced by

Schmidt-Schauss and Smolka [15].

Attributed to [15] the syntax and semantic of DL defines as the following, DL concepts are built

from a countably infinite set NC of concept names that relates atomic and complex concepts, a

countably infinite set NR of role names, and countably infinite set NI of individual names by

applying the available concept constructors. In the basic standard propositionally closed

description logic ALC, these constructors are

A, ⊥, T, ¬ C, C П D, ∃R.T, ∃R.C

Where A is the atomic concept and C, D are complex concepts that range over NC .R represents

a role and ranges over NR. T is the universal concept, and as usual we use ⊥ as an abbreviation

for ¬ T .Complex concepts are formed by constructors such as C П D .We use C ∪ D as an

abbreviation for ¬ (¬C П ¬D). We also use ∀R.C as an abbreviation for the negation of existential

¬∃R.¬C

A concept denotes the set of all individuals satisfying the properties specified in that concept.

For example, the concept Person represents the set of people, whereas Student П Male

represents the set of male student. A concept such as ￢Student represents all the individuals

which are not students. The intersection and complement of atomic concepts or complex

concept are often denoted as concept conjunction and negation respectively. Concerning the ∀

and ∃ restrictors, if the concept C denotes some class of individuals, then the restriction ∀R.C

represents those individuals who are R-related only to the individuals of that class. For example,

∀teaches.PhD represents those professors who only teach PhD students, whereas ∀ teaches.⊥

represents those professors who never teach. The restriction ∃R.T represents all individuals

that are R-related to at least one other individual. For example, ∃ownsCar.T represents all

individuals who own at least one car.

TBoxes represent knowledge at the conceptual level that can be formed by sentences. A

sentence may include concept subsumption C ⊆ D or concept equality C ≡ D. They are formally

build from atomic concepts and atomic roles or complex concepts with constructors like the

above ALC constructors. On the other hand, ABoxes represent knowledge at the instance level,

It is formally built by asserting each concept C(a) and role r(a,b) with individuals , where a and b

are individuals.

The semantic of DLs is based on the notion of an interpretation I of an expressions, which

consists of two parts I = < ΔI , .I > where ΔI is a set of non-empty individual domain of

interpretation ΔI, and an interpretation function .I that maps each ALC concept name C ∈ NC into

a subset of CI ⊆ ΔI and every role name r ∈ NR to a relation rI ⊆ ΔI x ΔI and every individual name

a ∈ NI to an element in the domain aI ∈ ΔI .The interpretation function .I can be defined for a

complex concept as follows

TI = ΔI

⊥I = ɸ

(¬C)I = ΔI \ CI

(C П D)I = CI ∩ DI = {a ϵ ΔI |a ϵ CI ∧ a ϵ DI }

(∃r.C)I = { a ϵ ΔI |∃b.(a,b) ϵ RI ∧ b ϵ CI }

We say that CI (rI) is the extension of the concept C ( role name r ) in the interpretation I . If a ∈

CI then we say that a is an instance of C in an interpretation I.

The core inference task over concept expressions in DL is subsumption. The meaning of

subsumption is to check whether the concept described by D is more general than another

concept denoted by C, written as C ⊆ D. A special case of subsumption is satisfiability which is

the problem of checking whether a concept expression does not necessarily denote an empty

concept [18]. Other basic reasoning tasks are: instance checking C(a) is to check if an individual

a is an instance of the concept c; equivalence checking A ≡ B is to check if both A ⊆ B and B ⊆

A are true; and retrieval is the reasoning task of retrieving a set of individuals that instantiate

the concept C.

2.3.1 Expressive Description Logics

In the previous section we discussed the basic ALC (Attributive Concept Language) description

logic which is an extension of the basic AL (Attributive Language) logic. In order to increase the

expressive power of Description logic several extension to the ALC were proposed by adding

new constructs. We’ll now give a brief introduction to the more expressive description logics,

for a detailed discussed we refer the reader to [16]. These languages feature complex roles such

as R1 ∩ R2 (intersection), R1 ∪ R2 (union), ￢R (complement), R1 ◦ R2 (composition), R+

(transitive closure) and R−1 (inverse). An example of conjunction include hasFather ∩ hasMother

which can be used to define hasParent. Another example is the composition hasHusband ◦

hasBrother which can be used to define hasBrotherInLaw, the transitive closure of hasChild

which is the role hasDescendant, and the inverse of hasChild which is the role hasParent.

Additional concepts occurring in expressive description languages is the cardinality of a role

participating in a concept include ≤ n R.C , and ≥ n R.C (qualified number restriction) and

{a1, . . . , an} (set concepts, for n ≥ 1). Examples include ≥ 2ownsCar.BMW which expresses the

set of individuals who own at least two BMW cars and {John, Tom, Mary, Jennifer} which can be

used to define the concept of students at some class. In order to avoid Description Logic

languages with long names, (S) was introduced as an abbreviation for an ALC language with

transitive roles. The extension (H) allows role hierarchies, i.e. role inclusions R1 ⊆ R2, and the

extension (R) incorporates role intersection. (I) allows for inverse roles, whereas (O) allows for

set concepts. The extension (Q) incorporates qualified number restriction. The extension (D)

allows the integration of an arbitrary concrete domain within a description logic language. An

example of an expressive description language is SHOIN(D).

Table 2 below show how the AL description logic can be further extended by adding new

constructs. The name of the logic is then formed from the string AL[U][E][N][C],so for example

the logic ALEN is the attributive language logic extended with full existential quantification and

number restrictions. Some of the combinations are not unique from the semantic point of view

- for example, union and existential quantification can be expressed using negation.

Table 1: AL logic extensions

2.3.2 Reasoning with DL

There are different reasoning tasks in Description Logics, According to [18] we can categorize

the type of reasoning tasks as two categories: either a reasoning for a terminology (TBox) or a

reasoning for an assertions (ABox). Typical reasoning tasks for a terminology (TBox) are (1)

satisfiability which determine whether a particular concept is satisfiable, i.e. non-contradictory;

and (2) Subsumption which determine whether one concept is more general than another, i.e.

whether the first description subsumes the second. Given a terminology and the set of all

possible models M for that terminology (whereby the models have differing domains and

interpretation functions), we say that a concept C is satisfiable if it is satisfied in at least one

model of M. Concept C is unsatisfiable if it is satisfied in no model of M. A concept C1 is said to

be subsumed by a concept C2 if C1 ⊆C2 is satisfied in every model of M. Two concepts C1 and

C2 are said to be equivalent if C1 ≡ C2 is satisfied in every model of M. From their definitions,

satisfiability and equivalence can be reformulated in terms of subsumption.

• C is unsatisfiable iff C is subsumed by ⊥, C ⊆ ⊥.

• C1 and C2 are equivalent iff C1 ⊆ C2 and C2 ⊆ C1.

Moreover, if the type of Description Logic allow full concept negation and conjunction, then the

subsumption and equivalence can be reformulated in terms of satisfiability.

• C1 is subsumed by C2 iff C1 П ￢C2 is unsatisfiable.

• C1 and C2 are equivalent iff both C1 П ￢C2 and ￢C1 П C2 are unsatisfiable.

A structural subsumption algorithms can compute the subsumption of concepts if the

description logic is simple. These structural subsumption algorithms perform greatly well if the

DL has less expressive power which do not allow negation at all, such algorithms compare the

syntactic structure of concept descriptions. We refer the reader to [19] for an in-depth

discussion. On the other hand, in order to determine the satisfiability of a more expressive

description logic which allow concept negation and conjunction, we use tableau-based

algorithms [19]. We will shortly give an example of a tableau-based algorithm for the ALC

language.

The second category of the reasoning tasks involves an assertions (ABox). Typical reasoning

tasks for the ABox are (1) Consistency which determine whether a particular assertion is

consistent, non-contradictory, i.e. whether it is satisfied in some model; and (2) whether one

particular individual is described by some concept. We say that an ABox A is consistent with

respect to a TBox T if there is at least one model which is both a model for T and a model for A.

We simply say A is consistent if it is consistent with respect to the empty TBox. An example is

the set of assertions {Mother(Mary), Father (John)} which is consistent with respect to the

empty TBox, but inconsistent with respect to a TBox defining the disjoint concepts Mother and

Father. Given an ABox A and the set of all possible models M for A, we say an assertion α is

entailed by A if α is satisfied in every model of M. Hence Mother(Mary) is entailed by an ABox

if the Mary is a mother in every model for that ABox. Derived from their definitions, consistency

and entailment are related as follows. α is entailed by A iff A∪{￢α} is inconsistent.

Consequently, concept satisfiability in the TBox can be reduced to consistency in the ABox,

because for every concept C and arbitrarily chosen individual name a, we have the following.

• C is satisfiable iff {C(a)} is consistent.

Basically, the tableau-based algorithm for ALC works as the following. Let’s assume we have a

concept C, the algorithm works on constructing a model M ≡ (D, F) such that C is satisfied in M,

i.e. F(C) ≡ ∅. The algorithm start by arbitrarily chooses an individual x where x ∈ F(C). Starting

with the ABox A ≡ {C(x)}, consistency-preserving tableau rules are applied next until the ABox

is complete, i.e. until no more rules can be applied. A is consistent (which means that C is

satisfiable) if the subsequent ABox does not have a contradiction, otherwise it is inconsistent.

Note that a contradiction or a clash in an ABox A is such that either {⊥(a)} ⊆ A, or {C(a), ￢C(a)}

⊆ A for some individual name a and concept C.

The example presented here is incorporated from [20], suppose we want to determine whether

C0 ≡ (∀ownsCar.BMW) П (∃ownsCar.￢BMW) is unsatisfiable. We choose an arbitrary individual

x and start with ABox

A0 ≡ {((∀ownsCar.BMW) П (∃ownsCar.￢BMW))(x)}

We then apply the following tableau rule.

П -rule

Condition: Ai contains (C1 П C2)(x), but not both C1(x) and C2(x).

Action: Ai+1 ≡ Ai ∪ {C1(x), C2(x)}.

After applying this rule, we have

A1 ≡ A0 ∪ {(∀ownsCar.BMW)(x), (∃ownsCar.￢BMW)(x)}

We next apply the tableau rule below.

∃-rule

Condition: Ai contains (∃R.C)(x), but there is no z such that. C(z), R(x, z) are in Ai.

Action: Ai+1 ≡ Ai ∪ {C(y), R(x, y)} where y does not occur in Ai.

Thus we have

A2 ≡ A1 ∪ {(∀ownsCar.BMW)(x), ￢BMW(y), ownsCar(x, y)}

The universal rule is as follows.

∀-rule

Condition: Ai contains (∀R.C)(x) and R(x, y), but it does not contain C(y).

Action: Ai+1 ≡ Ai ∪ {C(y)}.

After application of this rule we have

A3 ≡ A2 ∪ { BMW(y), ￢BMW(y)}

The final ABox A3 contains a contradiction or clash. This conclude that the concept

(∀ownsCar.BMW) П (∃ownsCar.￢BMW) is unsatisfiable and the original ABox A0 is inconsistent.

2.4 Temporal Logic

The representation and reasoning about time and temporal information within a logical

framework has been done using temporal logic. There are a rich variety of temporal models and

logics introduced and studied over the past 50 years including Interval temporal logic (ITL),

Linear temporal logic (LTL), Computational tree logic (CTL), Property specification language

(PSL), Halpern-Shoham Temporal logic and others [52].

In this subsection we will briefly refer to the temporal logic that use modal-logic operator

approach that was introduced around 1960 by Arthur Prior under the name of Tense Logic and

subsequently developed further by many logicians and computer scientists [52]. Other than

representing and reasoning about temporal information, temporal logic could also be used as a

tool for the specification, formal analysis, and verification of the executions of computer

programs and systems.

Attributed to [41], the syntax of temporal logic has two kinds of operators: logical operators

and modal operators. Logical operators are usual truth-functional operators ( ).

There are two type modal operators used in Linear Temporal Logic and Computation Tree Logic;

Binary operator and Unary operator are defined as follows.

Halpern and Shoham [41] introduced temporal logic HS which could be seen as the combination

of a propositional modal logic with the interval-based temporal logic. The syntax of HS

wellformed formulae are built by extending the propositional calculus with the modal temporal

operators corresponding to the Allen interval relations [1] in the table2 below are: before (b),

meets (m), during (d), overlaps (o), starts (s), finishes (f), equal (=),after (a), met-by (mi),

contains (di), overlapped-by (oi), started-by (si), finished-by (fi).

Table 2: Allen relations between pairs of intervals and Halpern-Shoham modal operators on them.

The semantics of the logic is based on a Kripke structure whose domain is a set of intervals, and

its logical formulae are interpreted as sets of intervals. We say that a formula holds at an

interval if it is evaluated as true at that interval. The modal operators relate the reference

interval now with other intervals. As an example incorporated from [41], the notion of Mortal

can be expressed in HS temporal logic as:

LivingBeing ∧ <met-by>￢LivingBeing

Which defines a LivingBeing as the one who will not be alive in some interval met by the

current interval.

In [41], the semantic of Halpern-Shoham Temporal logic is defined as the following. A linear and

unbounded temporal structure T = (P, <) is assumed, where P is a set of time points and < is a

strict partial order on P. The interval set of a structure T is defined as the set T *< of all closed

intervals [t1, t2] = {x ∈ P | t1 <= x <=t2} in T. An interpretation I = <T * <, .I> consists of a set T *<

(the interval set of the selected temporal structure T), and a function .I which maps each

primitive proposition into a set of closed intervals where it is true.

Halpern and Shoham improve the expressive power of the temporal logic and prove many

interesting complexity results concerning the validity and satisfiability issues. However, this

natural and seemingly simple logic turned out to be highly undecidable [Halpern and Shoham

1991]. The explanation of the heavy computational behavior of HS temporal logic is that it can

be viewed as a two dimensional modal logic interpreted over products of liner Kripke frames

which provide a good playground for simulating Turing machines [Artale, et al 2015].

3 The Semantic Web

With the expansion of the World Wide Web in the late eighties, Tim Berners-Lee identified two

purposes for internet use by people: information and knowledge sharing and information

analysis. The internet allowed people to share a multitude of information stored in the web

with each other across time and space. Internet use also witnessed a great deal of analysis with

the purpose of generating meaningful knowledge that caused a need for tools that can help

people analyze and manage the information they share in a meaningful way. This vision has

been referred to as semantic web [2]. The World Wide Web Consortium has initiated an effort

to increase the depth of information sharing, analysis and automation using various standards

and technology which has become known as the semantic web intuitive.

Lukasiewicz [21] outlined the Semantic Web intuitive goals as 1) add machine-readable

meaning to web pages using ontologies, thus assigning a precise definition to shared terms. (2)

Increase the use of automated reasoning within the context of knowledge representation, and

3) generate automated cooperation among machine systems to produce meaningful

information based on web content. It is clear that semantic web involves the use of knowledge

representation and reasoning to a great extent.

Below, we outline few semantic web techniques that heavily utilize knowledge representation.

These techniques include a wide range of languages such as XML, the resource description

framework RDF, the XML and RDF schema languages, the RDF query language called SPARQL;

and the Web ontology language abbreviated as OWL. These languages and technologies allow

computers to represent human knowledge on the web in an automated, reliable and accessible

manner.

XML – stand for ‘eXtensible Markup Language’ - is a general purpose computer language that

uses a set of explicit tags to produce documents interpretable by humans as well as machines.

The purpose of XML is to facilitate the sharing of data structures across information systems

[22]. XML is an extensible language, which means that users may develop their own tags. Tags

allow users to specify, identify or share a data set for a particular use. For example the pair of

tags <b> ...</b> in HTML specifies that the enclosed text is displayed in bold font, whereas the

pair <message>...</message> in XML labels the enclosed text as a message. A XML schema -

written in a schema language like DTD (Document Type Definition) - specifies a vocabulary for

the kinds of tags which can be included in a XML document and the valid arrangements of those

tags. A XML parser checks whether a document conforms to its schema.

XML Schema type System has two commonly cited drawbacks. First, XML Schema user-defined

datatypes are not accessible by RDF(S) and OWL causing an inconvenience for users. Second,

XML limits datatype constraints that RDF(S) and OWL could provide because XML Schema does

not support n-ary datatypes. XML schema has multiple varieties. More information regarding

these can be found at [23]

RDF – Stands for ‘Resource Description Framework’ - is a language with the purpose of

representing and sharing information about resources, web resources in particular [24]. The

language solves several practical problems, such as creating metadata for web resources. Note

that this metadata mechanism supplies the necessary platform for processing information

among various agents making it easier for more users to use the resources data. Another

important issue solved by RDF is allowing users to specify statements about any resources. This

leads to an “open world semantics”

The resource in RDF data models is represented as a Uniform Resource Identifier (URI)

reference. URIs are generic types of Uniform Resource Locator URLs. URLs are string characters

specifying the resource in web pages, whereas a URI is an identifier for the resource without

having to indicate the location of the resource. URIs can be used within a RDF statement to

refer to essentially any specified resource. RDF statements and models can be graphically

represented showing three main ingredients as a triple, subjects, objects and predicates. A

predicate is a directed arc emanating from a subject pointing to an object. URI reference nodes

are depicted as ellipses, whereas constant values are depicted as rectangles [24].

The meaning of an RDF graph is the conjunction of the statements corresponding to all the

triple it contains. However, some of the limitations of RDF is that it does not provide means to

express negation (NOT) or disjunction (OR). A formal definition of RDF triples are given in [25]:

_ an infinite set U containing RDF URI references,

_ an infinite set B = Nj ; j ϵ N (called blank nodes),

_ an infinite set L (RDF literals).

A triple(s; p; o) ϵ (U ⨆ B) x U x (U ⨆B ⨆ L) is called RDF triple. The symbols s; p; o are Subject,

Property, and Object respectively. An RDF, or RDF graph is a set of triples. A subgraph is a

subset of an RDF graph. According to the above definition, objects of the graph can be pieces of

text instead of resources (URIs); those pieces of text are called literals. This is syntactically

useful in RDF documents (being able to write directly some text rather than storing it in another

resource). It has to be emphasized that only "object" can assume literals.

In RDF graphs, a Blank node represents a special node that has no URI or intrinsic reference.

Blank nodes are used in n-ray RDF statements or graphs specifying relationships. Blank nodes

breaks up n-ray relationships into binary relationships. Blank nodes are also used to represent a

statement or graph that does not have an explicit URI reference.

RDF’s chief purpose is to make knowledge accessible, machine-readable and processable by

computers and other software applications. To achieve this aim RDF utilizes XML. A particular

type of notation called RDF/XML is used to specify RDF graphs as XML files. This process of

converting RDF into XML is called serialization. Serialization has many versions such as Turtle,

N3 and N-triples. We refer the reader to [24] for more information regarding RDF and its

serialization notations.

To draft a statement using RDF, W3C has recommended RDF vocabularies guiding users in

creating RDF graphs. Part of this vocabularies are certain types known as reserved words, which

are used to write RDF statements. Some URI references possess unique meanings. For instance,

the URI reference: "http://www.w3.org/1999/02/22-rdf-syntax-ns#" conventionally represent a

namespace whose prefix is rdf:. URI: "http://www.w3.org/2000/01/rdf-schema#" represent

another namespace whose prefix is rdfs:. The set of reserved words in RDF vocabulary

description language, called RDF schema (RDFS) is described in [26]. The vocabularies allow the

user to specify the properties, as well as the relationships among resources. Also, vocabularies

allows defining classes of references. A class represents resources that share a set of properties.

Elements of a class are called instances of that class. In schemas, new resources can be defined

as specialization of an existing ones, thus inferring implicit triples is possible. Schemas also

constrain the context in which defined resources may be used, inducing the notion of schema

validity or consistency.

RDF Schema (RDFS) enhances RDF data models by adding vocabularies and associated

semantics that enriches classes, subclasses and their properties, as well as sub-properties.

Similar to XML schema that provides vocabularies to XML documents, RDF schema supplies

data models with additional vocabularies for representing richer relationship. The RDF Schema

language does not only specifying the elements of the data model, but also carries the

relationship and type of elements used in these models [24].Essentially a schema provides a

basic type system for use in RDF models. Importantly, it allows resources to be described as

classes, instances of classes and subclasses of classes.

RDF utilizes several query languages such as SPARQL [27], RDQL [28], RQL [29], and SeRQL [30].

SPARQL has been recommended by W3C as the most appropriate language for RDF use. We can

write SPARQL query against RDF graph. A comprehensive review of the development of query

languages for RDF can be found in [31].

SPARQL – stands for ‘SPARQL Protocol And RDF Query Language’ - is a RDF query language

which has been standardized by the World Wide Web Consortium. Reference [27] reports that

SPARQL is based on (s, o, p) triple patterns. These are the same as RDF triples where each

subject, predicate and object may be a variable or has a constant value. A basic graph

represents a set of relationships. A basic graph matches a RDF subgraph when RDF terms can be

substituted with variables. To retrieve a RDF documents by queries, the set of queries

expressed as patterns, the solution to the query is a mapping u from g to G (G is the current

RDF graph).

SPARQL provide different forms of posing a query against a RDF graph or knowledge base, the

following are the query "forms" provided in SPARQL:

_ The SELECT query form returns variable bindings, the triple following the query patterns.

_ The CONSTRUCT query form returns an RDF graph specified by a graph template.

_ The ASK query form can be used to test whether or not a graph pattern has a solution. No

information is returned about the possible query solutions, just whether or not a solution

exists.

One may devise knowledge representation formalisms using RDF and RDFS to present

relationships between web resources. RDFS provides the opportunity to use schema

/vocabularies when referring to resources. However RDF constitutes a more powerful tool in

describing the world. Despite this capability, RDF does not possess a powerful reasoning service

in RDF(S). It does not allow localized range and domain constraints either. Another limitation of

RDF is that it does not feature the capability of specifying cardinality and existential constraints.

There is no transitive, inverse or symmetrical properties specification available. Given these

drawbacks, RDF(S) becomes an inadequate tool for the purpose of describing the world in

detail. OWL language came to overcome some of these challenges since it possess a more

expressive power.

OWL stands for “The Web Ontology Language” it is an ontology language for the World Wide

Web. It was developed to overcome the limitations presented by XML, RDF and RDF(S), and it

possess higher capabilities for expressing semantic content on the Web. Ontology is the

underlying generating model of relationships in a particular domain or practice. As defined in

[32] an ontology as "the specification of conceptualizations", which assists in information

sharing endeavors. Conceptualization refers to the process of specifying relationships among

entities (concepts) in a model (system of relationships) that reflects an underlying process or

situation in the real world. The specification is the process of identifying the direction and

magnitude of relationships among different entities. Ontologies aim to establish standards

vocabularies, terminologies and understandings among participants in a given domain.

An ontology has been often utilized as a tool for modelling relationships in a given domain,

rather than explaining the domain itself. It identifies and defines concepts in a particular field

and specify the relationships among them. As seen in the description logic discussion in section

2.3, the concept in ontology is similar to the concept in DL. Relations in ontology is similar to

roles in DL.

OWL is recommended by the W3C. OWL extends RDF and RDFS. OWL aspires to use expressive

power of descriptive logic in semantic web to represent meaningful knowledge. As discussed in

[33] OWL consists of three increasingly expressive sublanguages: OWL Lite, OWL DL and OWL

Full. OWL DL derives its name from its relation to description logics; it is based on the

description language extension SHOIN(D). OWL Lite is a simple ontology language which allows

users to develop classification hierarchies with simple constraints. OWL DL is more expressive

than OWL Lite and both are decidable. OWL Full is more expressive than the other two, but it is

not decidable. OWL Full is considered to be an extension of RDF, whereas OWL Lite and OWL DL

are considered to be extensions of a subset of RDF. Since OWL is syntactically embedded into

RDF, all of the RDF serializations can be used. RDF/XML is the normative syntax and should be

used to exchange information between systems. In this section we’ll give some very simple

examples of OWL. As an example, the concept of "Professor who teaches all PhD students" can

be expressed in abstract syntax in description logic as follows:

Professor П teaches.PhD

The concept can be serialized in RDF/XML:

<owl:Class>

<owl:intersectionOf rdf:parseType=collection">

<owl:Class rdf:about="#Professor"/>

<owl:Restriction>

<owl:onProperty rdf:resource="#teaches"/>

<owl:allValuesFrom>

<owl:Class rdf:about="#PhD"/>

</owl:allValuesFrom>

</owl:Restriction>

</owl:intersectionOf>

</owl:Class>

As discussed in [33] much of an OWL ontology concerns classes, instances of classes, class

individuals, and properties and relationships between these elements. An example of a

userdefined in the above example.

<owl:Class rdf:about="#Professor"/>

The rdf:about="#Professor" attribute-value pair assigns a name to a class. After this assignment

rdf:resource="#teaches" may be used. Note that each user-defined class is implicitly a subclass

of owl:Thing.

In OWL, if X is a subclass of Y, then every instance of X is also an instance of Y. We can introduce

an individual “Tom” of the class Professor as follows.

< Professor rdf:ID="Tom">

An OWL object property is a binary relation which relates two class instances. We define the

object property “teaches” and specify its domain and range accordingly.

<owl:ObjectProperty rdf:ID="teaches">

<rdfs:domain rdf:resource="#Professor"/>

<rdfs:range rdf:resource="#PhD"/>

</owl:ObjectProperty>

The class “Professor” is a subclass of the class “Person”. Here we assume we have previously

defined the class “Person”. In OWL we may also define object properties as being transitive,

symmetrical, functional, or the inverse of each other which we can’t define these in RFD. And

due to the high expressive power of OWL Full it is the primary reason why it is undecidable, the

reason is because it places no restriction on the transitivity of object properties.

OWL reasoning capabilities include the RDF/RDFS reasoning capabilities as well as more

extensive capabilities. Such as in all references to reasoning with rdfs:subClassOf, the same type

of reasoning is done with owl:subClassOf. The selected extended reasoning capabilities are

briefed as follows:

1. Semantics of owl:SymmetricProperty is enforced.

2. Reasoning with owl:inverseOf is available. For instance, (parentOf

owl:inverseOf(hasParent) and (Goldie parentOf Kate) imply the fact (Kate hasParent Goldie).

3. Inheritance of disjointness constraints is available. For instance, (Plant

owl:disjointWith Animal) and (Mammal rdfs:subClassOf Animal) imply the fact (Plant

owl:disjointWith Mammal).

4. When an owl:sameAs relationship is asserted between two entities that are

known to be classes, an owl:equivalentClass relationship is inferred between the classes.

Similarly, when an owl:sameAs relationship is asserted or inferred between two entities that

are known to be properties, an owl:equivalentProperty relationship is inferred between the

classes.

5. All the subclasses of a given class are disjoint with the class's complement.

6. A complicated bit of reasoning about owl:complementOf captured by following

KIF (Knowledge Interchange Format) axiom.

7. Inferring owl:sameAs relationships via owl:FunctionalProperty and

owl:InverseFunctionalProperty.

8. If a class A is owl:oneOf a list of objects, say X, Y, and Z, then each of X, Y,and Z

has rdf:type A.

9. If an object is a rdf:type an owl:allValuesFrom owl:Restriction, and the object has

values for the specified property, then the values are of the specified type.

10. If an owl:someValuesFrom owl:Restriction restricts a particular property to a

particular type, and if an object has some values of the specified type for the specified property,

then that object has the Restriction as a type.

11. If a property Q is owl:inverseOf of a property P, and P is an

owl:TransitiveProperty, then Q is also an owl:TransitiveProperty.

12. Classification inference: rdfs:subClassOf, owl:unionOf, owl:intersectionOf, ...etc..

The reasoning capabilities mentioned are provided based on the description logics. To make the

OWL and knowledge representation formalism more powerful, "rule-based" reasoning can be

augmented by adding rule languages on top of OWL. Potentially, the extension would make the

reasoning undecidable.

SWRL – stands for ‘Semantic Web Rule Language’ - has been proposed in May 2004 as the basic

rules language for the Semantic Web [34]. It can be used to express rules as well as logic. It

combines the sublanguages OWL DL and OWL Lite with RuleML, the Rule Markup Language.

RuleML is a markup language for publishing and sharing rule bases on the World Wide Web.

SWRL has the full power of OWL DL, but at the price of decidability and practical

implementations, and due to its expressive power reasoning using the full SWRL specification is

undecidable. To solve this problem, a decidable subset of SWRL has been identified and is

referred to as being DL-safe.

SWRL rules have the form of an implication between an antecedent (body) and consequent

(head). The meaning can be interpreted as: whenever the conditions specified in the

antecedent hold, then the conditions specified in the consequent must also hold. Both the

antecedent (body) and consequent (head) consist of zero or more atoms. An empty antecedent

is treated as trivially true (i.e. satisfied by every interpretation or model), so the consequent

must also be satisfied by every interpretation. An empty consequent is treated as trivially false

(i.e., not satisfied by any interpretation), so the antecedent must also not be satisfied by any

interpretation. Multiple atoms are treated as a conjunction. Our description thus far of the

SWRL language is very brief; we refer the reader to [34, 35] for more detailed discussion about

SWRL.

4 Temporal Knowledge Representation

Time represents a crucial element in any knowledge-based systems including semantic web.

The exponential rise in academic scholarship and practical research in incorporating temporal

dimensions into knowledge representation formalisms indicates the applied significance of

temporal aspects in semantic web and other knowledge-based systems. Time serves as an

integral part of dynamic data and dynamic knowledge. For instance, the description of a

concept in ontology often reference to temporal patterns salaries. e.g., the definition of salary

in employee ontology that changes over time. Similarly, time plays a critical role when using

Description logics to represent and reason about conceptual model of temporal databases.

There are two common approaches for representing temporal information: implicit approach

and explicit approach. The explicit representation of time in theoretical and empirical models or

languages is required in order to consider the time element. Time becomes a variable in the

equation of models and languages. Besides the explicit approach of time incorporation, one

may choose to integrate temporal elements implicitly. The implicit approach necessitates a

manipulation of model ingredients. The implicit approach relies on the ability to capture the

ordering of states that are represented by certain Knowledge representation formalism.

According to the explicit view, one may incorporate time into models in two ways:

-External point of view

This view perceives time in a cross-sectional lens. Same individual can have different snapshots

in different moments describing various states of the individual at these times.

-Internal point of view

Different states of an individual are seen as different individual components.

The interest in incorporating time into data models, and knowledge representation formalism

resulted in the proliferation of diverse studies discussing various issues with respect to how a

researcher can tackle the issue of accounting for time in a model or language. This vast

literature generated many approaches on how best to incorporate time in a given model or

formalism. One of the foundational differences among existing approaches is whether time is

represented on an interval based or a point based manner. Most importantly, these differ with

respect to whether one should use an explicit notion of time in which temporal operators are

used to build new formulae , or an implicit incorporation of temporal aspects into models or

languages by restoring to a state change style of representation to denote sequences of

events[36].

Existing Knowledge Representation formalisms may be extended through adding a temporal

dimension to their capabilities. This extension has been underway and the following discussion

will touch briefly on its main findings. For instance, it's possible to extend "Frames" to

"temporal Frames" for representing temporal information in on object oriented way. This type

of extensions, although useful, presents difficulties in terms of tractability, the reasoning and

inference services

As example of adding the time dimension to a knowledge base language in OWL. OWL relies on

a logic-based formalism, and largely employs binary predicates. Adding the time component to

the binary predicates used by OWL is done through the inclusion of a time argument (t) to the

binary predicate. In doing so, the time (t) here is added as an interval. However, this treatments

of adding the time (t) to the binary predicate ends up with a ternary predicate which is not

allowed in current OWL . Alternatively, many researches look at ways of supporting temporal

representation that sits on top of the core of OWL without modifying any of OWL's logic-based

formalism. The kind of add-ons to OWL are not usually lightweight and can't utilize the

reasoning tool in most OWL tools.

The interest of the following discussion is not in the selection of "valid time" versus "transaction

time". We will briefly discuss the point based and interval based temporal structure. And then

focus is on the literature reviews on temporally extending Description Logics, RDF, and OWL.

4.1 The Temporal Structure

Temporal aspects and structures have been extensively studied within the knowledge

representation domain especially from the theoretical point of view [39]. The following

discussion outlines the fundamental findings of this research.

Adding a time element to a knowledge representation formalism or building a time formalism

involves several crucial decisions regarding temporal structures. A temporal formalism can be

understood as a set of temporal elements organized by a temporal relationship. This involves

the specification of time elements within a general knowledge representation system.

Temporal elements encompass any construct related to time, time points and time intervals in

particular. Temporal structure postulates how different time elements are related to each

other, (the ordering, bounded vs unbounded, dense vs discrete). Before defining a temporal

structure, one has to determine the relationship between temporal elements, ontological

primitives, and how those are ordered in time. This definitional step involves the axiomization

of temporal elements that make up a temporal structure.

Two structural models for designing and implementing time formalisms are outlined [21]: the

linear and semi-ordered. In the first model time is assumed to progress from past to the future

in a totally ordered manner. Time progresses from a point to the next in a temporal

perspective, first point followed by a second point. The second model allows for branching flow

of time which allows for many possible following points, future points that follows the first one.

Most of the literature on temporal formalism is concerned with conceptualizing timepoints and

intervals.

Reference [9] raised another issue in temporal formalism, whether time is anchored or not?

Anchored temporal information can be exactly located on the underlying time-line e.g., 30

March 2003 whereas unanchored temporal information has a known length e.g, lasting for one

month. But it doesn’t have specific starting or ending anchor points. The two dominant

temporal formalisms existing in the literature are timepoints and interval based models. These

are elaborated more in the following sub-sections.

4.1.1 Point-based Formalisms

The idea that timepoints should be the primitives in a temporal ontology has been a tradition

not only in the AI community but also researchers in temporal databases uses this assumption.

Modelling time as a point based element is also an important aspect in exploring and explaining

continuous outcomes. For instance, if someone throws a ball into the air then the intensity at

which a ball hits the ground depends on a timepoint. In addition, if intervals become necessary,

they can be introduced as ordered pairs of timepoints [40].

McDermott considers time as a left-linearly and right-partially unbounded, branching into

future and dense collection of timepoints [9]. Further, McDermott considered time as intervals,

collection of time points within two ends. In this formalism, two kinds of temporal properties

are introduced, facts and events. Facts are represented over timepoints while events are

represented over intervals. McDermott takes timepoints as ontological primitives and an

interval is defined as ordered pairs of timepoints. This indicates that events are continuous

outcomes consisting of more than one timepoint. This understanding of time as a modelling

mechanism in formalisms has been successful in solving planning problems [9]

Points based formalisms are representations of a set of time points that are related to each

other in a specified way. Time points are points that contain no duration. A given time point is a

special point on a time spectrum or time-line. Simultaneously, the beginning or ending of a time

point could not be distinguished.

Attributed to [9], we can formally define a point-based temporal formalism over a structure <T,

< >. In this case, T denotes a set of timepoints along with the attributive ordering relation <.

Additionally, this temporal structure has the following properties:

Ordering. For timepoints ordering there must be at least a partially ordered set consistent with

the following properties:

(irreflexivity) :(x < x)

(antisymmetry) ((x < y) ^ (y < x)) =) (x = y)

(transitivity) ((x < y) ^ (y < z) =) (x < z)

Additionally, one can impose a linear flow of time either only towards the past:

(left-linear) ((y < x) ^ (z < x)) =) ((y < z) ∪ (y = z) ∪ (z < y)) or

in both directions (i.e., towards the past and the future):

(linear) (x < y) ∪ (x = y) ∪ (y < x)

Boundness, or unboundness. The timepoints ordering structure may have a beginning and an

end (i.e., it is bounded), or have no end towards the past and the future

(right-bounded) ∀x∃y(y < x)

(left-bounded) ∀x∃y (x < y)

Dense or discrete. If there is always a timepoint between any two timepoints then the flow of

time is dense:

∀x,y(x < y) => ∃z(x < z < y)

Discreteness can be expressed as follows:

∀x,y((x < y) => ∃z((x < z) ^ ~∃w(x < w < z))

∀x,y((x < y) => ∃z((z < y) ^ :~∃w(z < w < y))

A dense collection of timepoints can be used for modeling continuous changes or events. Dense

collection of timepoints can be divided into sub-intervals. This use of intervals is significant in

modelling planning problems. Planning systems are composures of tasks, and can be subdivided

into sub-tasks. One of the issues with dense time structures is that one may not explicitly refer

to a time point preceding or following the set of time points made by the system. On the other

hand, in a discrete temporal structure some next timepoint can be expressed.

Let T be a set of timepoints, and < a strict total order on the set T. There are three main natural

relations between pair of timepoints in the set T: < (before), = (equals), and > (after). In point

based temporal formalism time is described by timepoints located on the underlying time-line

which characterize the flow of time. Point-based temporal formalisms fail to represent

information regarding duration of time. This gave a rise to developing other temporal

formalisms depending on time duration.

4.1.2 Interval-based Formalisms

As mentioned above, to represent a duration of time over which an event or continuous change

hold we use an interval. As we have seen in the case of point-based approaches, there are

many different possibilities regarding how intervals are defined and the relationships between

these intervals are established. Given a linear model of time, we still need to decide upon some

situations, for example whether an action within this linear order are represented as points or

not, whether the order is infinite in either (or both) future or past, etc. Additionally, we now

have the ontological primitive as an interval. Simply, this represents the period of time between

two actions or moments. But, of course, there are many possibilities here [37]. Are the end

points included in the interval? Can we have intervals that has only one timepoint in which the

start point and end point are the same? Can we have zero length intervals?

Note that much of the following sub-section is derived from [37].Supposing we have decided on

the basic structure of intervals and the flow of time, then when it comes to the reasoning in

such models we need to decide about some key questions. Imagine that we have the simple

model of time based on natural numbers N, Then, let us denote the interval between two time

points a and b by [a, b]. Now, we might ask:

• Does a particular time point x occur within or outside the interval [a, b]?

• Is a particular time point y adjacent to (i.e. immediately before or immediately after) the

interval [a, b] (and what interval do we get if we add y to [a, b])?

• Does another interval, [c, d], overlap with the interval [a, b]?

• Is the interval [e, f] a sub-interval of the interval [a, b]?

• What interval represents the overlap of the intervals [g, h] and [a, b]?

• Is the interval open or closed?

The last question certainly becomes applicable when we consider underlying sets such as the

Rational or Real Numbers. Informally, an element x in the temporal domain are within the open

interval (a, b) if a < x and x < b, and is within the closed interval [a, b] if a <= x and x <= b.

In [41] Allen define interval relations which are: before (b), meets (m), during (d), overlaps (o),

starts (s), finishes (f), equal (=),after (a), met-by (mi), contains (di), overlapped-by (oi), startedby

(si), finished-by (fi). They are pictorially represented as follows

The following are basic operations of temporal intervals, Let i and j are tow intervals such that

a= [a-, a+], and b= [b-, b+] a U b = [min(a-, b-) , max(a+, b+)] a П b = [max(a-, b-) , min(a+,

b+)] a < b = (a- < b- && a+< b+)

¬ [a-, a+] = [1, a-- 1] U [a++ 1, now]

In a temporal based formalism, particularly in Description logic, we usually define temporal

concepts or properties. Such properties are usually represented by concepts (unary predicate)

or a role (binary predicate) which will be satisfied at particular time intervals, we can also pose

questions such as:

• Does the concept C or role R hold throughout the whole interval [a, b]?

• Does the concept C or role R hold anywhere within the interval [a, b]?

• Does the concept C or role R hold by the end of interval [a, b]?

• Does the concept C or role R hold immediately before the interval [a, b]?

• Does the concept C or role R hold immediately after the interval [a, b]?

Various connectives allow us to express even more:

• Given an interval [a, b] where concept C or role R holds, is there another interval, [c,d],

occurring in the future (i.e. strictly after [a, b]), on which concept C or role R also holds?

• Can we divide up an interval [a, b] into two sub-intervals, [a, c1] and [c2, b] such that

concept C or role R holds constantly during [a, c1] but not at c2?

4.2 Temporal Description Logic

In Section 2.3 we presented the foundations of Description Logic without considering time. The

presentation of a formal framework of Description logic is strictly follows the ALC notation

introduce by Schmidt-Schauss and Smolka [15].The Researchers has examined different

approaches of temporal extensions of knowledge base systems for improving its expressivity, as

well as guaranteeing that the reasoning algorithms always terminate with the correct answers.

Artale and Franconi wrote a good survey that summarized temporal aspects of description logic

[36]. TDLs, which include the combinations of DLs with Halpern and Shoham's logic of time

intervals represents another interesting research work within the temporal description logic

[41]. There are also other formalisms inspired by action logics, and the treatment of time points

and intervals as a data type [42].

The first researcher who propose an extension of description logics with an interval-based

temporal logic is Schmiedel [52]. He suggested using some temporal modal operator like the

qualifier at, the existential and universal temporal quantifiers sometime and alltime. The at

operator specifies the time at which a concept holds while sometime and alltime are temporal

quantifiers introducing temporal variables. Temporal variables are constrained by means of

temporal relationships based on Allen’s interval algebra extended with metric constraints in

order to deal with durations, absolute times and granularities of intervals. To give an example

of Schmiedel‘s temporal description logic, we taken example from his paper [52], the concept

of Mortal can be defined as:

Mortal = LivingBeing and (sometime (x)(met-by x now).(at x (not LivingBeing)))

with the meaning of a LivingBeing at the reference interval now, who will not be alive at

some interval x met by the reference interval now. A concept denotes a set on pairs, <i, a>,

composed by a temporal interval and an individual. With the use of the at temporal operator it

is possible to bind the evaluation time of a concept to a particular interval of time.

Another example of Schmiedel‘s temporal description logic to represent the terminological

axiom

With the meaning of Doctors who were a PhD students.

Schmidel’s temporal description logic improves the expressive power due to the introduction of

temporal variables constrained by temporal relations. His logic is argued to be undecidable,

thus sacrificing the main benefit of description logics, i.e., the possibility to have decidable

inference techniques

Description Logic has several temporal extensions, but most of these aim to make languages

decidable by restricting the operators used. Artale and Franconi of [36, 43] proposed an

important temporal description logic extension. They propose an interval-based temporal

description logic TL_ALCF. They merged temporal logic TL with description logic ALC. The core

language of DL is extended to ALCF which can represent "functional roles". The functional role

means assigning the individual to a single value for that role-property. As an example which is

incorporated from their paper [43], consider the following temporal dependencies in Figure 1

which show the definition of the "Basic-Stack" action.

Figure 1 Temporal Dependencies in the definition of the Basic-Stack action [43]

In figure 1 x and y denotes some temporal intervals. # denotes the current interval or the

occurring time of the action type being defined. Basic-Stack denotes any action occurring at

some interval involving a * BLOCK that was once OnTable and then OnBlock. The Basic-Stack

action can be described as:

"meets" is one of Allen's interval operators. The model operation ◇ denotes the existential

quantification over intervals. "(C)@x" means temporally qualifying C, or C is qualified at interval

x. In this framework, a concept like "Mortal" can be defined as:

Another example of Artale and Franconi ‘s temporal description logic to represent the

terminological axiom

With the meaning of Doctors who were a PhD students.

In outlining their formalism with respect to the reasoning in their TDL, Artale and Franconi [36,

43] show that the subsuming problem is decidable. Further, they indicate that an empty

knowledge representation characterized by an unbounded and dense flow of time has PSpace

completeness for the satisfiability problem. They argue that the decidability comes from

restricting some operators; they suggest that the language does not allow for a universal

quantification over intervals.

In more recent work done by Artale, et al [53], the authors propose a tractable temporal

Description Logics which is based on a combination a sub-Boolean fragment of the

HalpernShoham interval temporal logic HS and ALC description logic. They use modal temporal

interval operators based on Allen interval operators (after, begins, ends, during, later, overlaps,

equals and their inverses). Their proposed TDL logic is motivated by possible applications in

ontologybased data access over temporal databases. The temporal operators of HS are of the

form <R> (`diamond') and [R] (`box'), where R is one of Allen's interval relations After, Begins,

Ends, During, Later, Overlaps and their inverses . Example incorporated

from their paper [53] ; the below axiom defines an advanced course that cannot be given

during the morning sessions;

Another axiom defines morning sessions

The authors in [56] proposed a temporal extension method which is based on the concrete

domain, which can be used to handle temporal knowledge conveniently. Their work only

incorporates time intervals, and they suggested a temporal description logic algorithm based on

ontology, which to a certain extent, enhances the expressivity of temporal description logic.

They also proved that the satisfiability of temporal domain is decidable.

Other line of work that concentrates on an application of temporal description logics reasoning

is [55], the authors proposed an approach for representation and recognition of motion

patterns. Their approach combines qualitative spatial and temporal reasoning and Description

logic that provides a formal basis for reasonable reasoning. The goal of their work is to detect or

recognize a motion patterns. Any motion pattern of a primary object with respect to the

reference object can be identified using their approach.

Quite often, temporally extending description logic entails the use of explicit modal logic

operators. This indicates that the temporal extensions are types of modal extension of

description logic. Temporal description logics do not have, in general, variables in the syntax,

thus making quantification implicit. Moreover, temporal DL reduces to a modal logic. Time is

removed from the syntax [44]. This leads to a situation where one may only quantify language

in a limited manner

At the moment, there is no agreement about a standard Temporal Description logics. The W3C

does not recommend a particular approach in this regard as standard TDL. This led researchers

to propose query languages that could extend DL with time. OWL is the most notable language

that blends DL and time together in an ontology language described in [45]. One of such

languages referred to as TL-OWL is the temporal extension of DL [45].it provides semantics for

TL-OWL as the extension of RDF's model-theoretic semantics. It also shows that reasoning in

TLOWL is decidable. For a comprehensive survey about temporal description logics we refer the

reader to [36].

4.3 Temporal RDF

Earlier, we briefly introduced the non-temporal RDF which will serve as the basic representation

model for the non-temporal information, and here we will discuss some literature reviews

about adding the temporal extension to it. The researchers have investigated different

approaches of temporal extension for the RDF and its language. The first formal treatment of

temporally extending RDF is in [58]. Their approach is based on temporal graphs that are RDF

triples labelled with time (time points or time intervals). They use additional vocabulary on top

of the RDF specification. The basic temporal RDF graph is defined in a conceptual level as

follows:

• A temporal triple is an RDF triple (s; p; o) with a temporal label t (t ϵ N). The expression

(s, p, o)[t1, t2] states that the triple holds true in the time open interval from t1 to t2.

• A temporal graph is a set of temporal triples.

• Given a temporal graph G and a time t, the slice of G at t G|t is a subgraph of all

temporal triples of G with temporal label t.

• u(G) = {(s, p, o)|(s, p, o)[t] ϵ G for some t}. u(G) is the underlying graph of the temporal

graph G.

A Temporal RDF graph is a set of temporal triples labeled with their interval of validity. These

triples are of the form (s, p, o): [t1, t2]. The graph in Figure 1 is an example incorporated from

the paper [58] of a Temporal RDF graph. An RDF graph can be regarded as a knowledge base

from which new knowledge which mean in this case other RDF graphs, may be entailed. In

temporal RDF, entailment is slightly more involved. This problem called a temporal entailment.

Based on the above 4 point definitions of temporal RDF, temporal entailment and slice closure,

are shown in [58], which lead to the formal semantics for temporal RDF model. The authors

further proves that given two temporal graphs G1 and G2, the problem of deciding if G1 entails

G2 is NP-complete.

A query language for the temporal RDF graphs is presented with corresponding formal

semantics. As an example, see the following Figure 3 as the database. This example is

incorporated from [58] and it shows a temporal RDF graph for the evolution of one Web

service.

A query: “find the service providers who have offered a Web service between time instants 0

and 2, and return them qualified by early provider” can be expressed in abstract syntax as:

In this query, the returned result may be non-temporal RDF graph that is, snapshot of the

temporal graph at specific time t.

In [59], the authors bring up the importance of designing indexing structure for temporal RDF.

Currently, RDF triples are still stored in relational database with some of the attributes being

"time". They argue that the standard relation indexes are inadequate to handle RDF's graph

structure.

In [71] a temporal querying of RDF data with SPARQL is presented. The author presented a

syntax based on named graphs to express temporal RDF. They claims that their approach can

perform any temporal query using standard SPARQL syntax only. They introduce a shorthand

format called τ -SPARQL for temporal queries and show how τ-SPARQL queries can be

translated to standard SPARQL. Moreover, they introduce a new indexing approach method

that can significantly reduce the time needed to execute time point queries.

Figure 3 A Temporal RDF graph for web services profiling of Sports networks [58]

In [60], a high-level description of temporal relations between (fragments of) Web sites to catch

the dynamics of the Web documents and the links between them. This description is based on

the RDF. Although this approach is not aiming at presenting a temporal knowledge

representation formalism, it's helpful to get familiar with the standard strategy they take to

solve the problem. They employ the Interval-based Temporal Logic (ITL), a simple linear model

of time, as their time model. From that, Allen's temporal operators can be modelled by

introducing a primitive relation meets. A XML-based Temporal Relation Specification Language

(TRSL) is then introduced to specify the time model. TRSL will be able to express the relations

Before, Meets, Overlaps, Starts, during, and Finishes that can be established between two

fragments of web sites or between two different Web sites. These temporal relationships can

be used to determine the dynamics of that Web sites' content.

In [72] the authors presented a logical approach for representing valid time in RDF, they also

extended SPARQL to allow for querying temporal graphs. They implemented their approach in

ExperienceOn’s backend system. The system is based on an extension of RDF that supports nary

relations. The PostgreSQL query language is used for data persistence and query processing.

Ontology reasoning is implemented by translating the ontology into a datalog program. Datalog

rules are changed in order to deal with validity time; additionally, the resulting set of facts

obtained by applying the rules is normalized to allow for efficient query answering. Finally,

temporal queries are translated into SQL and then evaluated using the query engine of

PostgreSQL.

4.4 Temporal OWL

Earlier, we briefly introduced the non-temporal OWL language, and here we will discuss some

literature reviews about adding the temporal extension to it. Recall that OWL only supports

unary and binary predicates. OWL relies on a logic-based formalism that largely employs binary

predicates. Adding a time component to the binary predicates used by OWL is done through the

inclusion of a time argument (t) for the binary predicates. In doing so, the time addition (t) here

is an interval based one. However, this treatments of adding the time (t) to the binary predicate

ends up with a ternary predicate which is not allowed in current OWL . Alternatively, many

researches look at ways of supporting temporal representation that sits on top of the core OWL

without modifying any of OWL's logic-based formalism. The kind of add-ons to OWL are not

usually lightweight and can't utilize the reasoning tool in most OWL tools [51].

Due to the representation limitation of binary predicate language construct of OWL, the

traditional OWL-based systems do not support temporal knowledge representation and

reasoning. This limitation prevents a wider application of OWL, e.g., clinical guideline systems.

The researchers have investigated different approaches for temporal extension for the OWL

and its language to deal with the shortcoming of only supporting binary predicates. Different

approaches have been taken to tackle the temporal representation problem: versioning, adding

temporality on top of OWL, reification, fluent, N-ary relations, or Named Graphs.

Versioning is a concept applied across several areas of computer science, including databases

and ontology. During the process of versioning, the model first gets modified like modifying the

ontology. Second, the modification is referred to as a new version to reflect it evolution. Third,

after saving both the old and the new versions, one optimizes the process of modification by

following meticulous steps that requires significant effort [51].

The drawback of ontology versioning is not only the redundancy but also the difficulty of

efficient query. To make things worse: suppose two aspects of time, valid time and transaction

time are both considered, the versioning approach would need to handle more snapshots of

the ontologies, not to mention even more type of time needs to be added.

Reification is a common technique for representing n-ary relations using a language such as

OWL that permits only binary relations [48]. Similar to the concept in database modeling when

we are faced with ternary relationship it is usually converted as weak entity connecting all other

participating entities by binary relations. In ontology, an n-ary relation is represented as a new

concept that has all the arguments of the n-ary relation as objects of properties. For example if

the relation R holds between objects X and Y at time t which will be a ternary predicate that is

not allowed in OWL, this is can be expressed as R(X,Y,t). Furthermore, in OWL, using reification

this is expressed as a new object with R, X, Y and t being its properties.

Figure 4 is incorporated from the paper [54] and it demonstrates the ternary relation WorksFor.

WorksFor(Employee, Company, TimeInterval) representing the fact that an employee works for

a company during a specific time interval.

Figure 4: Reification

The 4D-fluent approach [44] shows how temporal concepts and temporal relationship and their

evolution can be represented in OWL. Temporal Concepts are represented as 4-dimensional

objects with the timeslices as being the 4th dimension. Time interval class is created as a super

class and Time instances and time intervals are represented as instances of a time interval class

which in turn is related with temporal concepts or temporal roles as shown in Figure 5 which is

incorporated from [54]. Fluctuations occur on the properties of the temporal part of the

ontology keeping the non-temporal entities unchanged. The 4D-fluent approach sometimes

suffers from data redundancy if the ontology is large and different type of time is represented

but in contrast to other approaches it preserves full OWL expressiveness and better reasoning

support.

Figure 5: 4D fluent

The author in [57] proposed an extension for the 4D fluent temporal knowledge representation

method to deal with the shortcoming of the traditional OWL-based system, he studied a clinical

ontology systems as case study. By leveraging the extended 4D fluent method, it is possible to

model valid calendar time, repetitive temporal constraints and temporal relations.

N-ary relations [44] is another technique that represents an n-ary relation using an additional

object. N-ary relation is represented as two properties each related with the new object. It is

different from the reification approach where the n-ary relation is represented as the object of

a property. These two objects are related to each other with an n-ary relation. This approach

needs only one additional object for every temporal interval. See Figure.6 which is incorporated

from [54]. The figure illustrate the nary relation approach. This approach sustains property

semantics but suffers from data redundancy in the case of inverse and symmetric properties

because the inverse of a relation is added explicitly twice instead of once as in 4D-fluents.

Figure 6: N-ary Relation

Time Ontology Due to the increased availability of temporal information in the web and the

rapid growth of temporal information, time ontology has become one of the key techniques for

handling and organizing temporal data. In time ontology, events are temporal concepts and

temporal relations between events are either Point based or Interval based. Most existing time

ontologies incorporate Allen temporal interval relations.

Different time ontologies have been proposed: DAML ontology of time, the time ontology in

OWL, and KSL time ontology .These proposed time ontologies share a common understanding

about their domain. The DAML ontology of time is based on first-order predicate calculus

axioms. These axioms can be used to represent the other temporal theories that are more

specific. It considers both the point based and interval as temporal primitives [66].The time

ontology in OWL states the facts about topological relations among instants and intervals,

together with information about durations, and about date time information [67]. Similar to the

DAML ontology of time, this also supports the first order logic calculus. And it considers the

instants and intervals as the temporal primitives. The KSL time ontology (Knowledge Systems

Laboratory) is the simple time ontology that considers both the time points and time interval as

primitive elements on a time line[68].This ontology model the relationship between the

temporal primitives as a hierarchical structured class. It involves the relation between time

interval and time points, axioms and time granularity. KSL time ontology differentiates the

closed and open intervals.

Before the introduction of the Allen‘s temporal interval proposal, there had been different form

of calculus evaluated in the field of logical formalism. These logical formalism called situation

calculus and Event calculus and they are used in the ontological engineering. In situation

calculus [70], series of situations are represented as knowledge. Each situation acts as a

description of the world event at particular point of time. If a particular fact in situation calculus

is proved to be true, then it should be reprove as true in its succeeding instants of time

[70].Actions and events maps state to state. Event calculus uses the logical axioms for

representing and reasoning about actions and their effects.

5 Comparison

In this section we will briefly compare between several knowledge representations formalisms

that we mentioned previously for the aim of deciding upon better approach to knowledge

representation formalism. We will look at their similarities and differences.

There are similarities between logic-based knowledge representations formalisms due to that

Logic is fundamental to many formal knowledge representation and reasoning methodologies.

All logic-based knowledge representations formalisms provides syntax and semantics for

symbolic representation, truth conditions for sentences written in those languages, and rules of

inference for reasoning about sentences. Each Knowledge Representation formalism has an

expressive power and a complexity for retrieving and reasoning about a specific knowledge.

The differences between the several formalisms are in their expressive power and the

complexity of their reasoning algorithm. For example First-order logic has high expressive

power but it is undecidable while Description Logics has less expressivity and decidable

reasoning algorithm.

First-order logic (FOL) usually rely on half a dozen symbols to draw a given reasoning based on a

given knowledge base. Depending on the choice of predicates, highly expressive knowledge

representations can be constructed using these elements .Nevertheless, FOL does not perform

greatly when considering its complexity. FOL faces a challenge when it comes to its reasoning

algorithm, when we represent a lot of domain knowledge and the knowledge-based get large,

FOL will eventuality become undecidable. Therefore, FOL is not the most used formalism when

it comes to the current practice of knowledge representation [8].

Description Logics (DL) are subsets of first-order logic. In fact, the DL ALC corresponds to the

fragment of first-order logic obtained by restricting the syntax to formulas containing two

variables. ALC Description Logic perform greatly when considering its complexity. The

tractability of Description Logic is due to limiting its expressiveness of the representation by

restricting some logical operators.

FOL models the world in terms of Objects, which are things with individual identities. Properties

of objects that distinguish them from other objects. Relations that hold among sets of objects,

and Functions, which are a subset of relations where there is only one “value” for any given

“input”. FOL allows using free and bounded variables in FOL formula. Since the Description

logics are subset of First-order logic they model the world similarly. DL models the world in

terms of Concepts, roles, and individuals. DL doesn’t allow using variables in DL formula

While First-order logic semantics only allow us to talk about truths within the range {T, F} (true

or false), Modal logics are designed for reasoning about different modes of truth. For example,

they allow us to specify what is necessarily true, known to be true, or believed to be true [10].

These different modes often referred to as modalities – include possibility, necessity,

knowledge, belief and perception. While FOL is suitable for a variety of knowledge-based

system, Modal logic is only suitable for small knowledge-based system, here knowledge

representation is more limited.

There are some similarity between Description Logics and modal logic. Since DL focus on a

syntax formed by unary and binary predicates, it turned out that they are closely related to

modal syntax, if one considers roles in DL as accessibility relations in Modal logic. On the other

hand, we can model some features in Description Logics that did not have counterparts in

modal logics and therefore needed ad hoc extensions of the reasoning techniques developed

for modal logics [12]. In particular, we need to use specific treatment based on the idea of

reification in modal logic in order to deal with number restrictions as well as the treatment of

individuals in the ABox in DL.

OWL relies on a logic-based formalism .it only supports unary and binary predicates, and it

largely employs binary predicates. Adding the time component to the binary predicates used by

OWL is done through the inclusion of a time argument (t) to the binary predicate. In doing so,

the time addition (t) here is an interval based one. However, this treatments of adding the time

(t) to the binary predicate ends up with a ternary predicate which is not allowed in current

OWL . This is however not possible given the existing limitations of OWL in its facilities

regarding semantic web. Alternatively, many researches look at ways of supporting temporal

representation that sits on top of the core of OWL without modifying any of OWL's logic-based

formalism. The kind of add-ons to OWL are not usually lightweight and can't utilize the

reasoning tool in most OWL tools [51].

OWL and RDF differentiate in the expressive power of representing the knowledge. RDF model

the world as triple subject, object and predicate. It allows us to link resources (concepts)

together so we ca say for example that (Tom is a student). It represent it as directed graph.

However we can't classify objects so we can't say for example that student is a subclass of

person. RDFS gives us more expressive power. It allows you to classify resources by using the

class and subclass (rdfs:class, rdfs:subclass) notions. It also allows us to set restriction on the

properties (relationships) in our domain knowledge using rdfs:Domain and rdfs:range [24].

RDFS offers taxonomic relations, object relations and datatype properties. OWL has richer

vocabulary and is more expressive. OWL allows you to add more restrictions to our knowledge

representation. It categorizes properties (relationships) into object and data properties and

allows you to add restrictions on properties. OWL is a way of adding meaning .i.e., semantic

richness to RDF. Among other things this allows automated reasoning / inferencing. It is also a

way to define types for RDF data, though OWL "typing” differs from conventional type systems

in that it has an open world assumption. Moreover, OWL is represented using RDF triples and

typically expressed using RDF/XML syntax. However, OWL is not an extension to RDF, in the

same sense that DTDs are not extensions to XML. OWL does not allow us to say anything in RDF

that we couldn't say already using RDF triples [33].

6 Discussion

This survey indicates the existence of several knowledge representation formalisms with

temporal extensions. Brachman and Levesque [46] outlined the main problem in knowledge

representation and reasoning with respect to a temporal extension. They suggests that despite

the desire to have a rich expressive language from a knowledge representation view point, it is

undesirable from a reasoning stance. This is due to the intractability involved in obtaining

knowledge reasoning using a highly expressive language. This alludes to the fact that reasoning

consumes a large amount of resources and time when performed in a highly expressive

language. More importantly, reasoning algorithms in these contexts can be undecidable.

Knowledge Representation Systems aspire for high expressive languages without giving away

decidability. The goal of a good KRR system is to have high expressive power without sacrificing

its decidability. There are two compromises we can make in regards to the intractability

problem: (1) we can limit the expressiveness of the representation language, or (2) we can use

an undecidable reasoner.

Notwithstanding the above limitations, one may find a middle ground without sacrificing the

expressiveness or decidability. For instance, one may extend limited representation languages

to guarantee an acceptable modicum of reasoning. The extent to which such extensions affect

the computation processes in determining the decidability and robustness of reasoning is yet to

be settled by researchers. Some progress has been made; for example in the field of Description

Logics, much research has been conducted on which combinations of logical operators preserve

tractability. Moreover, undecidable reasoning algorithms are actually quite popular; they are

considered good approximations of problem solving procedures.

Semantic Web has expanded the knowledge representation and reasoning applications far

beyond what anyone may have expected given the large amount of information put forward

and shared on the Internet. RDF and OWL are tools that not only can be used within a Semantic

Web context, but also can extend much beyond their applications. Ontologies are flexible and

can be modified to fulfill interesting applications such as temporal extensions of existing

knowledge representation formalisms. OWL's Description Logic capabilities can be used in

semantic web, as well as extending these to include time elements. Currently, there is no

unified model for temporally extending knowledge representation formalisms and languages

including RDF, OWL and DL. Despite the proposal of several ways of extending time in existing

knowledge representation formalisms, the problems associated with knowledge reasoning

complexity, expressive power of corresponding query languages, and formal semantics have

not been fully explored.

This survey does not address the issue of uncertainty in knowledge. After all knowledge is

extracted from information that can suffer from reliability and validity issues. This can arise in

the knowledge acquisition phase from untrustworthy information sources, or inaccurate,

incomplete or out-of-date information. Researchers proposed Probability Logic, Fuzzy Logic,

and Bayesian Networks as some solutions to the issue of extracting information from uncertain

platforms. In Probability Logic, the truth values of formulae are given as probabilities. In Fuzzy

Logic, degrees of truth are represented by partial membership within sets. Using Bayesian

Networks we can graphically represent a set of variables and their probabilistic

interdependencies. These issues are beyond the scope of our work and we refer the reader to

[47] for an in-depth discussion on these topics.

7 Conclusion

This survey of the literature covers the basic approaches to logic-based knowledge

representation and some of its temporal extensions. First, a number of KR methods and

formalisms are reviewed. Second, we discussed each KR formalisms approach in detail

presenting its logical and formal construction. Third, we presents a discussion of how one may

extend some of these formalisms to incorporate time. This survey serves as a foundational step

in our current understanding of knowledge representation and the temporal extensions of

these methods. This will help solve problems involving time within the context of knowledge

representation and reasoning. In a future research, we search for a very expressive temporal

Description Logics and the formation of its reasoning algorithm.

References

[1] Chein, Michel, and Marie-Laure Mugnier. Graph-based knowledge representation: computational

foundations of conceptual graphs. Springer Science & Business Media, 2008.

[2] Tim Berners-Lee. Semantic Web Road map. W3C Design Issues. URL

http://www.w3.org/designIssues/Semantic.html, Oct.1998

[3] Alessandro Artale and Enrico Franconi. Introducing temporal description logics. In TIME, pages 2-5,

1999.

[4] G. Klyne and J. Carroll. RDF Concepts and Abstract Syntax. http://www.w3.org/TR/rdf-primer/,

2004.

[5] R.A. Akerkar and P.S. Sajja. Knowledge-based Systems. Jones and Bartlett Publishers, 2010.

[6] J. H. Boose. A survey of knowledge acquisition techniques and tools. Knowledge Acquisition. 1:3-37,

June 1989.

[7] Israel, D. J. The role of logic in knowledge representation, IEEE Computer 16(10), 37–42, 1983.

[8] Blackburn, P. & Bos, J. Representation and Inference for Natural Language: A First Course in

Computational Semantics, CSLI. 2005

[9] Drew V. McDermott. A critique of pure reason. Computational Intelligence, 3, 1987.

[10] Emerson, E. A. Temporal and modal logic, in the Handbook of Theoretical Computer Science.

Volume B: Formal Models and Semantics, Elsevier, pp. 996–1072. 1990

[11] Cresswell, M. J. Modal logic, in the Blackwell Guide to Philosophical Logic, Blackwell, pp. 136–158. 2001

[12] Halpern, J. Y. First-order modal logic, in Reasoning About Uncertainty, MIT Press, pp. 365–392. 2005

[13] Kripke, S. Semantical analysis of modal logic: Normal propositional calculi, Zeitschrift f¨ur

Mathematische Logik und Grundlagen der Mathematik 9, 67–96. 1963

[14] D. Calvanese, M. Lenzerini, and D. Nardi. Description logics for conceptual data modeling. In Logics

for Databases and Information Systems, pages 229.263. Kluwer Academic Publisher, 1998.

[15] M. Schmidt-Schauß and G. Smolka, Attributive concept descriptions with complements, Artificial

Intelligence 48(1) , 1991.

[16] Russell, Stuart J.; Norvig, Peter. Artificial intelligence: a modern approach. Upper Saddle River, N.J.:

Prentice Hall. p. 454. ISBN 978-0-13-604259-4, 2010.

[17] T.J.M. Bench-Capon. Knowledge Representation: An Approach to Artificial Intelligence, the APIC

SERIES 32. Academic Press, 1990.

[18] F. Baader, D. Calvanese, D. McGuinness, D. Nardi, and P. F. Patel-Schneider.The Description Logic

Handbook: Theory, Implementation and Applications. Cambridge University Press, 2010.

[19] Baader, F. Description logic terminology, in the Description Logic Handbook: Theory,

Implementation and Applications, Cambridge University Press, pp. 485–495. 2003

[20] Franconi, E. Description logic tutorial. URL – http://www.inf.unibz.it/~franconi/dl/course/. 2002

[21] Lukasiewicz, T. Probabilistic Description Logics for the Semantic Web, Technical report, INFYS

Research Report 1843-06-05, Technical University of Vienna, Austria, 2007.

[22] Armstrong, E. Working with XML. URL –

http://www2.informatik.huberlin.de/~xing/Lib/Docs/jaxp/docs/tutorial,2001.

[23] Sperberg-McQueen, C. & Thompson, H. XML Schema. URL –

http://www.w3.org/TR/2007/WDxmlschema11-1-20070830/.2007.

[24] Manola, F. & Miller, E. RDF primer. URL – http://www.w3.org/TR/rdf-primer/. 2004

[25] Carlos A. Hurtado Claudio Gutierrez and Alejandro Vaisman. Introducing Time into RDF. IEEE Trans.

on Knowledge and Data Engineering, 19:207-218, February 2007.

[26] RDF Vocabulary Description Language 1.0: RDF Schema. http://www.w3.org/TR/rdf-schema/.

[27] Prud’hommeaux, E. & Seaborne, A. SPARQL query language for RDF. URL –

http://www.w3.org/TR/rdf-sparql-query/,2007.

[28] Andy Seaborne. http://www.w3.org/Submission/RDQL/.

[29] Gregory Karvounarakis, So_a Alexaki, Vassilis Christophides, Dimitris Plexousakis, and Michel Scholl.

Rql: a declarative query language for rdf. In Proceedings of the 11th international conference on

World Wide Web, WWW '02, pages 592-603, New York, NY, USA, 2002. ACM.

[30] Jeen Broekstra and Arjohn Kampman. Serql: A second generation rdf query language. In Proceeding

of SWAD-Europe Workshop on Semantic Web Storage and Retrieval, 2003.

[31] Tim Furche, Fran_cois Bry, Sebastian Scha_ert, Renzo Orsini, Ian Horrocks, Michael Krauss, and

Oliver Bolzer. Survey over Existing Query and Transformation Languages, 2004.

[32] T.R. Gruber. Towards principles for the design of ontologies used for knowledge sharing. In N. GUARINO and R. POLI, editors, Formal Ontology in Conceptual Analysis and Knowledge Representation.

Kluwer, 1994.

[33] McGuinness, D. & Harmelen, F. v. OWL web ontology language overview. URL –

http://www.w3.org/TR/owl-features/,2004.

[34] Horrocks, I., Patel-Schneider, P., Boley, H., Tabet, S., Grosof, B. & Dean, M. SWRL: A semantic web

rule language combining OWL and RuleML. URL – http:// www.w3.org/Submission/SWRL/.,2004.

[35] Motik, B., Sattler, U. & Studer, R. Query answering for OWL-DL with rules, Journal of Web

Semantics: Science, Services and Agents on the World Wide Web 3(1), 41–60., 2005.

[36] A. Artale and E. Franconi. A survey of temporal extensions of description logics. Annals of

Mathematics in Artificial Intelligence, 30(1-4):171.210, 2000.

[37] P. Hayes and J. Allen. Moments and points in an interval-based temporal logic. Computational

Intelligence, 5(4):225-238, 1989.

[38] P. Ladkin. The logic of time representation. PhD Thesis, University of California, 1987.

[39] G. Ligozat and L. Vila. Ontology and theory of time. Working Draft, 1998.

[40] J. Allen. Maintaining knowledge about temporal intervals. Communications of the ACM,

26(11):832{843, 1983.

[41] J. Y. Halpern and Y. Shoham. A propositional modal logic of time intervals. Journal of the ACM,

38(4):935.962, 1991.

[42] C. Lutz. Interval-based temporal reasoning with general TBoxes. In Proceedings of IJCAI-01, pages

89.94. Morgan Kaufmann, 2001.

[43] Alessandro Artale and Enrico Franconi. Introducing temporal description logics. In TIME, pages 2{5,

1999.

[44] Christopher Welty, Richard Fikes, and Selene Makarios. A reusable ontology for fluent in OWL. In

Proceedings of FOIS, pages 226-236, 2006.

[45] Sang-Kyun Kim, Mi-Young Song, Chul Kim, Sang-Jun Yea, Hyun Chul Jang, and Kyu-Chul Lee. Temporal ontology language for representing and reasoning interval-based temporal knowledge. In

Proceedings of the 3rd Asian Semantic Web Conference on The Semantic Web, ASWC '08, pages 31-45,

Berlin, Heidel-berg, Springer, 2008.

[46] Brachman, R. J. & Levesque, H. Knowledge Representation and Reasoning, Elsevier, 2004.

[47] Halpern, J. Y. First-order modal logic, in Reasoning about Uncertainty, MIT Press, pp. 365–392.,

2005.

[48]Martin J. O'Connor and Amar K. Das. A Method for Representing and Querying Temporal Information in OWL. In Biomedical Engineering Systems and Technologies, Communications in Computer

and Information Science. Springer,2011.

[49] Theodore Sider. Four-dimensionalism: An ontology of persistence and time. Oxford Univ. Press,

2004.

[50] Artale, Alessandro, Enrico Franconi, and Federica Mandreoli. "Description logics for modeling

dynamic information." In Logics for emerging applications of databases, pp. 239-275. Springer Berlin

Heidelberg, 2004.

[51] Jerry R. Hobbs and Feng Pan. An Ontology of Time for the Semantic Web. ACM Transactions on

Asian Language Information Processing, 3:66-85, 2004.

[52] A. Schmiedel, A temporal terminological logic, in: Proc. of AAAI-90, Boston, MA (1990) pp. 640–645.

[53] Artale, A., Kontchakov, R., Ryzhikov, V., & Zakharyaschev, M. Tractable interval temporal

propositional and description logics. Association for the Advancement of Artificial Intelligence

(www.aaai.org). 2015

[54] Batsakis, Sotiris, and Euripides GM Petrakis. "Representing and reasoning over spatio-temporal

information in owl 2.0." Proceedings of the 6th Workshop on Semantic Web Applications and

Perspectives (SWAP’2010}, Bressanone7 Italy. 2010.

[55] Talukdar, Upasana, Rupam Barua, and Shyamanta M. Hazarika. "A description logic based QSTR

framework for recognizing motion patterns from spatio-temporal data." Recent Trends in

Information Systems (ReTIS), 2015 IEEE 2nd International Conference on. IEEE, 2015.

[56] Zhang, Xin, ChaoGang Wang, and Rui Wen. "Research Application of Temporal Description Logic

Algorithm based on Ontology." International Conference on Advances in Mechanical Engineering

and Industrial Informatics. Atlantis Press, 2015.

[57] Li, Hongsheng. "An extended HD Fluent Analysis of Temporal knowledge in OWL-based clinical

Guideline System." Thesis, University of Sydney (2014).

[58] Carlos A. Hurtado Claudio Gutierrez and Alejandro Vaisman. Introducing Time into RDF. IEEE Trans.

on Knowledge and Data Engineering, 19:207-218, February 2007.

[59] Andrea Pugliese, Octavian Udrea, and V. S. Subrahmanian. Scaling rdf with time. In Proceeding of

the 17th international conference on World Wide Web, WWW '08, pages 605-614, New York, NY,

USA, 2008. ACM.

[60] Sabin C. Buraga and Gabriel Ciobanu. A rdf-based model for expressing spatio-temporal relations

between web sites. In Proceedings of the 3rd International Conference on Web Information Systems

Engineering, WISE '02, pages 355-361, Washington, DC, USA, 2002. IEEE Computer Society.

[61] Carroll, J.J., Bizer, C., Hayes, P., Stickler, P.: Named graphs. Journal of Web Semantics 3(3) , 2005.

[62] Shuohao Zhang and Curtis E. Dyreson. Adding valid time to xpath. In In DNIS, pages 29-42.

SpringerVerlag, 2002.

[63] Rizzolo, Flavio, and Alejandro A. Vaisman. "Temporal XML: modeling, indexing, and query

processing." The VLDB Journal—The International Journal on Very Large Data Bases 17.5, 2008.

[64] Toshiyuki Amagasa, Masatoshi Yoshikawa, and Shunsuke Uemura. A Data Model for Temporal XML

Documents., Database and Expert Systems Applications, volume 1873 of Lecture Notes in Computer

Science, pages 334-344. Springer Berlin - Heidel-berg, 2000.

[65] Dengfeng Gao and Richard T. Snodgrass. Temporal slicing in the evaluation of xml queries. In

Proceedings of the 29th international conference on Very large data bases - Volume 29, VLDB '2003,

pages 632{643. VLDB Endowment, 2003.

[66] Jerry R. Hobbs , “ A DAML Ontology of Time “,2002.

[67] Feng Pan and Jerry R. Hobbs, "Time in OWL-S" Proceedings of the AAAI Spring Symposium on

Semantic Web Services, , pp. 29-36, AAAI Press,2004

[68] Qing Zhou, Richard Fikes: A Reusable Time Ontology-Proceeding of the AAAI Workshop on

Ontologies for the Semantic Web ,2002 .

[69] Feng Pan and Jerry R.Hobbs , “Time Ontology in OWL” World Wide Web Consortium, Working

Draft WD-owl-time-20060927, 2006.

[70] FengPan,”An Ontology of Time: Representing Complex Temporal Phenomena for the Semantic Web

and Natural Language”, ACM digital library , 2007.

[71] Tappolet, Jonas, and Abraham Bernstein. "Applied temporal RDF: Efficient temporal querying of RDF

data with SPARQL." The Semantic Web: Research and Applications. Springer Berlin Heidelberg,

308322. 2009.

[72] Motik, Boris. "Representing and querying validity time in RDF and OWL: A logic-based approach." Web

Semantics: Science, Services and Agents on the World Wide Web 12 (2012): 3-21.