I have come across various kinds of exolanations and pointers to the actual type of OWL language that is used. while some people refer to OWL Full as a vaid language for a particular syntax, others mention names such as OWL DL and further try to divide their explanation by saying the syntax is valid in OWL1 but not in OWL2 and like. Does anyone know how do we learn the actual difference between these variations of OWL? is there a document somewhere that shows the actual differnce between these versions of OWl clearly and explain what is allowed where?

asked 11 Nov '10, 19:41

Abhishek%20Shivkumar's gravatar image

Abhishek Shi...
accept rate: 0%

The W3C OWL Overview Page gives a comprehensive introduction to the differences:

See http://www.w3.org/TR/2004/REC-owl-features-20040210/#s1.3 and http://www.w3.org/TR/2004/REC-owl-features-20040210/#s2.1

permanent link

answered 12 Nov '10, 13:11

Weizen's gravatar image

accept rate: 50%

edited 12 Nov '10, 13:29

Clearly? no.

There are certain constructs in OWL that end up potentially sending a reasoner into an infinite process of deductions. OWL DL is a subset of OWL where this provably cannot happen.

As DL is a subset of OWL, certain things are not allowed. They're not forbidden as such, but they pop you out of DL and into Full. A simple example is asserting that a blank node or a URI is owl:sameAs a literal:

_:this owl:sameAs "Hello" .

Another example of something not allowed in DL is a resource which is simultaneously a class and an individual.

OWL Lite is an even smaller subset of OWL DL, thought to be computationally simpler to implement.

OWL2 is an update to OWL. It introduces a new non-RDF XML syntax as an alternative way of expressing OWL. (And there's also the Manchester syntax which hasn't been standardised but is another popular non-RDF syntax for OWL.) It introduces a few new ideas like property chains (e.g. saying that { ?x ex:uncle ?y } is equivalent to { ?x ex:parent ?z . ?z ex:brother ?y . }).

OWL2 has its own version of DL which is a little less restrictive - it allows resources to be both classes and individuals. It performs this feat by reasoning about the resource's class nature separately from reasoning about its individual nature (called "punning" - a pun is a joke that relies on a word having to meanings).

OWL2 also introduces some other subsets EL (which is apparently good if you've got a lot of classes and properties); QL (which is good if you've got a lot of individuals); and RL (which is designed to be implementable on top of rules engines like cwm).

permanent link

answered 11 Nov '10, 22:31

tobyink's gravatar image

tobyink ♦
accept rate: 26%

There are already 2 slightly related questions to that topic. You may find some useful informations there:

permanent link

answered 12 Nov '10, 13:58

Bastian%20Spanneberg's gravatar image

Bastian Span...
accept rate: 21%

The relationship between OWL (1/2) DL and OWL (1/2) Full is pretty complex. Chap. 7 of the the OWL 2 RDF-Based Semantics [1], which provides the normative specification of OWL 2 Full, describes a very technical correspondence between OWL 2 DL and OWL 2 Full. There is also the introduction chapter 1 of the same document that might be helpful to get an idea of the characteristic aspects of OWL 2 Full, but it does not treat OWL 2 DL.

There are several aspects, in which OWL DL and OWL Full differ (when saying "OWL DL" or "OWL Full", I will typically refer to OWL 2 DL and OWL 2 Full):


The native syntax of OWL Full is RDF or, more precisely, the RDF Abstract Syntax [2]. This is so, since OWL Full is meant to be a language for providing a semantic meaning for every possible RDF graph. Hence, OWL Full entirely deals with triples, or sets of triples. The native syntax of OWL DL, on the other hand, is the OWL 2 Structural Specification [3]. This syntax defines direct representations for every OWL construct, instead of encodings by one or more RDF triples. In fact, OWL DL's abstract structural syntax is defined largely independently of RDF, and the relationship to RDF is rather defined via an RDF mapping [4] that maps each construct to a set of triples, and back.

In OWL DL, only those sets of triples that correspond to a construct in the abstract syntax are syntactically valid. So, obviously, there remain RDF graphs that are not valid "OWL DL ontologies in RDF graph form". In addition, OWL DL defines several constraints that disallow certain uses or combinations of language constructs, mostly in order to retain decidability of OWL DL, and this further reduces the number of RDF graphs that are valid OWL DL ontologies. See this other answer for a list of some of the things that cannot be done in an OWL DL ontology. Unlike OWL DL, OWL Full does not define any syntactic restrictions, and so every RDF graph is a valid OWL Full ontology.


