Ontology FAQ

What is an ontology?

It is a document that defines the semantics of a specific vocabulary. Much like a database schema, the ontology defines through axioms the classes and their associations with one another as well as cardinality restrictions. Such axioms might be the definition of classes (say, BreakdownElement, SoftwareElement, HardwareElement, etc.); their properties; their subclasses, etc.

An ontology simply defines vocabulary. A dataset that uses undefined vocabulary (i.e. classes or properties that are not defined in any active ontology) is not invalid per se; in practice, it will not present the benefits of one with a properly defined vocabulary and thus, will prove less useful, but it will still be valid.

Ontologies can be shared so that several exchanging parties have a reference vocabulary. In this case, the ontology is exchanged only once and backs up all the ensuing application data exchanges.


What is the difference between an ontology and a schema?

Schemas (as in database schemas) are generally used for validation purposes; any dataset that has been confirmed to comply with a given schema is guaranteed to be well structured (but not necessarily meaningful).

Ontologies define vocabulary, which helps machines and developers to understand the application data; the possibilities are then virtually unlimited.

On the Semantic Web, ontologies are generally used by reasoners to infer triples that were not explicitly stated in the application data; any possible inconsistencies in the data are liable to cause reasoning errors (inability of a reasoner to cope with conflicting inferences) or wrong inferences. Either way, the process of inferencing data may be long and require machine resources; the ontologist must work in order to establish an efficient ontology (based on one of the available OWL profiles) that will repel those bad inferences.

Our use case is quite different; the ontology is used by our internal applications to:

  • generate SPIN rules, which in turn can be executed by a SPIN API; the result of this operation is the validation of the data or reports of violations or inconsistencies in the data;
  • pass along essential information to our data merging engine so that it can determine how and when to accept data from some third party before merging it;
  • pass along other valuable information: XSD enumeration codes (for allowing S3000L XML export/import) or PLCS classes to use (for allowing PLCS-PSM export/import);
  • contain SPIN inference rules that are executed by a SPIN API; the result of this operation is the construction of new triples based on the existing data.

Thus, the ontology has a much broader scope of applications than the traditional schemas and the implementation dictates its utilization and not the other way around.


What kinds of rules are described in an ontology?

The S3KL ontology was modelled from the S3000L 1.1 UML class diagrams. It was designed in such a way that it conveys the same information as in there with some other information to allow a better querying of the data:

    rdf:type owl:Class, s3kl:ClassS3000L ;
    rdfs:subClassOf s3kl:BreakdownElement .

    rdf:type owl:Class, s3kl:ClassS3000L ;
    rdfs:subClassOf s3kl:TypicalIndividual, s3kl:FunctionalPhysicalObject ;
    owl:hasKey ( s3kl:id ) .

In this excerpt, the classes s3kl:HardwareElement and s3kl:BreakdownElement are defined. Among several things, the following can be witnessed:

s3kl:HardwareElement is a sub-class of s3kl:BreakdownElement

This information allows our engine to understand that any hardware element is also a breakdown element. The immediate benefit is when querying data: it becomes possible to get a hold of a the elements, be they hardware, software or zonal with a simple query such as SELECT ?element WHERE { ?element a s3kl:BreakdownElement }. This becomes possible by loading the right inference models (here, simple RDF subtype inferencing) or by using specific property functions.

All s3kl:BreakdownElement individuals are uniquely identified by a key

This information allows our engine to merge datasets from different sources. Thus, any two (or more) breakdown elements that are related (using the property s3kl:id) to the same value are considered the same breakdown element and identical treatment is applied to all of them, indistinctly.

This is our own way of dealing with keys; in the Semantic Web, owl:hasKey is a property that can be computed by OWL DL reasoners, which can infer owl:sameAs statements between two distinct individuals that have the same key. If owl:sameAs inferencing is enabled, the end result is identical.

s3kl:BreakdownElement and s3kl:HardwareElement are S3000L classes

This axiom brings interesting (albeit noncritical) insight because we can now can get a hold of all the S3KL classes directly defined in the S3000L data model (This can otherwise not be done easily because the class mapping between S3KL and S3000L is not one-to-one).


In what language does one define an ontology?

The RDF (Resource description framework) data model is used to define an ontology; that is, just like application data, an ontology is defined in the form of triples. The underlying vocabulary is RDFS (RDF Schema) and possibly one of OWL (Web Ontology Language)'s specific profiles. Finally, the representation of the ontology in text files can be any serialization of RDF (TTL, RDF/XML, N3, etc.).

  • RDFS vocabulary includes: rdfs:subClassOf (for defining subclass relationships); rdfs:subPropertyOf (for defining subproperty relationships); rdfs:domain, rdfs:range (for defining property domains and ranges); etc. (View the complete vocabulary)
  • OWL DL's vocabulary includes: owl:Class (for defining classes); owl:DatatypeProperty, owl:ObjectProperty (for defining properties); owl:Restriction (for defining cardinality, data/object type restrictions, etc.); etc. (View the complete vocabulary)

Beyond these two main pieces, any other vocabulary can be used, for example to re-use or extend a foreign, already defined ontology available on the Web. You could for example create your own ontology based on the S3KL ontology.