This document specifies the Manchester syntax for OWL 1.1.
This syntax is used in Protege 4 and TopBraid composer and is designed
to be user friendly.
Status of This Document
This is an initial draft.
Table of Contents
1 Introduction
The Manchester OWL syntax is used in Protege 4 (http://protege.stanford.edu/)
and TopBraid composer (http://www.topquadrant.com/topbraid/composer/).
It was originally
[Manchester OWL DL Syntax]
created for OWL DL
[OWL Semantics and Abstract Syntax],
but has been updated for OWL 1.1
[OWL 1.1 Syntax],
The syntax is used for entering and display descriptions associated with
classes, but can also be used to store ontologies.
The Manchester OWL syntax was desgined to be a human-friendly syntax,
more readable particularly by non-logicians than
RDF/XML [RDF Syntax],
the abstract syntax for OWL DL
[OWL Semantics and Abstract Syntax],
the functional-style syntax for OWL 1.1,
[OWL 1.1 Syntax],
or the XML syntaxes for OWL [?,?].
The Manchester OWL syntax stores ontologies in an object-centered
frame-like fashion similar. It is thus closer to the abstract syntax
for OWL DL than the functional-style syntax for OWL 1.1. Nevertheless,
parsing the Manchester OWL syntax into the OWL 1.1 structural
specification is quite easy, as it is easy to identify the axioms inside
each frame.
An example ontology in the Manchester OWL syntax can be found in the OWL
Primer
[OWL 1.1 Primer],
2 Miscellaneous Concerns
Documents in the Manchester OWL syntax consist of sequences of unicode
characters and are encoded in UTF-8.
It is suggested that there eventually be a MIME type for this syntax.
This grammar does not explicitly show white space.
White space is allowed between any two terminals or non-terminals except inside
nonNegativeInteger,
prefix,
reference,
Full-IRI,
stringLiteral,
integerLiteral,
decimalLiteral,
floatingPointLiteral,
and
languageTag.
White space is required between two terminals or non-terminals if its removal could cause ambiguity.
Generally this means requiring white space except before and after
punctuation (e.g., commas, parentheses, braces, and brackets).
Because comma-separated lists occur in very many places in the syntax,
to save space the grammar here has two meta-productions, one for lists
and one for lists with annotations in them.
<NT>List ::= <NT> { , <NT> }
<NT>AnnotatedList ::= [annotations] <NT> { , [annotations] <NT> }
3 The Grammar
Low-level Productions:
zero ::= '0'
nonZero := '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
digit ::= zero | nonZero
digits ::= digit { digit }
positiveInteger ::= nonZero { digit }
nonNegativeInteger ::= zero | positiveInteger
NCName ::= as defined in [XML Namespaces]
prefix ::= NCName
irelative-ref ::= as defined in [RFC-3987]
reference ::= irelative-ref
curie ::= [ [ prefix ] ':' ] reference
Abbreviated-IRI ::= curie
Full-IRI ::= '<' IRI as defined in [RFC-3987] '>'
URI ::= Full-IRI | Abbreviated-IRI
datatypeURI ::= URI
owlClassURI ::= URI
objectPropertyURI ::= URI
dataPropertyURI ::= URI
individualURI ::= URI
annotationURI ::= URI
ontologyURI ::= URI
stringLiteral ::= '"' string with backslashes and double-quotes \-escaped '"'
integerLiteral ::= ['+' | '-'] digits
decimalLiteral ::= ['+' | '-'] digits '.' digits
exponent ::= ('e' | 'E') ['+' | '-'] digits
floatingPointLiteral ::= [ '+' | '-'] ( digits ['.'digits] [exponent] | '.' digits[exponent]) ( 'f' | 'F' )
typedLiteral ::= stringLiteral '^^' datatypeURI
typedConstant ::= stringLiteral | integerLiteral | decimalLiteral | floatingPointLiteral | typedLiteral
languageTag ::= a language tag as specified in RFC-4646
untypedConstant ::= stringLiteral [ '@' languageTag ]
constant ::= typedConstant | untypedConstant
entity ::= 'Datatype' '(' datatypeURI ')' | 'OWLCLass' '(' OWLClassURI ')'
| 'ObjectProperty' '(' objectPropertyURI ')' | 'DataProperty' '('dataPropertyURI ')'
| 'Individual' '(' individualURI ')' | 'Ontology' '(' ontologyURI ')'
Ontologies and Annotations:
annotation ::= annotationURI ( constant | individualURI | entity )
annotations ::= 'Annotations:' annotationAnnotatedList
namespace ::= 'Namespace' [ prefix ] '=' Full-IRI
ontologyDocument ::= { namespace } ontology
ontology ::= 'Ontology:' ontologyURI { import } { annotations } { frame }
import ::= 'Import:' URI
frame ::= classFrame | objectPropertyFrame | dataPropertyFrame | individualFrame | misc
Property and Datatype Expressions:
inverseObjectProperty ::= 'inverseOf'
objectPropertyExpression
objectPropertyExpression ::= objectPropertyURI | inverseObjectProperty
dataPropertyExpression ::= dataPropertyURI
dataComplementOf ::= 'not' dataRange
dataOneOf ::= '{' constant { ',' constant } '}'
datatypeFacet ::= 'length' | 'minLength' | 'maxLength' | 'pattern'
| '<=' | '<' | '>=' | '>'
| 'digits' | 'fraction'
restrictionValue ::= constant
datatypeRestriction ::= ( datatypeRestriction | datatypeURI )
'[' datatypeFacet restrictionValue { ',' datatypeFacet restrictionValue } ']'
Note: If the datatypeURI is an XML Schema datatype then the
datatypeFacets and restrictionValues have to be valid for that datatype.
dataRange ::= datatypeURI | dataComplementOf | dataOneOf | datatypeRestriction
Descriptions:
atomic ::=
OWLClassURI
| '{'
individualURI { ','
individualURI } '}'
| '('
description ')'
restriction ::=
objectPropertyExpression 'some'
primary
|
objectPropertyExpression 'only'
primary
|
objectPropertyExpression 'value'
individualURI
|
objectPropertyExpression 'min'
nonNegativeInteger [
primary ]
|
objectPropertyExpression 'exactly'
nonNegativeInteger [
primary ]
|
objectPropertyExpression 'max'
nonNegativeInteger [
primary ]
|
objectPropertyExpression 'Self'
|
dataPropertyExpression 'some'
dataRange
|
dataPropertyExpression 'only'
dataRange
|
dataPropertyExpression 'value'
constant
|
dataPropertyExpression 'min'
nonNegativeInteger [
dataRange ]
|
dataPropertyExpression 'exactly'
nonNegativeInteger [
dataRange ]
|
dataPropertyExpression 'max'
nonNegativeInteger [
dataRange ]
primary ::= [ 'not' ] (
restriction |
atomic )
conjunction ::=
OWLClassURI 'that' [ 'not' ]
restriction { 'and' [ 'not' ]
restriction }
|
primary 'and'
primary { 'and'
primary }
|
primary
description ::=
conjunction 'or'
conjunction { 'or'
conjunction }
|
conjunction
Frames and Miscellaneous:
classFrame ::= 'Class:' OWLClassURI
{ 'Annotations:' annotationAnnotatedList
| 'SubClassOf:' descriptionAnnotatedList
| 'EquivalentTo:' descriptionAnnotatedList
| 'DisjointWith:' descriptionAnnotatedList
| 'DisjointUnionOf:' annotations descriptionList }
objectPropertyFrame ::= 'ObjectProperty:' objectPropertyURI
{ 'Annotations:' annotationAnnotatedList
| 'Domain:' descriptionAnnotatedList
| 'Range:' descriptionAnnotatedList
| 'Characteristics:' objectPropertyCharacteristicAnnotatedList
| 'SubPropertyOf:' objectPropertyExpressionAnnotatedList
| 'EquivalentTo:' objectPropertyExpressionAnnotatedList
| 'DisjointWith:' objectPropertyExpressionAnnotatedList
| 'Inverses:' objectPropertyExpressionAnnotatedList
| 'SubPropertyChain:' annotations objectPropertyExpression 'o' objectPropertyExpression { 'o' objectPropertyExpression } }
objectPropertyCharacteristic ::= 'Functional' | 'InverseFunctional'
| 'Reflexive' | 'Irreflexive' | 'Symmetric' | 'Asymmetric' | 'Transitive'
dataPropertyFrame ::= 'DataProperty:' dataPropertyURI
{ 'Annotations:' annotationAnnotatedList
| 'Domain:' descriptionAnnotatedList
| 'Range:' dataRangeAnnotatedList
| 'Characteristics:' annotations 'Functional'
| 'SubPropertyOf:' dataPropertyExpressionAnnotatedList
| 'EquivalentTo:' dataPropertyExpressionAnnotatedList
| 'DisjointWith:' dataPropertyExpressionAnnotatedList }
objectPropertyFact ::= objectPropertyURI individualURI
dataPropertyFact ::= dataPropertyURI constant
fact ::= [ 'not' ] (objectPropertyFact | dataPropertyFact)
individualFrame ::= 'Individual:' nameID
{ 'Annotations:' annotationAnnotatedList
| 'Types:' descriptionAnnotatedList
| 'Facts:' factAnnotatedList
| 'SameAs:' individualURIAnnotatedList
| 'DifferentFrom:' individualURIAnnotatedList }
misc ::= 'EquivalentClasses:' annotations descriptionList
| 'DisjointClasses:' annotations descriptionList
| 'EquivalentObjectProperties:' annotations objectPropertyList
| 'DisjointObjectProperties:' annotations objectPropertyList
| 'EquivalentDataProperties:' annotations dataPropertyList
| 'DisjointDataProperties:' annotations dataPropertyList
| 'SameIndividual:' annotations individualURIList
| 'DifferentIndividuals:' annotations individualURIList