OWL Full is a conservative extension of the model-theoretic semantics of RDFS [5], in the sense that every semantic conclusion that is true in RDFS is also true in OWL Full. OWL Full just adds semantics for the additional OWL features, and these are defined in the "OWL 2 RDF-Based Semantics" [1]. Even the main design principles that have been applied for the definition of the RDFS semantics have been reused for the definition of OWL Full, for example that data properties are individuals that have an extension assigned, which is a binary relation. Think of OWL Full as RDFS plus a bit -- a very large bit, indeed, so large that OWL Full becomes computationally troublesome (see below).

While the semantics of OWL Full is defined directly for RDF graphs, the semantics of OWL DL, the "OWL 2 Direct Semantics" [6], is defined for OWL DL's abstract structural syntax [3]. So in order to understand what an OWL DL ontology in RDF graph form means, you need to first map the graph into OWL DL's structural syntax via the RDF mapping [4] and then apply OWL DL's semantics to the result.

The semantics of OWL Full and OWL DL differ in several ways, such as that classes are sets in OWL DL while being individuals in OWL Full, or that individuals and data values are strictly disjoint in OWL DL, while data values are just special individuals in OWL Full; well, everything is an individual/resource in OWL Full, but OWL DL strictly distinguishes between the different types of entities. The semantics of OWL DL in fact follows classical set theory / first order logic, while the semantics of OWL Full is a non-classical logic that has specifically be taylored to meet the requirement to give meaning to every RDF graph without leading to logical conflicts.

Computational Aspects:

OWL DL is computationally decidable, that is, one can build a reasoner that always terminates and returns the correct result -- provided that the reasoner has enough memory to process the query (and that the user has enough patience to wait for a result :-)). Decidablity was a core design criterion in the development of OWL DL, and many of the syntactic restrictions that exist in OWL DL have been introduced to retain decidability.

However, the computational complexity (according to traditional complexity theory) of OWL DL is high. OWL Lite was a first try in OWL 1 to build a less complex sub-language of OWL DL in terms of further syntactic restrictions. So OWL Lite is different from OWL DL only in what you can validly write down in an ontology; the semantics is the same for both languages. OWL 2 introduced further syntactic fragments, called "Profiles" [7], which lead to considerably lower complexity bounds.

For OWL Full, computational aspects have never played a role in its design, only logical/semantical aspects. OWL Full has been designed to give a precise semantic meaning to every RDF graph, while at least sharing the semantic expressivity of OWL DL, hence basically covering "all of OWL"... at any cost! :-) Since none of the restrictions that OWL DL uses for retaining undecidability are enforced in OWL Full, OWL Full in fact turns out to be undecidable.


OWL DL is basically a description logic, stemming from decades of description logics research in the context of knowledge representation research. Technically, the only connection between OWL DL and RDF is the RDF mapping [4]; the technical core of OWL DL, consisting of its syntax [3] and semantics [6], has (almost) no normative relationship to RDF.

OWL Full, on the other hand, is not a description logic and has been solely specified as a language being based on RDF, sharing all of RDF(S)'s syntax, semantics, and the basic design ideas as first given in the original RDF Schema definition [8] (Sec. 2 of this document is of particular interest).

There is probably no life outside the RDF world for OWL Full, at least no intended one. For OWL DL, on the other hand, there are many possible lives outside the RDF world and, in fact, RDF is only one of many serialization languages for OWL DL. To my knowledge, quite some OWL modelling is done without using RDF or, if at all, only using it as an "invisible" storage-and-exchange syntax.

Example List of Differences:

To conclude, maybe a random, concrete list of things that distinguishes OWL Full from OWL DL is of additional help.

It would be entirely fullish to believe ...

  • ... that owl:Class, owl:Restriction or owl:FunctionalProperty are classes;
  • ... that owl:equivalentClass is a sub-property of rdfs:subClassOf;
  • ... that from :c1 owl:equivalentClass :c2 follows semantically :c1 rdf:type owl:Class;
  • ... that from cyc:Country owl:sameAs dbpedia:Country and cyc:England rdf:type cyc:Country follows that cyc:England is also an instance of dbpedia:Country;
  • ... that one can work-around the problem of not having literals as subjects in RDF by stating something like _:lll owl:sameAs "foo" and then create assertions with the bnode _:lll in subject position;
  • ... that RDF lists can be used as normal entities, or to discuss whether rdf:first should be a functional property or not;
  • ... that OWL is an extension of RDFS.









permanent link

answered 15 Nov '10, 12:10

Michael%20Schneider's gravatar image

Michael Schn... ♦
accept rate: 34%

Your answer
toggle preview

Follow this question

By Email:




Answers and Comments

Markdown Basics

  • *italic* or _italic_
  • **bold** or __bold__
  • numbered list: 1. Foo 2. Bar
  • basic HTML tags are also supported

Question tags:


question asked: 11 Nov '10, 19:41

question was seen: 7,719 times

last updated: 15 Nov '10, 12:10