ManchesterSyntax

Authors

Matthew Horridge, University of Manchester

Peter F. Patel-Schneider, Bell Labs Research, Alcatel-Lucent

1 Introduction

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 URIs by label values, but this document does not include any of these special-purpose extensions.

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 functional-style syntax of OWL 2 is defined using a standard BNF notation, which is summarized in the table below.

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.

<NT>List ::= <NT> { , <NT> } <NT>2List ::= <NT> , <NT>List <NT>AnnotatedList ::= [annotations] <NT> { , [annotations] <NT> }

Documents in the Manchester OWL syntax consist of sequences of Unicode characters [UNICODE] and are encoded in UTF-8 [UTF-8 Encoding].

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 URIs. When there is an ambiguity the keyword use is to be used.

2.1 URIs, Integers, Literals, and Entities

Names are URIs (actually IRIs) 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.

URI ::= full-IRI | abbreviated-IRI abbreviated-IRI ::= curie full-IRI ::= '<' IRI as defined in [RFC-3987] '>' curie ::= [ [ prefix ] ':' ] reference reference ::= irelative-ref irelative-ref ::= as defined in [RFC-3987] prefix ::= NCName NCName ::= as defined in [XML Namespaces] nonNegativeInteger ::= zero | positiveInteger positiveInteger ::= nonZero { digit } digits ::= digit { digit } digit ::= zero | nonZero nonZero := '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' zero ::= '0' OWLClassURI ::= URI Datatype ::= datatypeURI | 'integer' | 'decimal' | 'float' | 'string' datatypeURI ::= URI objectPropertyURI ::= URI dataPropertyURI ::= URI annotationPropertyURI ::= URI individual ::= individualURI | nodeID individualURI ::= URI nodeID ::= a node ID of the form _:name as specified in N-Triples [RDF Test Cases] literal ::= typedLiteral | abbreviatedXSDStringLiteral | abbreviatedRDFTextLiteral | integerLiteral | decimalLiteral | floatingPointLiteral typedLiteral ::= lexicalValue '^^' Datatype abbreviatedXSDStringLiteral ::= quotedString abbreviatedRDFTextLiteral ::= quotedString '@' languageTag languageTag ::= a language tag as specified in [RFC-4646] lexicalValue ::= quotedString quotedString ::= '"' string with backslashes and double-quotes \-escaped '"' floatingPointLiteral ::= [ '+' | '-'] ( digits ['.'digits] [exponent] | '.' digits[exponent]) ( 'f' | 'F' ) exponent ::= ('e' | 'E') ['+' | '-'] digits decimalLiteral ::= ['+' | '-'] digits '.' digits integerLiteral ::= ['+' | '-'] digits entity ::= 'Datatype' '(' datatypeURI ')' | 'Class' '(' OWLClassURI ')' | 'ObjectProperty' '(' objectPropertyURI ')' | 'DataProperty' '('dataPropertyURI ')' | 'AnnotationProperty' '(' annotationPropertyURI ')' | 'NamedIndividual' '(' individualURI ')'

2.2 Ontologies and Annotations

annotations ::= 'Annotations:' annotationAnnotatedList annotation ::= annotationPropertyURI ( literal | individual | entity ) ontologyDocument ::= { namespace } ontology namespace ::= 'Namespace:' [ prefix ] full-IRI ontology ::= 'Ontology:' [ ontologyURI [ versionURI ] ] { import } { annotations } { frame } ontologyURI ::= URI versionURI ::= URI import ::= 'Import:' URI frame ::= classFrame | objectPropertyFrame | dataPropertyFrame | annotationPropertyFrame | individualFrame | misc

The 'rdf', 'rdfs', 'owl', and 'xsd' prefixes are pre-defined as follows and cannot be changed.

Namespace: rdf <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
Namespace: rdfs <http://www.w3.org/2000/01/rdf-schema#>
Namespace: xsd <http://www.w3.org/2001/XMLSchema#>
Namespace: owl <http://www.w3.org/2002/07/owl#>

