owled | A simple experiment with Node.JS Arduino Johnny-Five

The spec says yes. (emphasis mine)

Note:
The date and time datatypes described in this recommendation were inspired by [ISO 8601]. '0001' is the lexical representation of the year 1 of the Common Era (1 CE, sometimes written "AD 1" or "1 AD"). There is no year 0, and '0000' is not a valid lexical representation. '-0001' is the lexical representation of the year 1 Before Common Era (1 BCE, sometimes written "1 BC").

In OWL

Assuming DifferentIndividuals: :s1, :s2 etc.:

REPLACE is the function to apply a regular expression, with () match groups, and calculate a return string based on the match using $1 to get the group actually matched. It is based on fn:replace from "XPath and XQuery Functions and Operators" as are many of the SPARQL functions.

It gives you this error because the Hermit reasoner has found that your ontology is inconsistent. This uses Artificial Intelligence reasoning procedures based on Description Logics to find logical errors in the statements of your ontology. Your other ontology did not give an error because it did not find any logical inconsistencies. You can check this yourself using Protege which you can download here.

If you open your ontology in Protege and run the Hermit reasoner, it will state that your ontology is inconsistent and it will provide reasons for the inconsistency. Here is a screenshot of the inconsistencies as displayed in Protege:

Looking at the first inconsistency it states

The problem that is mentioned in the question is a known issue within the RDF community and has been discussed in peer-reviewed papers.

With respect to the second approach mentioned in the question, one may think that is completely unnatural to write using intermediary objects. However, ontologies to describe measurements of things may have been written considering several aspects in mind. For example, in the case when something expands in at a particular instant, intermediary objects may be needed to specify the time of these measurements. Surely, there are situations where these additional descriptions are not required.

The problem with the first approach is that it completely restricts prop:density to only one unit. If you have a density in a different unit, you will have to perform conversions.

I think that an easy solution in your context is to introduce specific datatypes.

In OOP, you have two ways to "combine" objects: multiple inheritance or composition. In the first, you use a class C which inherits from A and B. In the latter, you create a generic object C, which contains references from objects generated from A and from B.

For multiple inheritance, you can check the chapter 9.3.1 Multiple Inheritance of the Basic Programming Guide to see how to implement it in CLIPS.

In practice, you need to specify the multiple types within the defclass construct.

You probably are trying to execute the method before the DOM is safe to be manipulated. The underlying issue is that you've put all your script tags in the head tag and not after the body content. Try wrapping your call in the following:

The example you have posted demonstrate one of the corner cases of the SPARQL specification, which combines multiple related topics and are highly ambiguous in my opinion. The details below explain what are the taken assumptions and design decisions in the GraphDB engine. Please note that this might be different from the way other implementations read the following specification lines:

Interplay of SERVICE and VALUES

The SPARQL Federation 1.1 has a non-normative section describing what should be the behavior in this case:

Implementers of SPARQL 1.1 Federated Query may use the VALUES clause to constrain the results received from a remote endpoint based on solution bindings from evaluating other parts of the query.

GraphDB's query optimizer cannot retrieve any statistics from the remote SPARQL endpoint, so it takes the approach to throw naively the query to the remote SERVICE and join locally the results. Thus, the query optimization task is in the hands of the user who knows the schema in the two repositories by rearranging the query in a procedural way (see below).

Federated queries are sub-queries

Every remote query is treated as a sub-query and sent as it is to the external endpoint. Here is the equivalent syntax:

java.lang.ClassNotFoundException: org.protege.editor.owl.model.hierarchy.roots.Relation

There are other dependencies you need. Rather than going piecemeal, you should use a build system that can resolve the dependency closure for you, such as Maven, Gradle or similar.

The problem here is not Protege specific or ontology related, it's just plain Java libraries missing from the classpath.

Note that your code does not use OWL API. These classes are Jena classes and Protege classes (from Protege 3.x, I'd think). Note that Protege 3.x is a very dated API. Consider using a newer version (5.2.0 or newer), or directly using the actual OWL API. See https://github.com/owlcs/owlapi/wiki/Documentation

OWL API also has zip files containing all dependencies, which might simplify your work (Maven is still better than resolving dependencies by hand). See https://github.com/owlcs/releases/tree/master/owlapi/5