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 I I interpretation Δ , and an interpretation function . that maps each ALC concept name C ∈ NC into I I I I I a subset of C ⊆ Δ and every role name r ∈ NR to a relation r ⊆ Δ x Δ and every individual name I I I a ∈ NI to an element in the domain a ∈ Δ .The interpretation function . 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 ∧
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 ... in HTML specifies that the enclosed text is displayed in bold font, whereas the pair
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:
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.
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.
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
(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,
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
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.