2.3 Property and Datatype Expressions

objectPropertyExpression ::= objectPropertyURI | inverseObjectProperty inverseObjectProperty ::= 'inverse' objectPropertyURI dataPropertyExpression ::= dataPropertyURI dataRange ::= Datatype | dataComplementOf | dataOneOf | datatypeRestriction datatypeRestriction ::= Datatype '[' facet restrictionValue { ',' facet restrictionValue } ']' facet ::= 'length' | 'minLength' | 'maxLength' | 'pattern' | 'langPattern' | '<=' | '<' | '>=' | '>' restrictionValue ::= literal dataOneOf ::= '{' literal { ',' literal } '}' dataComplementOf ::= 'not' dataRange

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.

2.4 Descriptions

description ::= conjunction 'or' conjunction { 'or' conjunction } | conjunction conjunction ::= OWLClassURI 'that' [ 'not' ] restriction { 'and' [ 'not' ] restriction } | primary 'and' primary { 'and' primary } | primary primary ::= [ 'not' ] ( restriction | atomic ) restriction ::= objectPropertyExpression 'some' primary | objectPropertyExpression 'only' primary | objectPropertyExpression 'value' individual | objectPropertyExpression 'Self' | objectPropertyExpression 'min' nonNegativeInteger [ primary ] | objectPropertyExpression 'max' nonNegativeInteger [ primary ] | objectPropertyExpression 'exactly' nonNegativeInteger [ primary ] | dataPropertyExpression 'some' dataRange | dataPropertyExpression 'only' dataRange | dataPropertyExpression 'value' literal | dataPropertyExpression 'min' nonNegativeInteger [ dataRange ] | dataPropertyExpression 'max' nonNegativeInteger [ dataRange ] | dataPropertyExpression 'exactly' nonNegativeInteger [ dataRange ] atomic ::= OWLClassURI | '{' individual { ',' individual } '}' | '(' description ')'

2.5 Frames and Miscellaneous

classFrame ::= 'Class:' OWLClassURI { 'Annotations:' annotationAnnotatedList | 'SubClassOf:' descriptionAnnotatedList | 'EquivalentTo:' descriptionAnnotatedList | 'DisjointWith:' descriptionAnnotatedList | 'DisjointUnionOf:' annotations description2List } objectPropertyFrame ::= 'ObjectProperty:' objectPropertyURI { 'Annotations:' annotationAnnotatedList | 'Domain:' descriptionAnnotatedList | 'Range:' descriptionAnnotatedList | 'Characteristics:' objectPropertyCharacteristicAnnotatedList | 'SubPropertyOf:' objectPropertyExpressionAnnotatedList | 'EquivalentTo:' objectPropertyExpressionAnnotatedList | 'DisjointWith:' objectPropertyExpressionAnnotatedList | 'InverseOf:' 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 } annotationPropertyFrame ::= 'OntologyProperty:' annotationPropertyURI { 'Annotations:' annotationAnnotatedList } individualFrame ::= 'Individual:' individual { 'Annotations:' annotationAnnotatedList | 'Types:' descriptionAnnotatedList | 'Facts:' factAnnotatedList | 'SameAs:' individualAnnotatedList | 'DifferentFrom:' individualAnnotatedList } fact ::= [ 'not' ] (objectPropertyFact | dataPropertyFact) objectPropertyFact ::= objectPropertyURI individual dataPropertyFact ::= dataPropertyURI literal misc ::= 'EquivalentClasses:' annotations description2List | 'DisjointClasses:' annotations description2List | 'EquivalentProperties:' annotations objectProperty2List | 'DisjointProperties:' annotations objectProperty2List | 'EquivalentProperties:' annotations dataProperty2List | 'DisjointProperties:' annotations dataProperty2List | 'SameIndividual:' annotations individual2List | 'DifferentIndividuals:' annotations individual2List | 'HasKey:' description annotations ( objectPropertyExpression | dataPropertyExpression ) { objectPropertyExpression | dataPropertyExpression }

