The Manchester OWL syntax is a user-friendly syntax for OWL DL, fundamentally based on collecting all information about a particular class, property, or individual into a single construct, called a frame. The Manchester OWL syntax has been revised to be a syntax for OWL 1.1, involving adding the new OWL 1.1 description constructs and the new axioms allowed in OWL 1.1 ontologies.
– the normative exchange syntax in RDF/XML [
These syntaxes have differing purposes; for transfer within the Semantic Web, to assist in formal definition of the semantics, for transfer as XML. None of them, however, are designed for ease of use by humans when building or analyzing ontologies. Instead, it was thought that these vital tasks would be performed using tools that provide a graphical interface for human users. Indeed there are tools that provide such a graphical interface, including Prot´eg´e (http://protege.stanford.edu/overview/) and Swoop (http://code.google.com/ p/swoop/). However, it was soon understood that some parts of creating an ontology require the creation and entry of complex descriptions, for example when creating a class. A useful way of creating such complex descriptions is via a linear syntax. Similarly presenting these complex descriptions can usefully be done by using a linear syntax (generally with nice indentation).
The original Manchester OWL syntax [
The Manchester OWL syntax tries to minimize syntactic constructs that are difficult to enter or understand, particularly in description. Complex descriptions use short, intuitive English words instead of logical symbols and the usual precedence rules to minimize parentheses.
For example, Student or Person that hasAge all xsd:integer[ <= 25 ] corresponds to
The Manchester OWL syntax is much more compact and more readable.
The new functional-style syntax for OWL 1.1 has moved from the
framelike abstract syntax for OWL DL and is, instead, based on axioms. This move
was taken because of problems encountered with the original abstract syntax
having to do with performing operations on OWL ontologies, such as removing
axioms. The functional-style syntax thus corresponds very closely to a potential
mechanism for storing ontologies in tools, the structural specification of OWL
1.1 ontologies [
The Manchester OWL syntax, purposefully, retains a object-centered framelike organization for ontologies, as a frame organization supports a very natural way of creating, editing, and viewing ontologies, similar to the presentation of ontologies in most ontology-building tools, e.g., Prot´eg´e 4. IN this organization, all the information about an object (a class or property or individual) is collected together, both to aid in perusal of ontology documents and to mirror the way graphical user interfaces like Prot´eg´e present information about parts of ontologies.
Frames and the parts of a frame are uniformly introduced by keywords that end in colons, allowing for their easy recognition. It is suggested that when printing ontologies that indentation be used to help with readability, as follows:
The advent of OWL 1.1 required some changes to the Manchester OWL syntax.
The new constructs in descriptions, qualitative cardinality restrictions and
self restrictions, were easy to handle, just requiring additional syntax, similar to
the existing syntax. Allowing CURIES [
OWL 1.1 allows annotations in many more places than were allowed previously. These annotations are allowed in the Manchester OWL syntax. They are introduced by an Annotations: keyword, in a way consistent with the other constructs in the syntax.
The following example shows a class frame with two annotations (a label and a comment) on the frame itself, one annotation on the subclass axiom to Person and two annotations on the subclass axiom to owl:Thing.
rdfs:comment "The class of students"
Because annotations break up the flow of information, they can be harmful to readability.
The syntax here allows for annotations on annotations which are not (yet) part of OWL 1.1. Extending annotations in this way is one of the issues that the OWL working group is considering.
Some constructs in OWL 1.1, such as the axioms for n-way disjointness of classes and properties and n-way difference and sameness of individuals, are not obviously part of any particular object. In fact, they are equally about each of the n classes, properties, or individuals involved. Attaching these constructss to any one frame would be misleading. The Manchester OWL syntax thus breaks from its general object-centricity with specific syntax for these axioms, as in the following example.
OWL 1.1 does pose a few problems for the Manchester OWL syntax.
The frames for classes, properties, and individuals play a similar role to declarations in OWL 1.1, and thus the syntax does not have a separate construct for declarations. However, it can be the case that an ontology adds information to an imported class, property, or individual. In this case the frame for that class, property, or individual is not a declaration. Global analysis is thus required to determine which declarations are required in an ontology.
Moving between the Manchester OWL syntax and the functional-style syntax and structural specification for OWL 1.1 requires moving between frames and axioms. This is actually not difficult at all, as each frame construct has a number of top-level pieces that each correspond directly to an axiom.
For example, the frame corresponds to seven axioms (and possibly one declaration) in the functionalstyle syntax, as follows:
Punning between object and data properties (i.e., an object property and a data property with the same name) could cause ambiguity between object and data property restrictions. Overcoming this ambiguity would require much extra vocabulary, resulting in lessened readability. Therefore the Manchester OWL syntax does not support dumping of ontologies with punned object and data properties. Duplicating the syntax, as in the OWL 1.1 functional-style syntax, was another possible solution, but it would have interfered with readability too much. 5
Here is a grammar for the Manchester OWL Syntax, with some low-level productions (e.g., digits) removed. In the grammar, terminals are enclosed in single quotes (‘’) and non-terminals are in bold. Optional parts are in brackets ([]) and repeated parts are in braces (). Some productions are given informally or by references, indicated with italics. 5.1
prefix irelative-ref reference curie
::= as defined in XML Namespaces ::= NCName ::= as defined in RFC-3987 ::= irelative-ref ::= [ [ prefix ] ‘:’ ] reference ::= curie ::= ‘<’ IRI as defined in RFC-3987 ‘>’ ::= Full-IRI | Abbreviated-IRI datatypeURI ::= URI | ‘integer’ | ‘decimal’ | ‘float’ | ‘string’ owlClassURI ::= URI objectPropertyURI ::= URI dataPropertyURI ::= URI individualURI ::= URI annotationURI ::= URI ontologyURI ::= URI stringLiteral ::= ‘"’ string with \ and " \-escaped ‘"’ integerLiteral ::= [‘+’|‘-’] digits decimalLiteral ::= [‘+’|‘-’ ] digits ‘.’ digits exponent ::= (‘e’ | ‘E’) [‘+’ | ‘-’] digits floatingPointLiteral ::= [‘+’|‘-’] ( digits [‘.‘digits] [ exponent] | ‘.’ digits[ exponent]) ( ‘f’ | ‘F’ ) typedLiteral ::= stringLiteral ‘^^’ datatype typedConstant ::= stringLiteral | integerLiteral | decimalLiteral | floatingPointLiteral | typedLiteral languageTag ::= a language tag as specified in RFC-4646 untypedConstant ::= stringLiteral [ ‘@’ languageTag ] constant ::= typedConstant | untypedConstant 5.2
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.
NTList ::= NT { ‘,’ NT } NTAnnotatedList ::= [annotations] NT { ‘,’ [annotations] NT }
The non-terminal descriptionList is thus a comma-separated list of descriptions, such as
and the non-terminal descriptionAnnotationList is thus a comma-separated list of descriptions each possibly proceeed by annotations, such as
Annotations and entities are formed as follows: annotation ::= annotationURI ( constant | individualURI | entity ) annotations ::= ‘Annotations:’ annotationAnnotatedList entity ::= ‘Datatype’ ‘(’ datatypeURI ‘)’ | ‘OWLCLass’ ‘(’ OWLClassURI ‘)’ | ‘ObjectProperty’ ‘(’ objectPropertyURI ‘)’ | ‘DataProperty’ ‘(’ dataPropertyURI ‘)’ | ‘Individual’ ‘(’ individualURI ‘)’ | ‘AnnotationProperty’ ‘(’ annotationPropertyURI ‘)’
This grammar allows annotations on annotations, which are not (yet) in OWL 1.1. The current state of annotations in OWL 1.1 corresponds to replacing the production for annotations with annotations ::= ‘Annotations:’ annotationList 5.3
Ontology Documents namespace ::= ‘Namespace:’ [ prefix ] ‘=’ Full-IRI ontologyDoc ::= { namespace } ontology ontology ::= ‘Ontology:’ ontologyURI { import }
{ annotations } { frame } import ::= ‘Import:’ URI frame ::= classFrame | objectPropertyFrame
| dataPropertyFrame | individualFrame | misc 5.4
Property Expressions and Datatypes inverseObjectProperty ::= ‘inverseOf’ objectPropertyExpression objectPropertyExpression ::= objectPropertyURI
| inverseObjectProperty dataPropertyExpression ::= dataPropertyURI dataComplementOf ::= ‘not’ dataRange dataOneOf ::= ‘{’ constant { ‘,’ constant } ‘}’ datatypeFacet ::= ‘length’ | ‘minLength’ | ‘maxLength’ | ‘pattern’ | ‘<=’ | ‘<’ | ‘>=’ | ‘>’ | ‘digits’ | ‘fraction’ restrictionValue ::= constant datatypeRestriction ::= datatypeURI ‘[’ datatypeFacet restrictionValue
{ , datatypeFacet restrictionValue } ‘]’ dataRange ::= datatypeURI | dataComplementOf | dataOneOf | datatypeRestriction
Note: If the datatypeURI involved is an XML Schema datatype then the datatypeFacets and restrictionValues have to be valid for that datatype. 5.5
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 ::= | primary ‘and’ primary { ‘and’ primary }
5.6
Class, Property, and Individual Frames classFrame ::= ‘Class:’ OWLClassURI { ‘Annotations:’ annotationAnnotatedList | ‘SubClassOf:’ descriptionAnnotatedList | ‘EquivalentTo:’ descriptionAnnotatedList | ‘DisjointWith:’ descriptionAnnotatedList | ‘DisjointUnionOf:’ annotations descriptionList } objectPropertyFrame ::= ‘ObjectProperty:’ objectPropertyURI { ‘Annotations:’ annotationAnnotatedList | ‘Domain:’ descriptionAnnotatedList | ‘Range:’ descriptionAnnotatedList | ‘Characteristics:’ objectPropertyCharacterAnnotatedList | ‘SubPropertyOf:’ objectPropertyExpressionAnnotatedList | ‘EquivalentTo:’ objectPropertyExpressionAnnotatedList | ‘DisjointWith:’ objectPropertyExpressionAnnotatedList | ‘Inverses:’ objectPropertyExpressionAnnotatedList | ‘SubPropertyChain:’ annotations objectPropertyExpression ‘o’ objectPropertyExpression {‘o’ objectPropertyExpression} } objectPropertyCharacter ::= ‘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:’ individualURI { ‘Annotations:’ annotationAnnotatedList | ‘Types:’ descriptionAnnotatedList | ‘Facts:’ factAnnotatedList | ‘SameAs:’ individualURIAnnotatedList | ‘DifferentFrom:’ individualURIAnnotatedList } 7
The Manchester OWL syntax is used in the Prot´eg´e 4 ontology development tool (http://www.co-ode.org/downloads/protege-x/). Prot´eg´e 4 can dump and load OWL 1.1 ontologies in the Manchester OWL syntax. As well, complex descriptions can be entered using the Manchester OWL syntax. Most of the examples in this paper were generated using Prot´eg´e 4. Although the Manchester OWL syntax was initially developed to be more human-readable than other OWL syntaxes, there has as yet been no formal user studies to support this aspect of the current language.
The OWL Primer (http://www.w3.org/2007/OWL/wiki/Primer), under consideration in the W3C OWL Working Group, currently uses the Manchester OWL syntax as its primary syntax because this syntax is the most readable OWL syntax. The OWL Working Group may also decide to produce a Working Group note on the Manchester OWL syntax.
The OWL 1.1 language is still under development. The syntax in this paper attempts to track the current version of OWL 1.1 with a bit of anticipation related to annotations. The Manchester OWL syntax will be updated as OWL 1.1 is updated. Prot´eg´e 4 currently implements a slightly older version of the syntax (and has a couple of bugs in this area as well).