Re: Are there any plans to develop an OWL version of QUDT?

There are a number of reasons why the vocabularies at are
not legal OWL or RDF.  I will outline a few of the problems in the body of
the message, and try explain some of the consequences.  More detailed
justification of the claims for the claims can be found in the appendix.

There are many other issues;  I've picked a few examples that are easy to
understand for the typical public-vocabs reader, and which show some common
structural errors.

I also picked one that let me use an xkcd cartoon.

*Issue 1:  You can’t use user defined datatypes as the type of a literal *

Literals in RDF have data types.  For example, “1”^^xsd:integer  is the
number  1;  “1.1”^^xsd:decimal is the number 1.1, which is 0.1 louder.

OWL allows you to define named datatypes. For example, you can define the
datatype :wibble that is an  xsd:date or an xsd:dateTime or an xsd:string.
 However, the lexical space (roughly, the set of strings that can go inside
the double quotes) for a user defined data type is always empty, so you
cannot have a literal “2001-01-01”^^:wibble .
There are several reasons for this restriction; the most obvious one in
this example is that you have no idea what the value of the literal is - is
it the Jan 1st 2001? Or is it the string “2001-01-01”?

*Why it matters: *

RDF takes a very dim view of “ill-typed literals”.  If you have a triple
whose literal whose character string is not in the lexical space of its
data type,  and you know about that datatype, that triple is false.
 Unfortunately, the triples in a graph are asserted to be true.   So, if we
have an RDF graph that contains:

:fred :hasWibble   “2001-01-01”^^:wibble *(is true)*

the graph also  contains

:fred :hasWibble   “2001-01-01”^^:wibble *(is false)*

This is a contradiction, and ex falso quod libet (aka the principle of
explosion) applies:


I should note that although having an ill-typed literal is an error, it is
semantic, not syntactic. Under the old RDF 1.0 Semantics, the inconsistency
wouldn't have kicked in until RDFS derived it. It would still have been an

*(Claim A)  The RDF for VAEM (“Vocabulary for Adding Essential Metadata”)
is inconsistent and entails any RDF graph*

Corollary:  Any vocabularies that import VAEM are inconsistent. This
includes all the vocabularies listed in the QUDT catalog.

*Issue 2:  You can't use rdfs: IRIs as class names in OWL-2 DL*

OWL 2 declares certain namespaces as reserved.  Names from these namespaces
cannot be used as freely as other names in OWL-2 DL ontologies. This
includes all the names from the rdfs namespace.

*Why this matters:*

OWL-2 DL has certain useful properties as an ontology language.

   - It is *decidable *; that is, it is always possible to check if an
   ontology is consistent, find out which classes are subclasses of which
   other classes, etc.  This property is sometimes overrated; it is rarely
   useful to know that a reasoning task will finish in some finite amount of
   time, when you need to have an answer in the next five seconds.
   - There are several quite efficient reasoners for OWL-2 DL, and some
   very efficient reasoners for specified sub-profiles.
   - *There are no reasoners for OWL 2 Full*.
   - OWL 2 DL  Ontologies can mapped to and from RDF.
   - OWL 2 Full Ontologies can only be mapped to RDF; no reverse mapping is

*Claim (B):  The VAEM RDF file does not define an OWL 2 DL Ontology.*

Corollary 1:  Any vocabularies that import VAEM are not OWL 2 DL. This
includes all the vocabularies listed in the QUDT catalog.

Corollary 2: The QUDT ontologies have probably not been checked for
consistency. This can be inferred from the fact that the ontologies are not
consistent. For example, has a type
clash before the end of the ontology header.

Corollary 3: The QUDT ontologies cannot be edited or processed using OWL

*Issue 3:  rdf:Property is not a property type in OWL 2 Ontologies *

All OWL 2 properties must be of typed as Object Properties, Data
Properties, or Annotation Properties.  Under the DL restrictions, a
property can only be declared as one of the three kinds. Under Full OWL 2,
a property can be all three at once.

None of the rules for mapping OWL 2 properties into RDF generate triples of
the form  *x a rdf:Property.

If Full OWL 2 is used, DataProperty and AnnotationProperty are effectively
subclasses of ObjectProperty. Under the OWL 2 RDF semantics,
owl:ObjectProperty is equivalent to rdf:Property.

If for some reason you really, really want to generate a triple from an OWL
Ontology that says  *x a rdf:Property , you could make an assertion about
that the individual *x  is a member of the class rdf:Property .This would
be strange thing to do, as this triple would automatically be inferred if
*x is ever used as a property, and does not bring in to being any kind of
OWL property.

*Why this matters*

The RDF to OWL parsers in OWLAPI (used by tools like Protegé) will try
their best (when lax parsing is enabled) to guess what kind of OWL property
a bare rdf:Property was meant to be. This works well in some cases, but it
is something of a matter of luck - the parser is attempting to do its best
with an invalid owl file.

