OWL 2 extends the W3C OWL Web Ontology Language with a small but useful set of features that have been requested by users, for which effective reasoning algorithms are now available, and that OWL tool developers are willing to support. The new features include extra syntactic sugar, additional property and qualified cardinality constructors, extended datatype support, simple metamodeling, and extended annotations. The Manchester syntax is a user-friendly compact syntax for OWL 2; it is frame-based, as opposed to the axiom-based other syntaxes for OWL 2. The Manchester Syntax is used in the OWL 2 Primer, and this document provides the language used there. It is expected that tools will extend the Manchester Syntax for their own purposes, and tool builders may collaboratively extend the common language. It is already used in Protégé 4 and TopBraid composer.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
Set of Documents
This document is being published as one of a set of 11 documents:
This description of the Manchester Syntax is derived from the syntax used in various OWL tools and in the OWL 2 Primer as of November 2008. It is expected that tools will extend the Manchester Syntax for their own purposes, and tool builders may collaboratively extend the common language.
The Working Group expects this document, when done, to be a Working Group Note, not a W3C Recommendation. As expressed in the document conformance clause, OWL systems are not required to read or write this syntax.
Please Comment By 23 January 2009
The OWL Working Group seeks
public feedback on this First Public Working Draft. Please send your
comments to public-owl-comments@w3.org (public archive). If possible, please offer
specific changes to the text that would address your
concern. You may also wish to check the Wiki
Version of this document for internal-review comments and changes being
drafted which may address your concerns.
No Endorsement
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
The Manchester OWL syntax is a user-friendly syntax for OWL 2 descriptions, but it can also be used to write entire OWL 2 ontologies. The original version of the Manchester OWL syntax [Manchester OWL DL Syntax] was created for OWL 1 DL [OWL Semantics and Abstract Syntax]; it is here updated for OWL 2 ontologies [OWL 2 Syntax]. The Manchester syntax is used in Protégé 4 [Protégé 4] and TopBraid composer [TopBraid Composer], particularly for entering and displaying descriptions associated with classes. Some tools (e.g., Protégé 4) extend the syntax to allow even more compact presentation in some situations (e.g., for explanation) or to replace IRIs by label values, but this document does not include any of these special-purpose extensions.
Editor's Note:Issue 146 relates to the potential use of label annotations instead of IRIs and may affect the Manchester Syntax. Input on this aspect of the syntax is encouraged.
The Manchester OWL syntax gathers together information about names in a frame-like manner, as opposed to
RDF/XML [RDF Syntax],
the functional-style syntax for OWL 2
[OWL 2 Syntax],
and the XML syntax for OWL 2 [OWL 2 XML Syntax].
It is thus closer to the abstract syntax
for OWL 1 DL [OWL Semantics and Abstract Syntax], than the above syntaxes for OWL 2. Nevertheless,
parsing the Manchester OWL syntax into the OWL 2 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 2 Primer].
2 The Grammar
The Manchester syntax of OWL 2 is defined using a standard BNF notation, which is summarized in the table below.
Table 1. The BNF Notation Used in this Document
Construct
Syntax
Example
nonterminal symbols
boldface
ClassExpression
terminal symbols
single quoted
'PropertyRange'
zero or more
curly braces
{ ClassExpression }
zero or one
square brackets
[ ClassExpression ]
alternative
vertical bar
Assertion | Declaration
Because comma-separated lists occur in very many places in the syntax,
to save space the grammar has three meta-productions, one for non-empty lists, one for lists of minimum length two, and
one for non-empty lists with annotations in them.
Documents in the Manchester OWL syntax consist of sequences of Unicode characters [UNICODE] and are encoded in UTF-8 [RFC3829].
The grammar for the Manchester syntax does not explicitly show white space.
White space is allowed between any two terminals or non-terminals except inside
nonNegativeInteger,
prefix,
reference,
full-IRI,
lexicalValue,
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).
White space is a sequence of blanks (U+20), tabs (U+9), line feeds (U+A), carriage returns (U+D), and comments. Comments are maximal sequences of Unicode characters starting with a '#' and not containing a line feed or a carriage return. Note that comments are only recognized where white space is allowed, and thus not inside the above non-terminals.
The syntax uses the keywords 'and', 'or', and 'not', which are used in descriptions, that can be confused with their use as IRIs. When there is an ambiguity the keyword use is to be used.
2.1 IRIs, Integers, Literals, and Entities
Names are IRIs (the successors of URIs) and can either be given in full or can be abbreviated using CURIEs [CURIE].
This syntax uses short forms for common data values, e.g., strings and numbers, and short forms for some common datatypes, e.g., integer. These correspond to the obvious long forms.
full-IRI := 'IRI as defined in [RFC3987], enclosed in a pair of < (U+3C) and > (U+3E) characters'
NCName := 'as defined in [XML Namespaces]'
irelative-ref := 'as defined in [RFC3987]'
namespace := full-IRIprefix := NCNamereference := irelative-refcurie := [ [ prefix ] ':' ] referenceIRI := full-IRI | curienonNegativeInteger ::= zero | positiveIntegerpositiveInteger ::= nonZero { digit }
digits ::= digit { digit }
digit ::= zero | nonZerononZero := '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
zero ::= '0'
classIRI ::= IRIDatatype ::= datatypeIRI | 'integer' | 'decimal' | 'float' | 'string'
datatypeIRI ::= IRIobjectPropertyIRI ::= IRIdataPropertyIRI ::= IRIannotationPropertyIRI ::= IRIindividual ::= individualIRI | nodeIDindividualIRI ::= IRInodeID := 'a node ID of the form _:name as specified in the N-Triples specification [RDF Test Cases]'
literal ::= typedLiteral | abbreviatedXSDStringLiteral | abbreviatedRDFTextLiteral | integerLiteral | decimalLiteral | floatingPointLiteraltypedLiteral ::= lexicalValue '^^' DatatypeabbreviatedXSDStringLiteral ::= quotedStringabbreviatedRDFTextLiteral ::= quotedString '@' languageTaglanguageTag := 'a nonempty (not quoted) string defined as specified in BCP 47 [BCP 47]'
lexicalValue ::= quotedStringquotedString := 'a finite sequence of characters in which " (U+22) and \ (U+5C) occur only in pairs of the form \" (U+22, U+5C) and \\ (U+22, U+22), enclosed in a pair of " (U+22) characters'
floatingPointLiteral ::= [ '+' | '-'] ( digits ['.'digits] [exponent] | '.' digits[exponent]) ( 'f' | 'F' )
exponent ::= ('e' | 'E') ['+' | '-'] digitsdecimalLiteral ::= ['+' | '-'] digits '.' digitsintegerLiteral ::= ['+' | '-'] digitsentity ::= 'Datatype' '(' datatypeIRI ')' | 'Class' '(' classIRI ')'
| 'ObjectProperty' '(' objectPropertyIRI ')' | 'DataProperty' '('dataPropertyIRI ')'
| 'AnnotationProperty' '(' annotationPropertyIRI ')' | 'NamedIndividual' '(' individualIRI ')'
Editor's Note: There are currently only short forms for four major datatypes. Other short forms could be added. Note that all datatypes can be accessed via their IRIs. Input on this aspect of the syntax is encouraged.
Editor's Note: The syntax for floating point literals is fairly restrictive and could be extended (for example to make the trailing f optional if there is an exponent. Note that all literals can be written using the long form. Input on this aspect of the syntax is encouraged.
In a datatypeRestriction, the facets and restrictionValues must be valid for the datatype, as in the OWL 2 Syntax [OWL 2 Syntax], after making the obvious change for the comparison facets.
Editor's Note: Some syntax in previous versions of the Manchester Syntax is no longer allowed (e.g., onlysome, xor, and ValuePartition). These were somewhat problematic. Input on including this syntax is welcome.
The Manchester syntax has the same restrictions on multiple use of IRIs as in OWL 2 [OWL 2 Syntax]. That is, in an ontology and the ontologies that it imports, no IRI can be used as more than one of an object property, a data property, or an annotation property; nor can a IRI be used as both a class and a datatype.
The Manchester syntax also has the same restriction on declaration of IRIs as does OWL 2. If a IRI is used as a property in an ontology then there must be a property frame for it in the ontology, or in an ontology that is imported by it, unless it is one of the built-in OWL 2 properties. If a IRI is used as a class in an ontology then there must be a class frame for it in the ontology, or in an ontology that is imported by it, unless it is one of the built-in OWL 2 classes. The only datatypes allowed are the built-in OWL 2 datatypes.
The Manchester syntax has the same global restrictions on the use of properties, anonymous individuals, and owl:topDataProperty as OWL 2 [OWL 2 Syntax] does. The details of these restrictions are complex, but one basic restriction is that no object property that is used in a number restriction ('min', 'max', or 'exactly') or 'self' restriction can be transitive or have a transitive property as a descendant sub-property, or be the inverse of or equivalent to such properties.
3 Quick Reference
This is a made-up partial ontology that provides a quick reference guide to the
Manchester Syntax. Not all of the ontology makes logical sense so that
all aspects of the syntax can be shown in a small example.
All colon-terminated keyword constructs except Ontology: (e.g., Import:, Class:, Domain:,
SubClassOf:) are optional and can be repeated. Most keyword constructs
take a comma-separated list of sub-constructs, which is sometimes
indicated by ",...". Annotations are allowed for elements in these
lists of sub-constructs except where annotations are explicitly noted
(e.g., in DisjointUnionOf:, in DisjointClasses:).
4 Appendix: Translation to and from OWL 2 Functional-Style Syntax
Most of the translation between the Manchester OWL syntax and OWL 2 is
obvious. The translation given here is with the OWL 2 Functional-Style Syntax
[OWL 2 Syntax].
4.1 Informal Description
In many cases there is a one-to-one correspondence between the
Manchester OWL syntax and the OWL 2 Functional-Style Syntax.
For example, dataComplementOf in the
Manchester OWL syntax corresponds directly to
dataComplementOf
in the OWL 2 Functional-Style Syntax.
All that is required is to translate the keywords and adjust to a
parenthesized syntax.
IRIs and their parts are the same in the Manchester OWL syntax and the
OWL 2 Functional-Style Syntax, no change is needed for them, except that the
"special" datatypes are translated into the corresponding XML Schema
datatypes.
Literals are mostly the same, but the abbreviated syntaxes for numbers
and strings have to be translated in the obvious way.
The syntax for data ranges in the Manchester OWL syntax corresponds
exactly with the syntax in the OWL 2 Functional-Style Syntax.
The syntax for annotations in the Manchester OWL syntax closely corresponds
to the syntax in the OWL 2 Functional-Style Syntax. The only special
processing that needs to be done is to determine which frame to attach
entity annotations to in the reverse mapping. Translating to the
Functional-Style syntax and back again can thus loose some non-logical
information in the Manchester syntax.
Descriptions also correspond closely between the Manchester OWL syntax
and the OWL 2 Functional-Style Syntax.
The translation of frame axioms is performed by splitting them into pieces that
correspond to single axioms. This is done by taking each of the pieces
of the frame (Annotations:, Domain:, Range:, etc) and making new
frames for each of them. The new frame is of the same kind (Class:,
ObjectProperty:, etc.) and for the same IRI.
Then each resultant frame that contains an
AnnotatedList with more than one element is broken into a frame for each
element of the list in a similar manner.
The resultant axioms and any miscellaneous axioms then correspond
closely to the OWL 2 Functional-Style Syntax axioms
and can be directly translated. The only special cases are that
annotations directly in frames become annotations in entity
annotation axioms and that (negative) property assertions have to be
disambiguated depending on whether the property is an object property or
a data property.
Translations of OWL 2 Functional-Style Syntax axioms back to frames can be done
piecemeal or the axioms on a single entity can be all combined together,
which is done here.
The remaining top-level constructs of an ontology (namespaces, imports, ontology
annotations, and the ontology name) can be directly translated.
4.2 Formal Description for Mapping to OWL 2 Functional-Style Syntax
Formally the transformation takes an ontology in the Manchester OWL
syntax and produces an ontology in the Functional-Style syntax. The
transformation needs access to the imported ontologies.
First, for each frame in the ontology, produce the appropriate
declaration as follows:
Frame
Declaration
Class: IRI ...
Declaration( Class(IRI) )
ObjectProperty: IRI ...
Declaration( ObjectProperty(IRI) )
DataProperty: IRI ...
Declaration( DataProperty(IRI) )
AnnotationProperty: IRI ...
Declaration( AnnotationProperty(IRI) )
Individual: IRI ...
Declaration( NamedIndividual(IRI) )
Individual: nodeID ...
Second, split up frames into single axioms in three stages.
The first stage splits apart top-level pieces of frames that have
multiple top-level pieces, transforming
F: IRIp1p2 ...
into
F: IRI p1 F: IRI p2 ...
for F: one of the frame keywords (Class:, ...),
until no more transformations are possible.
The second stage splits apart the pieces of each of the top-level
pieces, transforming
F: IRI P: s1s2 ...
into
F: IRI P: s1 F: IRI P: s2 ...
for P: one of the keywords immediately inside a frame
(Annotations:, SubClassOf:, ...),
until no more transformations are possible.
The third stage just removes any frame containing only a IRI.
Next, perform the actual syntax transformation. Any piece of syntax
with no transformation listed here is just copied through.
Finally, put the declarations produced in the first step into the ontology.
4.3 Formal Description for Mapping from OWL 2 Functional-Style Syntax
The mapping from the Functional-Style Syntax back to the Manchester
Syntax essentially just runs the above translation in reverse.
First, create a trivial frame containing only a IRI for each
declaration in the ontology.
Second, turn the Functional-Style Syntax into the Manchester Syntax by
running the syntax transformation above in reverse. The non-determinism
in the mapping of entity annotations is resolved by uniformly making
them annotations in individual frames.
Third, collapse frames for the same entity into one frame by running
that part of the forward transformation in reverse. This step does not
affect the meaning of an ontology and is thus optional.
5 Appendix: Internet Media Type, File Extension and Macintosh File Type
Contact
Sandro Hawke
See also
How to Register a Media Type for a W3C Specification Internet Media Type registration, consistency of use TAG Finding 3 June 2002 (Revised 4 September 2002)
The Internet Media Type / MIME Type for the OWL Manchester Syntax is
"text/owl-manchester".
It is recommended that OWL Manchester Syntax files have the extension
".omn" (all lowercase) on all platforms.
It is recommended that OWL Manchester Syntax files stored on Macintosh
HFS file systems be given a file type of "TEXT".
The information that follows will be submitted to the IESG for review,
approval, and registration with IANA.
Type name
text
Subtype name
owl-manchester
Required parameters
None
Optional parameters
charset This parameter may be required when transfering non-ascii data across some protocols. If present, the value of charset is always UTF-8.
Encoding considerations
The syntax of the OWL Manchester Syntax is expressed over code points in Unicode [UNICODE]. The encoding is always UTF-8 [RFC3629].
Security considerations
The OWL Manchester Syntax uses IRIs as term identifiers. Applications interpreting data expressed in the OWL Manchester Syntax should address the security issues of Internationalized Resource Identifiers (IRIs) [RFC3987] Section 8, as well as Uniform Resource Identifiers (URI): Generic Syntax [RFC3986] Section 7. Multiple IRIs may have the same appearance. Characters in different scripts may look similar (a Cyrillic "o" may appear similar to a Latin "o"). A character followed by combining characters may have the same visual representation as another character (LATIN SMALL LETTER E followed by COMBINING ACUTE ACCENT has the same visual representation as LATIN SMALL LETTER E WITH ACUTE). Any person or application that is writing or interpreting data in the OWL Manchester Syntax must take care to use the IRI that matches the intended semantics, and avoid IRIs that may look similar. Further information about matching of similar characters can be found in Unicode Security Considerations [UNISEC] and Internationalized Resource Identifiers (IRIs) [RFC3987] Section 8.
Interoperability considerations
There are no known interoperability issues.
Published specification
This specification.
Applications which use this media type
This media type is used by Protege 4 and TopBraid Composer.
Additional information
None.
Magic number(s)
OWL Manchester Syntax documents may have the strings 'Namespace:' or 'Ontology:' (case dependent) near the beginning of the document.
File extension(s)
".omn"
Base URI
There are no constructs in the OWL Manchester Syntax to change the Base URI.
Macintosh file type code(s)
"TEXT"
Person & email address to contact for further information
Sandro Hawke <sandro@w3.org>
Intended usage
COMMON
Restrictions on usage
None
Author/Change controller
The OWL Mancheser Syntax is the product of the W3C OWL Working Group in cooperation with OWL ontology tool builders; the specification may be extended by groups of OWL tool builders; W3C reserves change control over this specification.
The Manchester OWL Syntax. Matthew Horridge, Nick Drummond, John Goodwin, Alan Rector, Robert Stevens, Hai H. Wang. OWL Experiences and Directions Workshop, 2006.