Difference between revisions of "ManchesterSyntax"

From OWL
Jump to: navigation, search
(Formal Description: Added comments)
(8 intermediate revisions by one user not shown)
Line 28: Line 28:
 
[<cite>[[#ref-owl-2-syntax|OWL 2 Syntax]]</cite>].
 
[<cite>[[#ref-owl-2-syntax|OWL 2 Syntax]]</cite>].
 
The Manchester syntax is primarily used in Protégé 4 (http://protegewiki.stanford.edu/index.php/Protege4UserDocs) and TopBraid composer (http://www.topquadrant.com/topbraid/composer/) for entering and displaying descriptions associated with classes, but it can also be used for entire ontologies.  Some tools (e.g., Protégé 4) extend the Manchester syntax to allow even more compact presentation in some situations (e.g., for explanation) or to replace URIs by label values.  The version of the Manchester syntax here is sufficient to store OWL 2 ontologies, but does not include any of these special-purpose extensions.
 
The Manchester syntax is primarily used in Protégé 4 (http://protegewiki.stanford.edu/index.php/Protege4UserDocs) and TopBraid composer (http://www.topquadrant.com/topbraid/composer/) for entering and displaying descriptions associated with classes, but it can also be used for entire ontologies.  Some tools (e.g., Protégé 4) extend the Manchester syntax to allow even more compact presentation in some situations (e.g., for explanation) or to replace URIs by label values.  The version of the Manchester syntax here is sufficient to store OWL 2 ontologies, but does not include any of these special-purpose extensions.
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:04, 8 October 2008 (UTC)|Direct hyperlinks to P4 and Topbraid should be at the bottom of the page, in the references section}}
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:04, 8 October 2008 (UTC)|Propose a slight rewrite to improve readability (e.g. four sentences start with "The Manchester OWL syntax...") }}
  
 
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|The use of labels to to replace URIs is central to productive use of Manchester syntax when URIs are not meaningful, as is common in many ontologies. In addition it is often recommended that, in general, URIs not have meaninful information encoded in their strings (see e.g. http://www.w3.org/DesignIssues/Axioms.html). Given this and the goal of making the Manchester syntax readable and user friendly, this specification should say precisely how to use labels in this way, while providing, as a backup, the ability to use URIs when they are not available.}}
 
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|The use of labels to to replace URIs is central to productive use of Manchester syntax when URIs are not meaningful, as is common in many ontologies. In addition it is often recommended that, in general, URIs not have meaninful information encoded in their strings (see e.g. http://www.w3.org/DesignIssues/Axioms.html). Given this and the goal of making the Manchester syntax readable and user friendly, this specification should say precisely how to use labels in this way, while providing, as a backup, the ability to use URIs when they are not available.}}
Line 44: Line 48:
  
 
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|Backwards reference to OWL 1 not necessary. Syntax "represents", rather than "stores". Perhaps replace starting "The Manchester OWL syntax stores" with: "Despite the fact that it adopts a frame-like syntax, 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.  }}
 
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|Backwards reference to OWL 1 not necessary. Syntax "represents", rather than "stores". Perhaps replace starting "The Manchester OWL syntax stores" with: "Despite the fact that it adopts a frame-like syntax, 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.  }}
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:04, 8 October 2008 (UTC)|That the Manchester syntax is readable for non-logicians is not its most distinguishing feature wrt. the other syntaxes. I don't suppose logicians would find RDF/XML more readable than the Manchester syntax (and, logicians seems a bit arbitrary, why not computer scientists?). I understood from earlier comments by [[User:AlanRuttenberg|Alan Ruttenberg]] that the syntax is meant to overcome accessibility issues as a whole: e.g. it is suitable for screen readers. Perhaps this accessibility issue could be stressed more.}}
  
 
An example ontology in the Manchester OWL syntax can be found in the OWL
 
An example ontology in the Manchester OWL syntax can be found in the OWL
Line 49: Line 55:
  
 
== The Grammar ==
 
== The Grammar ==
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:28, 8 October 2008 (UTC)|BNF grammar should be explained by e.g. a pointer to http://www.w3.org/2007/OWL/wiki/Syntax#BNF_Notation}}
  
 
=== Miscellaneous Concerns ===
 
=== Miscellaneous Concerns ===
  
 
Documents in the Manchester OWL syntax consist of sequences of unicode characters and are encoded in UTF-8.  
 
Documents in the Manchester OWL syntax consist of sequences of unicode characters and are encoded in UTF-8.  
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:28, 8 October 2008 (UTC)|Add reference to unicode and UTF-8 specs}}
  
 
The grammar for the Manchester syntax does not explicitly show white space.   
 
The grammar for the Manchester syntax does not explicitly show white space.   
Line 89: Line 99:
 
<span class="nonterminal">full-IRI</span> ::= '<' IRI as defined in [<cite>[[#ref-rfc-3987|RFC-3987]]</cite>] '>'
 
<span class="nonterminal">full-IRI</span> ::= '<' IRI as defined in [<cite>[[#ref-rfc-3987|RFC-3987]]</cite>] '>'
 
<span class="nonterminal">curie</span> ::= [ [ <span class="nonterminal">prefix</span> ] ':' ] <span class="nonterminal">reference</span>
 
<span class="nonterminal">curie</span> ::= [ [ <span class="nonterminal">prefix</span> ] ':' ] <span class="nonterminal">reference</span>
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|The Curie syntax is in last call. We should plan on citing it as normative, perhaps leaving an editor's note to that effect.}}
 
 
<span class="nonterminal">reference</span> ::= <span class="nonterminal">irelative-ref</span>
 
<span class="nonterminal">reference</span> ::= <span class="nonterminal">irelative-ref</span>
 
<span class="nonterminal">irelative-ref</span> ::= as defined in [<cite>[[#ref-rfc-3987|RFC-3987]]</cite>]
 
<span class="nonterminal">irelative-ref</span> ::= as defined in [<cite>[[#ref-rfc-3987|RFC-3987]]</cite>]
Line 104: Line 113:
 
<span id="owlClassURI" class="nonterminal">OWLClassURI</span> ::= <span class="nonterminal">URI</span>
 
<span id="owlClassURI" class="nonterminal">OWLClassURI</span> ::= <span class="nonterminal">URI</span>
 
<span id="datatype" class="nonterminal">datatype</span> ::= <span class="nonterminal">datatypeURI</span> | 'integer' | 'decimal' | 'float' | 'string'
 
<span id="datatype" class="nonterminal">datatype</span> ::= <span class="nonterminal">datatypeURI</span> | 'integer' | 'decimal' | 'float' | 'string'
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|Why {only} non-URIs for these. What about: number, real, real+, double, decimal, long, int, short, byte, datetime, text, etc..}}
 
 
<span id="datatypeURI" class="nonterminal">datatypeURI</span> ::= <span class="nonterminal">URI</span>
 
<span id="datatypeURI" class="nonterminal">datatypeURI</span> ::= <span class="nonterminal">URI</span>
 
<span id="objectPropertyURI" class="nonterminal">objectPropertyURI</span> ::= <span class="nonterminal">URI</span>
 
<span id="objectPropertyURI" class="nonterminal">objectPropertyURI</span> ::= <span class="nonterminal">URI</span>
Line 119: Line 127:
 
<span id="lexicalValue" class="nonterminal">lexicalValue</span> ::= '"' string with backslashes and double-quotes \-escaped '"'
 
<span id="lexicalValue" class="nonterminal">lexicalValue</span> ::= '"' string with backslashes and double-quotes \-escaped '"'
 
<span id="floatingPointLiteral" class="nonterminal">floatingPointLiteral</span> ::= [ '+' | '-'] ( <span class="nonterminal">digits</span> ['.'<span class="nonterminal">digits</span>] [<span class="nonterminal">exponent</span>] | '.' <span class="nonterminal">digits</span>[<span class="nonterminal">exponent</span>]) ( 'f' | 'F' )
 
<span id="floatingPointLiteral" class="nonterminal">floatingPointLiteral</span> ::= [ '+' | '-'] ( <span class="nonterminal">digits</span> ['.'<span class="nonterminal">digits</span>] [<span class="nonterminal">exponent</span>] | '.' <span class="nonterminal">digits</span>[<span class="nonterminal">exponent</span>]) ( 'f' | 'F' )
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|Do we want the trailing f for 1e10f, and 1e10 to be disallowed?. What about doubles? NaN, -0, +/- INF}}
 
 
<span class="nonterminal">exponent</span> ::= ('e' | 'E') ['+' | '-'] <span class="nonterminal">digits</span>
 
<span class="nonterminal">exponent</span> ::= ('e' | 'E') ['+' | '-'] <span class="nonterminal">digits</span>
 
<span id="decimalLiteral" class="nonterminal">decimalLiteral</span> ::= ['+' | '-'] <span class="nonterminal">digits</span> '.' <span class="nonterminal">digits</span>
 
<span id="decimalLiteral" class="nonterminal">decimalLiteral</span> ::= ['+' | '-'] <span class="nonterminal">digits</span> '.' <span class="nonterminal">digits</span>
Line 128: Line 135:
 
         | 'AnnotationProperty' '(' <span class="nonterminal">annotationPropertyURI</span> ')' | 'NamedIndividual' '(' <span class="nonterminal">individualURI</span> ')'  
 
         | 'AnnotationProperty' '(' <span class="nonterminal">annotationPropertyURI</span> ')' | 'NamedIndividual' '(' <span class="nonterminal">individualURI</span> ')'  
 
</p>
 
</p>
 +
 +
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|The Curie syntax is in last call. We should plan on citing it as normative, perhaps leaving an editor's note to that effect.}}
 +
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|Why {only} non-URIs for these. ([[User:RinkeHoekstra|RinkeHoekstra]]: refers to definition of datatype) What about: number, real, real+, double, decimal, long, int, short, byte, datetime, text, etc..}}
 +
{{Review|[[User:AlanRuttenberg|AlanRuttenberg]] 05:10, 8 October 2008 (UTC)|Do we want the trailing f for 1e10f, and 1e10 to be disallowed?. What about doubles? NaN, -0, +/- INF}}
 
{{Review|[[User:MikeSmith|MikeSmith]] 20:25, 7 October 2008 (UTC)|The grammar above could be simplified by referencing the Syntax document for terms that are defined identically, such as URI.  Since such references are present for terminals with other dependencies, such as full-IRI, referencing Syntax seems to make sense.}}
 
{{Review|[[User:MikeSmith|MikeSmith]] 20:25, 7 October 2008 (UTC)|The grammar above could be simplified by referencing the Syntax document for terms that are defined identically, such as URI.  Since such references are present for terminals with other dependencies, such as full-IRI, referencing Syntax seems to make sense.}}
 
{{Review|[[User:MikeSmith|MikeSmith]] 20:33, 7 October 2008 (UTC)|The grammar for typedLiteral and stringLiteral could be aligned with the grammar in Syntax.  This might reduce the likelihood of confused readers.}}
 
{{Review|[[User:MikeSmith|MikeSmith]] 20:33, 7 October 2008 (UTC)|The grammar for typedLiteral and stringLiteral could be aligned with the grammar in Syntax.  This might reduce the likelihood of confused readers.}}
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:14, 8 October 2008 (UTC)|Agree with Mike's comments on alignment with other syntaxes.}}
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:14, 8 October 2008 (UTC)|Wrt. datatypes (integer, decimal, float and string): these are probably mapped onto standard XML Schema datatypes, but this is left implicit.}}
  
 
=== Ontologies and Annotations ===
 
=== Ontologies and Annotations ===
Line 144: Line 157:
 
<span id="frame" class="nonterminal">frame</span> ::= <span class="nonterminal">classFrame</span> | <span class="nonterminal">objectPropertyFrame</span> | <span class="nonterminal">dataPropertyFrame</span> | <span class="nonterminal">annotationPropertyFrame</span> | <span class="nonterminal">individualFrame</span> | <span class="nonterminal">misc</span>
 
<span id="frame" class="nonterminal">frame</span> ::= <span class="nonterminal">classFrame</span> | <span class="nonterminal">objectPropertyFrame</span> | <span class="nonterminal">dataPropertyFrame</span> | <span class="nonterminal">annotationPropertyFrame</span> | <span class="nonterminal">individualFrame</span> | <span class="nonterminal">misc</span>
 
</p>
 
</p>
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:28, 8 October 2008 (UTC)|Inconsistent use of upper/lower case: full-IRI (previous section) vs. Full-IRI here}}
  
 
The 'rdf', 'rdfs', 'owl', and 'xsd' prefixes are pre-defined as follows and cannot be changed.
 
The 'rdf', 'rdfs', 'owl', and 'xsd' prefixes are pre-defined as follows and cannot be changed.
Line 199: Line 214:
  
 
=== Frames and Miscellaneous ===
 
=== Frames and Miscellaneous ===
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:28, 8 October 2008 (UTC)|Find the 'miscellaneous' in the title a bit imprecise, but can't come up with a better name myself.}}
  
 
<p class="grammar" style="white-space: pre;"><span id="classFrame" class="nonterminal">classFrame</span> ::= 'Class:' <span class="nonterminal">OWLClassURI</span>  
 
<p class="grammar" style="white-space: pre;"><span id="classFrame" class="nonterminal">classFrame</span> ::= 'Class:' <span class="nonterminal">OWLClassURI</span>  
Line 257: Line 274:
 
</p>
 
</p>
 
{{Review|[[User:MikeSmith|MikeSmith]] 21:03, 7 October 2008 (UTC)|KeyFor changed to HasKey in the other syntaxes.  Can it be changed here?}}
 
{{Review|[[User:MikeSmith|MikeSmith]] 21:03, 7 October 2008 (UTC)|KeyFor changed to HasKey in the other syntaxes.  Can it be changed here?}}
 +
  
 
=== Global Concerns ===
 
=== Global Concerns ===
Line 283: Line 301:
 
lists of sub-constructs except where annotations are explicitly noted
 
lists of sub-constructs except where annotations are explicitly noted
 
(e.g., in DisjointUnionOf:, in DisjointClasses:).
 
(e.g., in DisjointUnionOf:, in DisjointClasses:).
 +
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:32, 8 October 2008 (UTC)|Example ontology should import Dublin Core definitions. The dc:creator data property should probably be replaced with some made-up property.}}
  
 
  [[#namespace|Namespace: <http://ex.com/owl/families#>]]
 
  [[#namespace|Namespace: <http://ex.com/owl/families#>]]
Line 353: Line 374:
 
   [[#DifferentIndividuals|DifferentIndividuals:]] [[#annotations|Annotations: ...]] [[#individual|John]], [[#individual|Susan]], [[#individual|Mary]], [[#individual|Jill]]
 
   [[#DifferentIndividuals|DifferentIndividuals:]] [[#annotations|Annotations: ...]] [[#individual|John]], [[#individual|Susan]], [[#individual|Mary]], [[#individual|Jill]]
 
   [[#KeyFor|KeyFor:]] [[#annotations|Annotations: ...]] [[#dataPropertyExpression|hasSSN]] [[#description|Person]]
 
   [[#KeyFor|KeyFor:]] [[#annotations|Annotations: ...]] [[#dataPropertyExpression|hasSSN]] [[#description|Person]]
 
  
 
== Appendix: Translation to OWL 2 Functional Syntax ==
 
== Appendix: Translation to OWL 2 Functional Syntax ==
Line 389: Line 409:
 
Descriptions also correspond closely betwen the Manchester OWL syntax
 
Descriptions also correspond closely betwen the Manchester OWL syntax
 
and the OWL 2 Functional Syntax.
 
and the OWL 2 Functional Syntax.
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:37, 8 October 2008 (UTC)|Typo: betwen->between. Consider rephrasing 'translating frames axioms'.}}
  
 
Translating frames axioms is performed by splitting them into pieces that
 
Translating frames axioms is performed by splitting them into pieces that
Line 406: Line 428:
 
disambiguated depending on whether the property is an object property or
 
disambiguated depending on whether the property is an object property or
 
a data property.
 
a data property.
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:37, 8 October 2008 (UTC)|What does 'almost directly' mean? What would the mismatch be?}}
  
 
The remaining top-level constructs of an ontology (namespaces, imports, ontology
 
The remaining top-level constructs of an ontology (namespaces, imports, ontology
Line 449: Line 473:
  
 
Finally, perform the following transformation.  Any piece of syntax with no transformation listed here is just copied through.
 
Finally, perform the following transformation.  Any piece of syntax with no transformation listed here is just copied through.
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:42, 8 October 2008 (UTC)|Strings with language tags should be mapped onto literals of type rdf:text, see [[Syntax#Strings]]}}
 +
 +
{{Review|[[User:RinkeHoekstra|RinkeHoekstra]] 13:42, 8 October 2008 (UTC)|Typo: Asymmectric -> Asymmetric}}
  
 
{| border="1" style="font-size: smaller;"
 
{| border="1" style="font-size: smaller;"

Revision as of 13:42, 8 October 2008

__NUMBEREDHEADINGS__

[Hide Review Comments]

Document title:
OWL 2 Web Ontology Language
Manchester Syntax (Second Edition)
Authors
Matthew Horridge, University of Manchester
Peter F. Patel-Schneider, Bell Labs Research, Alcatel-Lucent
Abstract
The Manchester syntax is a user-friendly compact syntax for OWL 2. The Manchester syntax is frame-based, as opposed to the axiom-based other syntaxes for OWL 2. It is used in Protégé 4 and TopBraid composer.
Status of this Document
This is an editors' draft. This document is expected to be turned into a Working Group Note, describing the Manchester Syntax at the time of the W3C OWL Working Group's closing.
This is not a normative document. The Manchester Syntax is used in the OWL 2 Primer, and this document provides the language used there. OWL 2 tools may implement extensions to the Manchester Syntax, and may only implement part of it, for example only the descriptions.
Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
What OWL 2 tools may or may not do is not part of status.

1 Introduction

The Manchester OWL syntax is a user-friendly syntax for OWL 2 descriptions. The Manchester OWL syntax 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 primarily used in Protégé 4 (http://protegewiki.stanford.edu/index.php/Protege4UserDocs) and TopBraid composer (http://www.topquadrant.com/topbraid/composer/) for entering and displaying descriptions associated with classes, but it can also be used for entire ontologies. Some tools (e.g., Protégé 4) extend the Manchester syntax to allow even more compact presentation in some situations (e.g., for explanation) or to replace URIs by label values. The version of the Manchester syntax here is sufficient to store OWL 2 ontologies, but does not include any of these special-purpose extensions.

Review comment from RinkeHoekstra 13:04, 8 October 2008 (UTC)
Direct hyperlinks to P4 and Topbraid should be at the bottom of the page, in the references section
Review comment from RinkeHoekstra 13:04, 8 October 2008 (UTC)
Propose a slight rewrite to improve readability (e.g. four sentences start with "The Manchester OWL syntax...")
Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
The use of labels to to replace URIs is central to productive use of Manchester syntax when URIs are not meaningful, as is common in many ontologies. In addition it is often recommended that, in general, URIs not have meaninful information encoded in their strings (see e.g. http://www.w3.org/DesignIssues/Axioms.html). Given this and the goal of making the Manchester syntax readable and user friendly, this specification should say precisely how to use labels in this way, while providing, as a backup, the ability to use URIs when they are not available.

The Manchester OWL syntax was particularly designed to be easily readable, particularly by non-logicians, as opposed to RDF/XML [RDF Syntax], the abstract syntax for OWL 1 DL [OWL Semantics and Abstract Syntax], the functional-style syntax for OWL 2 [OWL 2 Syntax], and the XML syntax for OWL 2 [OWL 2 XML Syntax]. The Manchester OWL syntax stores ontologies in an object-centered frame-like fashion. It is thus closer to the abstract syntax for OWL 1 DL than the functional-style syntax 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.

Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
Backwards reference to OWL 1 not necessary. Syntax "represents", rather than "stores". Perhaps replace starting "The Manchester OWL syntax stores" with: "Despite the fact that it adopts a frame-like syntax, 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.
Review comment from RinkeHoekstra 13:04, 8 October 2008 (UTC)
That the Manchester syntax is readable for non-logicians is not its most distinguishing feature wrt. the other syntaxes. I don't suppose logicians would find RDF/XML more readable than the Manchester syntax (and, logicians seems a bit arbitrary, why not computer scientists?). I understood from earlier comments by Alan Ruttenberg that the syntax is meant to overcome accessibility issues as a whole: e.g. it is suitable for screen readers. Perhaps this accessibility issue could be stressed more.

An example ontology in the Manchester OWL syntax can be found in the OWL Primer [OWL 2 Primer].

2 The Grammar

Review comment from RinkeHoekstra 13:28, 8 October 2008 (UTC)
BNF grammar should be explained by e.g. a pointer to http://www.w3.org/2007/OWL/wiki/Syntax#BNF_Notation

2.1 Miscellaneous Concerns

Documents in the Manchester OWL syntax consist of sequences of unicode characters and are encoded in UTF-8.

Review comment from RinkeHoekstra 13:28, 8 October 2008 (UTC)
Add reference to unicode and UTF-8 specs

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).

The syntax uses several keywords (e.g., 'and', 'or', 'not') in places where they can be confused with names. In all cases, the keyword use dominates.

Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
Better to indicate these clearly at point of use. It's not clear what "keyword use dominates" means.

Because comma-separated lists occur in very many places in the syntax, to save space the grammar here 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> }

2.2 URIs, Integers, URIs, Literals, and Entities

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 | stringLiteral | integerLiteral | decimalLiteral | floatingPointLiteral typedLiteral ::= lexicalValue '^^' datatype stringLiteral ::= lexicalValue [ '@' languageTag ] languageTag ::= a language tag as specified in [RFC-4646] lexicalValue ::= '"' 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 ')'

Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
The Curie syntax is in last call. We should plan on citing it as normative, perhaps leaving an editor's note to that effect.
Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
Why {only} non-URIs for these. (RinkeHoekstra: refers to definition of datatype) What about: number, real, real+, double, decimal, long, int, short, byte, datetime, text, etc..
Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
Do we want the trailing f for 1e10f, and 1e10 to be disallowed?. What about doubles? NaN, -0, +/- INF
Review comment from MikeSmith 20:25, 7 October 2008 (UTC)
The grammar above could be simplified by referencing the Syntax document for terms that are defined identically, such as URI. Since such references are present for terminals with other dependencies, such as full-IRI, referencing Syntax seems to make sense.
Review comment from MikeSmith 20:33, 7 October 2008 (UTC)
The grammar for typedLiteral and stringLiteral could be aligned with the grammar in Syntax. This might reduce the likelihood of confused readers.
Review comment from RinkeHoekstra 13:14, 8 October 2008 (UTC)
Agree with Mike's comments on alignment with other syntaxes.
Review comment from RinkeHoekstra 13:14, 8 October 2008 (UTC)
Wrt. datatypes (integer, decimal, float and string): these are probably mapped onto standard XML Schema datatypes, but this is left implicit.

2.3 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

Review comment from RinkeHoekstra 13:28, 8 October 2008 (UTC)
Inconsistent use of upper/lower case: full-IRI (previous section) vs. Full-IRI here

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.4 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' | '<=' | '<' | '>=' | '>' restrictionValue ::= literal dataOneOf ::= '{' literal { ',' literal } '}' dataComplementOf ::= 'not' dataRange

Review comment from MikeSmith 20:40, 7 October 2008 (UTC)
Is rdf:langPattern intentionally missing or is pattern overloaded?
Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
Will we not follow the lead of functional syntax and have facets be URIs?

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.5 Descriptions

Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
Missing pipe(or) separating "that not" from "and not"

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 ')'

Review comment from AlanRuttenberg 05:10, 8 October 2008 (UTC)
The OWLED paper on Manchester syntax defines an "onlysome", "xor", and "ValuePartition" "macros" not listed here.

2.6 Frames and Miscellaneous

Review comment from RinkeHoekstra 13:28, 8 October 2008 (UTC)
Find the 'miscellaneous' in the title a bit imprecise, but can't come up with a better name myself.

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 | 'KeyFor:' annotations ( objectPropertyExpression | dataPropertyExpression ) { objectPropertyExpression | dataPropertyExpression } description

Review comment from MikeSmith 21:03, 7 October 2008 (UTC)
KeyFor changed to HasKey in the other syntaxes. Can it be changed here?


2.7 Global Concerns

In an ontology, and the ontologies that it imports, the same URI can be used for a class or a datatype; an object, data, or annotation property; and an individual. However, 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. 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.

Review comment from MikeSmith 21:00, 7 October 2008 (UTC)
Could this paragraph be simplifed by saying that the Manchester syntax is only valid for ontologies satisfying the typing constraints defined in Syntax?

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:).


Review comment from RinkeHoekstra 13:32, 8 October 2008 (UTC)
Example ontology should import Dublin Core definitions. The dc:creator data property should probably be replaced with some made-up property.
Namespace: <http://ex.com/owl/families#>
Namespace: g <http://ex.com/owl2/families#>
Namespace: dc <http://purl.org/dc/elements/1.1/>

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

  ObjectProperty: hasWife
    Annotations: ...
    Characteristics: Functional, InverseFunctional, Reflexive, Irreflexive, Asymmetric, Transitive
    Domain: Annotations: rdfs:comment "General domain",
                         dc: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 ,...

  DataProperty: dc: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
  KeyFor: 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 betwen the Manchester OWL syntax and the OWL 2 Functional Syntax.

Review comment from RinkeHoekstra 13:37, 8 October 2008 (UTC)
Typo: betwen->between. Consider rephrasing 'translating frames axioms'.

Translating frames 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 almost directly to 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.

Review comment from RinkeHoekstra 13:37, 8 October 2008 (UTC)
What does 'almost directly' mean? What would the mismatch be?

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:

Frame Declaration
Class: URI ... Declaration( Class(URI) )
ObjectProperty: URI ... Declaration( ObjectProperty(URI) )
DataProperty: URI ... Declaration( DataProperty(URI) )
AnnotationProperty: URI ... Declaration( AnnotationProperty(URI) )
Individual: URI ... Declaration( NamedIndividual(URI) )
Individual: nodeID ...

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

Syntax Form Transformation (U)
Frame with multiple top-level pieces (F: is Class:, ...) F: URI p1 p2 ... F: URI p1 F: URI p2 ...
Frame with single, complex top-level piece (P: is Annotations:, SubClassOf:, ...) F: URI P: s1 s2 ... F: URI P: s1 F: URI P: s2 ...

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.

Review comment from RinkeHoekstra 13:42, 8 October 2008 (UTC)
Strings with language tags should be mapped onto literals of type rdf:text, see Syntax#Strings
Review comment from RinkeHoekstra 13:42, 8 October 2008 (UTC)
Typo: Asymmectric -> Asymmetric
Nonterminal Form Transformation (T)
datatype integer xsd:integer
datatype decimal xsd:decimal
datatype float xsd:float
datatype string xsd:string
integerLiteral integer "integer"^^xsd:integer
decimalLiteral decimal "decimal"^^xsd:decimal
floatingPointLiteral float "float"^^xsd:float
stringLiteral string string
stringLiteral string@tag string@tag
dataComplementOf not dataRange ComplementOf(T(dataRange))
dataOneOf { literal list } OneOf(T(literal list))
facet length xsd:length
facet minLength xsd:minLength
facet maxLength xsd:maxLength
facet pattern xsd:pattern
facet <= xsd:minInclusive
facet < xsd:minExclusive
facet >= xsd:maxInclusive
facet > xsd:maxExclusive
datatypeRestriction datatype[facet-value list] DatatypeRestriction(T(datatype) T(facet-value list))
inverseObjectProperty inverse objectPropertyExpression InverseProperty(T(objectPropertyExpression))
atomic {individual list} OneOf(T(individual list))
atomic (description) T(description)
restriction objectPropertyExpression some primary SomeValuesFrom(T(objectPropertyExpression) T(primary))
restriction objectPropertyExpression only primary AllValuesFrom(T(objectPropertyExpression) T(primary))
restriction objectPropertyExpression value individual HasValue(T(objectPropertyExpression) individual)
restriction objectPropertyExpression min nni MinCardinality(T(objectPropertyExpression) nni)
restriction objectPropertyExpression min nni primary MinCardinality(T(objectPropertyExpression) nni T(primary))
restriction objectPropertyExpression exactly nni ExactCardinality(T(objectPropertyExpression) nni)
restriction objectPropertyExpression exactly nni primary ExactCardinality(T(objectPropertyExpression) nni T(primary))
restriction objectPropertyExpression max nni MaxCardinality(T(objectPropertyExpression) nni)
restriction objectPropertyExpression max nni primary MaxCardinality(T(objectPropertyExpression) nni T(primary))
restriction objectPropertyExpression Self ExistsSelf(T(objectPropertyExpression))
restriction dataPropertyExpression some dataRange SomeValuesFrom(T(dataPropertyExpression) T(dataRange))
restriction dataPropertyExpression only dataRange AllValuesFrom(T(dataPropertyExpression) T(dataRange))
restriction dataPropertyExpression value literal HasValue(T(dataPropertyExpression) T(literal))
restriction dataPropertyExpression min nni MinCardinality(T(dataPropertyExpression) nni)
restriction dataPropertyExpression min nni dataRange MinCardinality(T(dataPropertyExpression) nni T(dataRange))
restriction dataPropertyExpression exactly nni ExactCardinality(T(dataPropertyExpression) nni)
restriction dataPropertyExpression exactly nni dataRange ExactCardinality(T(dataPropertyExpression) nni T(dataRange))
restriction dataPropertyExpression max nni MaxCardinality(T(dataPropertyExpression) nni)
restriction dataPropertyExpression max nni dataRange MaxCardinality(T(dataPropertyExpression) nni T(dataRange))
primary atomic T(atomic)
primary not atomic ComplementOf(T(atomic))
conjunction OWLClassURI that primary ... IntersectionOf(OWLClassURI T(primary) ...)
conjunction primary and ... IntersectionOf(T(primary) ...)
conjunction primary T(primary)
description conjunction or ... UnionOf(T(conjunction) ...)
description conjunction T(conjunction)
annotation annotationPropertyURI literal Annotation(annotationPropertyURI T(literal))
annotation annotationPropertyURI individualURI Annotation(annotationPropertyURI Individual(individualURI))
annotation annotationPropertyURI nodeID Annotation(annotationPropertyURI nodeID))
annotation annotationPropertyURI entity Annotation(annotationPropertyURI entity)
classFrame Class: URI Annotations: annotation EntityAnnotation(Class(URI) T(annotation))
classFrame Class: URI SubClassOf: annotations description SubClassOf(T(annotations) URI T(description))
classFrame Class: URI EquivalentTo: annotations description EquivalentClasses(T(annotations) URI T(description))
classFrame Class: URI DisjointWith: annotations description DisjointClasses(T(annotations) URI T(description))
classFrame Class: URI DisjointUnionOf: annotations descriptions DisjointUnion(T(annotations) URI T(description))
objectPropertyFrame ObjectProperty: URI Annotations: annotation EntityAnnotation(ObjectProperty(URI) T(annotation))
objectPropertyFrame ObjectProperty: URI Domain: annotations description PropertyDomain(T(annotations) URI T(description))
objectPropertyFrame ObjectProperty: URI Range: annotations description PropertyRange(T(annotations) URI T(description))
objectPropertyFrame ObjectProperty: URI Characteristics: annotations Functional FunctionalProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI Characteristics: annotations InverseFunctional InverseFunctionalProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI Characteristics: annotations Reflexive ReflexiveProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI Characteristics: annotations Irreflexive IrreflexiveProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI Characteristics: annotations Symmetric SymmetricProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI Characteristics: annotations Asymmetric AsymmectricProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI Characteristics: annotations Transitive TransitiveProperty(T(annotations) URI)
objectPropertyFrame ObjectProperty: URI SubPropertyOf: annotations objectPropertyExpression SubPropertyOf(T(annotations) URI T(objectPropertyExpression))
objectPropertyFrame ObjectProperty: URI EquivalentTo: annotations objectPropertyExpression EquivalentProperties(T(annotations) URI T(objectPropertyExpression))
objectPropertyFrame ObjectProperty: URI DisjointWith: annotations objectPropertyExpression DisjointProperties(T(annotations) URI T(objectPropertyExpression))
objectPropertyFrame ObjectProperty: URI InverseOf: annotations objectPropertyExpression InverseProperties(T(annotations) URI T(objectPropertyExpression))
objectPropertyFrame ObjectProperty: URI SubPropertyChain: objectPropertyExpression o ... SubPropertyOf(PropertyChain(T(objectPropertyExpression) ...) URI)
dataPropertyFrame DataProperty: URI Annotations: annotation EntityAnnotation(DataProperty(URI) T(annotation))
dataPropertyFrame DataProperty: URI Domain: annotations description PropertyDomain(T(annotations) URI T(description))
dataPropertyFrame DataProperty: URI Domain: annotations dataRange PropertyRange(T(annotations) URI T(dataRange))
dataPropertyFrame DataProperty: URI Characteristics: annotations Functional FunctionalProperty(T(annotations) URI)
dataPropertyFrame DataProperty: URI SubPropertyOf: annotations dataPropertyExpression SubPropertyOf(T(annotations) URI T(dataPropertyExpression))
dataPropertyFrame DataProperty: URI EquivalentTo: annotations dataPropertyExpression EquivalentProperties(T(annotations) URI T(dataPropertyExpression))
dataPropertyFrame DataProperty: URI DisjointWith: annotations dataPropertyExpression DisjointProperties(T(annotations) URI T(dataPropertyExpression))
annotationPropertyFrame AnnotationProperty: URI Annotations: annotation EntityAnnotation(AnnotationProperty(URI) T(annotation))
individualFrame Individual: URI Annotations: annotation EntityAnnotation(Individual(URI) T(annotation))
individualFrame Individual: nodeID Annotations: annotation AnonymousIndividualAnnotation(nodeID T(annotation))
individualFrame Individual: individual Types: annotations description ClassAssertion(T(annotations) T(description) individual)
individualFrame Individual: individual Facts: annotations objectPropertyURI individual2 PropertyAssertion(T(annotations) objectPropertyURI individual individual2)
individualFrame Individual: individual Facts: annotations not objectPropertyURI individual2 NegativePropertyAssertion(T(annotations) objectPropertyURI individual individual2)
individualFrame Individual: individual Facts: annotations dataPropertyURI literal PropertyAssertion(T(annotations) dataPropertyURI individual T(literal))
individualFrame Individual: individual Facts: annotations not dataPropertyURI literal NegativePropertyAssertion(T(annotations) dataPropertyURI individual T(literal))
individualFrame Individual: individual SameAs: annotations individual2 SameIndividual(T(annotations) individual individual2)
individualFrame Individual: individual DifferentFrom: annotations individual2 DifferentIndividuals(T(annotations) individual individual2)
misc EquivalentClasses: annotations descriptions EquivalentClasses(T(annotations) T(descriptions))
misc DisjointClasses: annotations descriptions DisjointClasses(T(annotations) T(descriptions))
misc EquivalentProperties: annotations objectProperties EquivalentProperties(T(annotations) T(objectProperties))
misc DisjointProperties: annotations objectProperties DisjointProperties(T(annotations) T(objectProperties))
misc EquivalentProperties: annotations dataProperties EquivalentProperties(T(annotations) T(dataProperties))
misc DisjointProperties: annotations dataProperties DisjointProperties(T(annotations) T(dataProperties))
misc SameIndividual: annotations individuals SameIndividual(T(annotations) individuals)
misc DifferentIndividuals: annotations individuals DifferentIndividuals(T(annotations) individuals)
misc KeyFor: annotations properties description KeyFor(T(annotations) T(properties) T(description))
namespace Namespace: prefix Full-IRI Namespace(prefix = Full-IRI)
namespace Namespace: Full-IRI Namespace( = Full-IRI)
import Import: URI Import(URI)
ontology Ontology: URI URI imports annotations frames Ontology(URI URI T(imports) T(annotations) T(frames))
ontology Ontology: URI imports annotations frames Ontology(URI T(imports) T(annotations) T(frames))
ontology Ontology: imports annotations frames Ontology(T(imports) T(annotations) T(frames))
ontologyDocument namespaces ontology T(namespaces) T(ontology)


5 References

[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.
[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) .
[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/.
[XML Namespaces]
Namespaces in XML 1.0 (Second Edition). Tim Bray, Dave Hollander, Andrew Layman, and Richard Tobin. 16 August 2006.