OWL-MeT abstract syntax

OWL-MET Ontology Language Semantics and Abstract Syntax.

Abstract Syntax.


(Draft)
Last revision is: 1.12
Date is: 02 April 2007 08:54 PM

The abstract syntax is specified here by means of a version of Extended BNF, very similar to the EBNF notation used for XML [XML]. Terminals are quoted; non-terminals are bold and not quoted. Alternatives are either separated by vertical bars (|) or are given in different productions. Components that can occur at most once are enclosed in square brackets ([…]); components that can occur any number of times (including zero) are enclosed in braces ({…}). Whitespace is ignored in the productions here.

1. Temporalized Ontologies

An OWL-MET ontology in the abstract syntax contains a sequence of annotations, axioms, and facts. OWL-MET ontologies can have a name. Annotations are used in the same manner as in OWL. The main content of an OWL-MET ontology is carried in its axioms and facts, which provide information about classes, properties, and individuals in the ontology.

ontology ::= 'Ontology(' [ ontologyID ] { directive } ')'
directive ::= 'Annotation(' ontologyPropertyID ontologyID ')'
| 'Annotation(' annotationPropertyID URIreference ')'
| 'Annotation(' annotationPropertyID dataLiteral ')'
| 'Annotation(' annotationPropertyID individual')'
| axiom
| fact

Names of ontologies are URI references.
Ontologies incorporate information about classes, properties, and individuals, each of which can have an identifier which is a URI reference. Some of these identifiers need to be given axioms.

datatypeID ::= URIreference
classID ::= URIreference
tclassID ::= URIreference
individualID ::= URIreference
ontologyID ::= URIreference
instantID ::= URIreference
datavaluedPropertyID ::= URIreference
individualvaluedPropertyID ::= URIreference
annotationPropertyID ::= URIreference
ontologyPropertyID ::= URIreference

As in OWL, a URI reference cannot be both a datatypeID and a classID in an ontology, but URI reference classID is also considered as URI reference tclassID. Additionally, a URI reference also cannot be more than one of a datavaluedPropertyID, an individualvaluedPropertyID, an annotationPropertyID, or an ontologyPropertyID in an ontology. However, as in OWL Full, URI reference can be the identifier of a class or datatype as well as the identifier of a property as well as the identifier of an individual, although the ontology cannot then be translated into an OWL DL RDF graph.
Annotations are used to record information associated with some portion of the construct.

annotation ::= 'annotation(' annotationPropertyID URIreference ')'
| 'annotation(' annotationPropertyID dataLiteral ')'
| 'annotation(' annotationPropertyID individual ')'

2. Facts

There are two kinds of facts in the OWL-MET abstract syntax.
The first kind of facts states information about a particular individual, in the form of classes that the individual belongs to plus properties and values of that individual. An individual can be given an individualID that will denote that individual, and can be used to refer to that individual. However, an individual need not be given an individualID; such individuals are anonymous (blank in RDF terms) and cannot be directly referred to elsewhere. The syntax here is set up to somewhat mirror RDF/XML syntax [RDF Syntax] without the use of rdf:nodeID.

fact ::= individual
individual ::= 'Individual('[ individualID ]{ annotation }{'type(' type ')'}{value}')'
value ::= 'value(' individualvaluedPropertyID individualID ')'
| 'value(' individualvaluedPropertyID individual ')'
| 'value(' datavaluedPropertyID dataLiteral ')'

Types can be class IDs, OWL Lite restrictions and general descriptions, which include class IDs and OWL Lite restrictions as well as other constructs.

type ::= classID
| tclassID
| restriction
| description

Data literals in the abstract syntax are either plain literals or typed literals. Plain literals consist of a Unicode string in Normal Form C and an optional language tag, as in RDF plain literals [RDF Concepts]. Typed literals consist of a lexical representation and a URI reference, as in RDF typed literals [RDF Concepts].

dataLiteral ::= typedLiteral | plainLiteral
typedLiteral ::= lexicalForm^^URIreference
plainLiteral ::= lexicalForm | lexicalForm@languageTag
lexicalForm ::= as in RDF, a unicode string in normal form C
languageTag ::= as in RDF, an XML language tag

The second kind of fact (as in OWL) is used to make individual identifiers be the same or pairwise distinct.

fact ::= 'SameIndividual(' individualID individualID {individualID} ')'
| 'DifferentIndividuals(' individualID individualID {individualID} ')'

3.Axioms


axiom :: = temporal_axiom | owl_axiom
owl_axiom :: = 'Class(' classID ['Deprecated'] modality { annotation} {description } ')'
| 'EnumeratedClass(' classID ['Deprecated'] { annotation } { individualID} ')'
| 'DisjointClasses(' description description { description }')'
| 'EquivalentClasses(' description{ description} ')'
| 'SubClassOf(' description description ')'
| 'Datatype(' datatypeID ['Deprecated'] { annotation} ')'

temporal_axiom :: = 'TClass(' tclassID modality { annotation} {tdescription } ')'
| 'DisjointClasses(' tdescription tdescription { tdescription } ')'
| 'EquivalentClasses(' tdescription { tdescription} ')'
| 'SubClassOf (' tdescription tdescription ')'
| 'EnumeratedClass (' tclassID { annotation } { individualID } ')'
| 'TimeStructure(' instantID {instantID} ')'

modality :: = 'complete' | 'partial'

description :: = classID
| 'unionOf(' {description } ')'
| 'intersectionOf(' { description } ')'
| 'complementOf('description ')'
| 'oneOf(' { individualID} ')'

tdescription :: = description
| tclassID
| trestriction
| 'unionOf(' { tdescription } ')'
| 'intersectionOf(' { tdescription } ')'
| 'complementOf(' tdescription ')'
| 'oneOf(' { individualID} ')'

trestriction :: = 'TRestriction(' timeProperty ')'

timeProperty :: = 'allfuture(' description ')'
| 'allpast(' description ')'
| 'future(' non-negative-integer ')' description
| 'past(' non-negative-integer ')' description
| 'at(' instantID ')'description