Strict parsers will fail if a  property with no valid OWL property type is
encountered.  All parsers will discard any rdf:Property triples.

If you want to have an OWL Ontology stored in RDF which can be loaded and
processed by OWL tools, don't type properties as just  rdf:Property.

 If you *need* a property whose value can be either a datatype or an
object, either declare it as an annotation property (if you don't need to
reason with it), declare it as an Object Property (if you don't need to
write any datatype Axioms about it), or declare it as an Object and Data

If you need to load and save an OWL 2 Full Ontology, do not use RDF; use
the Functional Style Syntax (FSS), which can handle non-DL  ontologies.

*Claim (C):  The VAEM RDF file is either not generated from an OWL 2
Ontology, or that Ontology contains unnecessary class assertions.*

Corollary 1:  RDF generated by non OWL tools can be difficult to work with
in an OWL based tool chain.



*Claim (A):  The RDF for VAEM (“Vocabulary for Adding Essential Metadata”)
is inconsistent  and thus entails any other graph. *

(1) The OWL-2 Abstract Syntax and Functional Style Syntax Specification,
(hereafter OWL2 AS/FSS),
states that:

 "[a] datatype definition DatatypeDefinition( DT DR ) defines a new
datatype DT [...] The datatypes defined by datatype definition axioms
support no facets so they must not occur in datatype restrictions.
Furthermore, *such datatypes have empty lexical spaces and therefore they
must not occur in literals*.”

(2) The OWL 2 Web Ontology Language Mapping to RDF Graphs (hereafter
OWL2RDF), §3<>
that a triple of the form

(a) *:x rdf:type rdfs:Datatype .

corresponds to the OWL declaration

Declaration( Datatype( *:x ) )

And that a triple of the form

(b) *:x rdf:type owl:Ontology .

corresponds to an OWL ontology header of the form

Ontology( *:x …  )

(3) The RDF Semantics specification (hereafter RDF-MT)

          "[a]n ill-typed literal is one whose *datatype IRI is recognized*,
but whose character string *is assigned no value by the lexical-to-value
mapping* for that datatype."

(4) RDF-MT §7.1<>

"any triple, and hence any graph, containing an ill-typed literal will be
D-unsatisfiable, i.e. false in every D-interpretation. This applies only to
literals typed with recognized datatype IRIs in D".

(5) RDF-MT §7.2<>
that a D-unsatisfiable graph entails any other graph by the principle of *ex
falso quodlibet <> [xkcd]*.

For more details see e.g. the discussion on the principle of
non-contraction in the Stanford Encyclopedia of Philosophy: Classical
Logic, §3 <>

The VAEM document at includes
the following triples:

(6) a owl:Ontology .

(7) vaem:dateUnion a rdfs:Datatype .

(8) vaem:dateCreated
"2011-04-20"^^vaem:dateUnion .

(9) is declared to be an
owl ontology  (2b,6).
(10)     The IRI vaem:dateUnion is declared as a datatype and hence is
(11)     Any RDF literal with the datatype IRI  vaem:dateUnion is ill typed
(12)     The graph at is
D-unsatisfiable  (4,8,11).
(13)     The graph at entails
any other RDF graph (5,12)* □*

*Claim (B):  VAEM cannot be mapped to an OWL 2-DL Ontology.*

To pick a single example:

(14)   OWL2 AS/FSS, §2.4 <> declares
all IRIS from the rdfs: namespace to be part of the reserved vocabulary.
(15)   OWL2 AS.FSS, §5.1 <> states

"IRIs from the reserved vocabulary other than owl:Thing and owl:Nothing must
not be used to identify classes in an OWL 2 DL ontology.”

(16)   OWL 2 RDF §3.2.5,  requires the  subject and object  of an
rdfs:subClassOf triple to refer to class expressions.

   The VAEM document contains the following triple:

(17)  vaem:numericUnion rdfs:subClassOf rdfs:Resource.

(18) The VAEM document uses an IRI from the reserved rdfs namespace to
identify a class, and hence does not represent an OWL 2 DL ontology
(17,16,15,14) *□*

*Claim (C):  The VAEM RDF file is either not generated from any OWL 2
Ontology, or that Ontology contains unnecessary class membership or
property assertions.*

Following the conversions of OWL 2 RDF §2, let:

   -   a denote an individual
   - OP   denote an object property
   - AP  denote an annotation property
   -  C  denote a class;
   - CE  denote a class expression

(19) No rule in OWL 2 RDF
  mentions rdf:Property.

(20) The only rules that can generate a triple whose predicate is rdf:type
and whose object is is not directly mentioned in §2 are:

     (a)  ClassAssertion( CE a )          ==>
*                                        T(a) rdf:type T(CE) . *

     (b)  AnnotationAssertion( AP as av ) ==>