2.6 Global Concerns

The Manchester syntax has the same restrictions on multiple use of URIs as in OWL 2 [OWL 2 Syntax]. That is, in an ontology and the ontologies that it imports, no URI can be used as more than one of an object property, a data property, or an annotation property; nor can a URI be used as both a class and a datatype.

The Manchester syntax also has the same restriction on declaration of URIs as does OWL 2. If a URI 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 URI 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 and anonymous individuals 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:).

Namespace: <http://ex.com/owl/families#>
Namespace: g <http://ex.com/owl2/families#>

Ontology: <http://example.com/owl/families> <http://example.com/owl/families-v1>
  Import: <http://ex.com/owl2/families.owl>
  Annotations: creator John, 
               Annotations: rdfs:comment "Creation Year"
                 creationYear 2008, 
               mainClass Class(Person)

  ObjectProperty: hasWife
    Annotations: ...
    Characteristics: Functional, InverseFunctional, Reflexive, Irreflexive, Asymmetric, Transitive
    Domain: Annotations: rdfs:comment "General domain",
                         creator John
              Person, 
            Annotations: rdfs:comment "More specific domain"
              Man
    Range: Person, Woman
    SubPropertyOf: hasSpouse, loves
    EquivalentTo: isMarriedTo ,...
    DisjointWith: hates ,...
    InverseOf: hasSpouse, inverse hasSpouse
    SubPropertyChain: Annotations: ... hasChild o hasParent o...

  DataProperty: hasAge
    Annotations: ...
    Characteristics: Functional
    Domain: Person ,...
    Range: integer ,...
    SubPropertyOf: hasAge ,...
    EquivalentTo: hasAgeInYears ,...
    DisjointWith: hasSSN ,...

  AnnotationProperty: creator
    Annotations: ...

  Class: Person
    Annotations: ...
    SubClassOf: owl:Thing that hasFirstName exactly 1 and hasFirstName only string[minLength 1]  ,...
    SubClassOf: hasAge exactly 1 and hasAge only not integer[< 0]  ,...
    SubClassOf: hasGender exactly 1 and hasGender only {female , male} ,...
    SubClassOf: hasSSN max 1, hasSSN min 1
    SubClassOf: not hates Self, ...
    EquivalentTo: g:People ,...
    DisjointWith: g:Rock , g:Mineral ,...
    DisjointUnionOf: Annotations: ... Child, Adult

  Individual: John
    Annotations: ...
    Types: Person , hasFirstName value "John" or hasFirstName value "Jack"^^xsd:string
    Facts: hasWife Mary, not hasChild Susan, hasAge 33, hasChild _:child1
    SameAs: Jack ,...
    DifferentFrom: Susan ,...

  Individual: _:child1
    Annotations: ...
    Types: Person ,...
    Facts: hasChild Susan ,...

  DisjointClasses: Annotations: ... g:Rock, g:Scissor, g:Paper
  EquivalentProperties: Annotations: ... hates, loathes, despises
  DisjointProperties: Annotations: ... hates, loves, indifferent
  EquivalentProperties: Annotations: ... favoriteNumber, g:favouriteNumber, g:favouriteInteger
  DisjointProperties: Annotations: ... favoriteInteger, favouriteReal
  SameIndividual: Annotations: ... John, Jack, Joe, Jim
  DifferentIndividuals: Annotations: ... John, Susan, Mary, Jill
  HasKey: Annotations: ... hasSSN Person

4 Appendix: Translation to OWL 2 Functional Syntax

Most of the translation from the Manchester OWL syntax to OWL 2 is obvious. The translation given here is to the OWL 2 Functional 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 Syntax. For example, dataComplementOf in the Manchester OWL syntax corresponds directly to dataComplementOf in the OWL 2 Functional Syntax. All that is required is to translate the keywords and adjust to a parenthesized syntax.

URIs and their parts are the same in the Manchester OWL syntax and the OWL 2 Functional 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 Syntax.

The syntax for annotations in the Manchester OWL syntax closely corresponds to the syntax in the OWL 2 Functional Syntax. The only special processing that needs to be done is for annotations that use URIs directly. These are translated into annotations on an individual entity.

Descriptions also correspond closely between the Manchester OWL syntax and the OWL 2 Functional 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 URI. 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 Syntax axioms (modulo the extended annotations) and can be directly translated. The only special cases are that annotations directly in frames become entity 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.

The remaining top-level constructs of an ontology (namespaces, imports, ontology annotations, and the ontology name) can be directly translated.

4.2 Formal Description

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:

Next, split up frames with multiple components, by performing the following two transformations until no more transformations are possible.

Next remove any frame containing only a URI.

Finally, perform the following transformation. Any piece of syntax with no transformation listed here is just copied through.

5 References

[CURIE]

CURIE Syntax 1.0: A syntax for expressing Compact URIs. M. Birbeck, S. McCarron, Editors, W3C Working Draft, 26 November 2007, http://www.w3.org/TR/2007/WD-curie-20071126/.

[Manchester OWL DL Syntax]

The Manchester OWL Syntax. Matthew Horridge, Nick Drummond, John Goodwin, Alan Rector, Robert Stevens, Hai H. Wang. OWL Experiences and Directions Workshop, 2006.

[OWL Semantics and Abstract Syntax]

OWL Web Ontology Language: Semantics and Abstract Syntax. Peter F. Patel-Schneider, Patrick Hayes, and Ian Horrocks, eds. W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-semantics-20040210/. Latest version available at http://www.w3.org/TR/owl-semantics/.

[OWL 2 Primer]

OWL 2 Web Ontology Language: Primer. Bijan Parsia and Peter F. Patel-Schneider. 2008.

[OWL 2 Syntax]

OWL 2 Web Ontology Language: Structural Specification and Functional-Style Syntax. Boris Motik, Peter F. Patel-Schneider, and Ian Horrocks. 2008.

[OWL 2 XML Syntax]

OWL 2 Web Ontology Language: XML Syntax. Bernardo Cuenca Grau, Boris Motik, and Peter F. Patel-Schneider. 2008.

[Protégé 4]

Protégé 4 User Documentation. http://protegewiki.stanford.edu/index.php/Protege4UserDocs, October 2008.

[RDF Syntax]

RDF/XML Syntax Specification (Revised). Dave Beckett, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/rdf-syntax-grammar/.

[RDF Test Cases]

RDF Test Cases. Jan Grant and Dave Beckett, Editors, W3C Recommendation 10 February 2004, http://www.w3.org/TR/rdf-testcases/.

[RFC-3987]

RFC 3987 - Internationalized Resource Identifiers (IRIs). M. Duerst, M. Suignard. IETF, January 2005, http://www.ietf.org/rfc/rfc3987.txt.

[RFC-4646]

RFC 4646 - Tags for Identifying Languages. M. Phillips and A. Davis. IETF, September 2006, http://www.ietf.org/rfc/rfc4646.txt. Latest version is available as BCP 47, (details) .

[TopBraid Composer]

TopBraid Composer Home Page. http://www.topquadrant.com/topbraid/composer/, October 2008.

[XML Namespaces]

Namespaces in XML 1.0 (Second Edition). Tim Bray, Dave Hollander, Andrew Layman, and Richard Tobin. 16 August 2006.

[UTF-8]

UTF-8, a transformation format of ISO 10646, RFC 3629 , F. Yergeau November 2003. http://www.ietf.org/rfc/rfc3629.txt

[UNICODE]

The Unicode Standard Version 3.0, Addison Wesley, Reading MA, 2000, ISBN: 0-201-61633-5. http://www.unicode.org/unicode/standard/standard.html