*                                        T(as) T(AP)   T(av) .*

  (c)ObjectPropertyAssertion( OP a1 a2 ) ==>
*                                        T(a1)  T(OP)   T(a2) .*

  (d)ObjectPropertyAssertion( ObjectInverseOf( OP ) a1 a2) ==>
*                                        T(a2) T(OP) T(a1) .*

(21)   Named things  map to their names.

    (a)  T(a)  ==> *a*.
    (b)  if CE is a named class, T(CE)= T(C) ==> *C*

  (c)  T(AP) ==> *AP*

    (d)  T(OP) ==> *OP*

(22) The VAEM RDF contains the triple:
       vaem:ownedBy  rdf:type rdf:Property.

(23) The VAEM RDF does not contain any other triple matching

       vaem:ownedBy  rdf:type ?TYPE.

(24) IF the VAEM RDF was generated from an OWL Ontology, that Ontology
contains at least one of the following assertions (19-22):

(a)  ClassAssertion(rdf:Property  vaem:ownedBy)

(b)  AnnotationAssertion(rdf:type vaem:ownedBy rdf:Property)

(c)  ObjectPropertyAssertion(rdf:type vaem:ownedBy rdf:Property)

(d)  ObjectPropertyAssertion(ObjectInverseOf(rdf:type) rdf:Property

 (25) The RDFS Schema specification,
*,* defining rdfs:subPropertyOf, states that:

 A triple of the form:
  P1 rdfs:subPropertyOf P2

states that P1 is an instance of rdf:Property, P2 is an instance of
rdf:Property and P1 is a subproperty of P2.

(26) The VAEM RDF contains the triple:

vaem:rdfs:subPropertyOf vaem:ownedBy

(27)  The triple vaem:ownedBy rdf:type rdf:Property is entailed by the the
semantics of rdfs:subPropertyOf (25,26)

(28) Either the VAEM RDF file was  not generated from any OWL 2 Ontology,
or that Ontology contains unnecessary class membership or property
assertions. (24, 27)  *□*


[OWL2 AS/FSS]: OWL 2 Web Ontology Language Structural Specification and
Functional-Style Syntax:
[OWL2 RDF]: OWL 2 Web Ontology Language Mapping to RDF Graphs:
[RDF-MT]: RDF 1.1 Semantics.
[RDFS]:  RDF Schema 1.1

On Sat, May 3, 2014 at 8:31 PM, Ralph TQ [Gmail]

> Simon,
> Release 2.0 of QUDT is a significant change of 1.0, incorporating all of
> ISO 80000 and with naming and identifier compliance to NIST SP811 .  Before
> we can release 2.0, NASA needs to approve the editorial review of the NASA
> QUDT Handbook that you see mentioned in the presentation below. When can
> the release be expected? I would say sometime in June. This will be done as
> a set of schemas and some of the unit and quantity graphs.
> There is a presentation on QUDT release 2.0 at -
> A colleague of mine forwarded the recent post of yours at W3C. I’d like to
> know what you see as invalidating RDF?
> This is very strange because we work with QUDT as an RDF/OWL ontology set.
> Someone pointed out the way we use numericUnion and dateUnion caused
> problems with an OWL reasoner. Maybe this is an issue?
> You know that there are a number of schemas that make up QUDT? Each schema
> graph has its own base URI with OWL versioning.
> What level of OWL are you wishing to see in QUDT? It uses OWL classes with
> axioms for property restrictions. But not class expressions.
> -------- Original Message --------Subject:Re: Generic Property-Value
> Proposal for Schema.orgResent-Date:Sat, 03 May 2014 23:35:01 +0000
> Resent-From:public-vocabs@w3.orgDate:Sat, 3 May 2014 19:34:33 -0400From:Simon
> Spero <> <>To:Dan Brickley
> <> <>CC:Jason Douglas
> <> <>, Aaron Bradley
> <> <>,
>  <> <>, W3C
> Web Schemas Task Force <> <>, Jay
> Myers <> <>, Mike Bergman
> <> <>
> On Fri, May 2, 2014 at 3:27 PM, Simon Spero <> wrote:
>> WRT vocabularies for units and  quantities:  there's always the
>> NASA/TopBraid QUDT ontology, which seems to be moving on towards a new
>> version.
>> See
> Something I need to clarify: after checking, the schemas currently
> available on the site are not valid OWL or RDF, so I cannot recommend their
> use at this time.
> Simon
> Ralph
> On May 3, 2014, at 7:12 PM, Simon Spero <> wrote:
> Hi Ralph-
>    I saw that the homepage is showing an updated date of this
> March, so it looks like you're making headway on getting the release out.
> I was wondering if there are any plans to release an OWL version of the
> ontologies?
> Thanks,
> Simon

Received on Tuesday, 6 May 2014 20:08:02 UTC