The classes of the vocabulary are listed in Table 1. Each row represents a owl:Class with optional superclass relationship (using rdfs:subClassOf), textual definition (skos:definition) and optional note (skos:note).

The properties of the vocabulary are listed in Table 2. Each row represents an owl:AnnotationProperty with optional domain (rdfs:domain) and optional range (rdfs:range), textual definition (skos:definition) and optional node (skos:note).

The reasons for using owl:AnnotationProperty to represent the properties (and not owl:ObjectProperty and owl:DatatypeProperty) is that

• many of the properties take RDF lists as values, which places the vocabulary outside the OWL 2 DL fragment anyway, and
• some of the properties, ottr:value, ottr:default and ottr:parameter, need to take both literals and IRIs as values, which disqualifies the use of owl:ObjectProperty or owl:DatatypeProperty.

The domains and ranges for ottr:modifier are not translated into the ontology. This is because these should be represented as a "locally scoped" domain and range, but complex axioms on annotation properties are not supported in OWL.

The individuals of the vocabulary are listed in Table 3. Each row represents a owl:Thing with type relationship to a class (rdf:type), textual definition (skos:definition) and optional note (skos:note).

Each term is annotated with rdfs:isDefinedBy, naming the version IRI of the ontology that declares it. The table below adds, for the terms whose history is known, the versions bounding the term's life. A term with no row here carries no such stamp: this document only records history from 0.4.2 onwards, which is as far back as the change notes go.

The three columns answer three different questions:

Introduced

the term did not exist before this version.

Changed

the term existed, but its declaration or meaning differed before this version. This is the case a consumer cannot detect for itself: the document still parses and quietly means something else.

Deprecated

the term should not be used from this version on.

A term is therefore valid over the half-open interval from, and including, Introduced to Deprecated.

Values are versions; the version IRIs are built from them. A term with a Deprecated version must also carry owl:deprecated true, which is what tools that do not know this vocabulary read; a rename records dcterms:isReplacedBy alongside it, and that is the whole of what a migration tool needs.

The blank node scope [1] of wOTTR is the RDF document, as defined by RDF: the same blank node label denotes the same blank node within a document, and blank nodes of different documents are always distinct.

A variable is not a blank node, but is represented by one. The representation must be unambiguous within the scope: a blank node represents at most one variable and is not otherwise used, see 2.2.3.

ottr:RDFListShape a sh:NodeShape ;
  sh:targetSubjectsOf rdf:first , rdf:rest ;
  sh:node shsh:ListShape ;
  sh:name "RDF lists" ;
  sh:message "RDF lists must be regular linked lists." 
.

It is optional to explicitly type the resources used to specify an instance, e.g., it is not required to explicitly add the statement that an instance has the type ottr:Instance or ottr:Argument.

An ottr:Instance must be associated with the (single) ottr:Signature, ottr:Template and ottr:BaseTemplate it is an instance of using the ottr:of property. (Note that ottr:Template or ottr:BaseTemplate are disjoint subclasses of ottr:Signature.)

An ottr:Instance may have one ottr:modifier which is an ottr:ExpansionModifier. An ottr:ExpansionModifier is either ottr:cross, ottr:zipMax or ottr:zipMin.

An ottr:Instance must specify a list of arguments. This can be done in two ways: the canonical or the compact way. The canonical way is to state that an ottr:Instance has ottr:arguments which is an RDF list of ottr:Argument-s. The compact way is to directly state that an ottr:Instance has (attribute-) ottr:values which is an RDF list of RDF resources. However, as explained in the next paragraph, the reduced expressivity of the compact way does not cover all cases. The canonical way covers all cases.

ottr:InstanceShape a sh:NodeShape ;
  sh:targetSubjectsOf ottr:of , ottr:arguments , ottr:values ;
  sh:targetObjectsOf ottr:pattern, ottr:annotation ;
  sh:property 
    [ sh:path ottr:of ;
      sh:minCount 1 ;
      sh:maxCount 1 ;
      sh:nodeKind sh:IRI ;
      sh:name "Instance's reference to signature" ;
      sh:message "An instance must have exactly one reference to a signature, which must be an IRI."
    ] ,
    [ sh:path ottr:modifier ;
      sh:maxCount 1 ;
      sh:node _:instanceModifierInList ;
      sh:name "Instance modifier" ;
      sh:message "An instance can only have one modifier, which must be either ottr:cross, ottr:zipMin or ottr:zipMax."
    ];
  sh:xone 
    (
      [ sh:property
        [ sh:path ottr:arguments ;
          sh:minCount 1 ;
          sh:maxCount 1 ;
          sh:node shsh:ListShape ;
          sh:property [
            sh:path ( [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
            sh:node ottr:ArgumentShape ;
          ] ;
          sh:name "Instance argument list" ;
          sh:message "An instance must have exactly (possibly empty) one argument list or argument value list. The argument list must contain arguments---and not argument values."
        ]  
      ]
      [ sh:property 
        [ sh:path ottr:values ;
          sh:minCount 1;
          sh:maxCount 1 ;
          sh:node shsh:ListShape
        ] ;
        sh:name "Instance argument value list" ;
        sh:message "An instance must have exactly one (possibly empty) argument list or argument value list."
      ]
    ) ;
  ## instance has listExpander if and only if exists argument with modifier.
  ## modelled as (( not A or B ) and ( not B or A))
  sh:and (
    [ sh:or ( [ sh:not _:hasPropertyInstanceModifier ] _:hasPropertyArgumentWithListExpander ) ]
    [ sh:or ( [ sh:not _:hasPropertyArgumentWithListExpander ] _:hasPropertyInstanceModifier ) ]
  )
.

### Some shapes represented by named blank nodes to avoid repetition:

# legal instance modifiers:
_:instanceModifierInList sh:in ( ottr:cross ottr:zipMin ottr:zipMax ) .

# instance has a modifier:
_:hasPropertyInstanceModifier 
  sh:property [ 
    sh:path ottr:modifier ;
    sh:minCount 1 ;
    sh:node _:instanceModifierInList ] .

# instance has an argument with a modifier:
_:hasPropertyArgumentWithListExpander 
  sh:property [
    sh:path ( ottr:arguments [ sh:zeroOrMorePath rdf:rest ] rdf:first ottr:modifier ) ;
    sh:minCount 1 ;
    sh:hasValue ottr:listExpand ] .

An ottr:Argument must have one ottr:value which is any RDF resource. The resource ottr:none can be used to explicitly specify that an ottr:Argument has no value.

An ottr:Argument may have a ottr:modifier which is an ottr:ArgumentModifier. The only ottr:ArgumentModifier is ottr:listExpand. An ottr:Argument which has a ottr:listExpand modifier, must have a ottr:value which is compatible with a list type.

Canonical vs. Compact arguments

Since the compact way of specifying an instance's arguments does not include any ottr:Argument-s, it cannot be used if it is necessary to associate information on any of the ottr:Argument-s, for instance marking an ottr:Argument with an ottr:ArgumentModifier.

The use of ottr:none is required when stating "no value" in the compact way. This is due to how lists are represented in RDF Turtle.

ottr:ArgumentShape a sh:NodeShape ;
  sh:targetSubjectsOf ottr:value ;
  ## sh:nodeKind sh:BlankNode ; ## only in strict mode?
  sh:property 
    [ sh:path ottr:modifier ;
      sh:maxCount 1;
      sh:node [ sh:in ( ottr:listExpand ) ] ;
      sh:name "Argument modifier" ;
      sh:message "An argument can only have the modifier ottr:listExpand."
    ] ,
    [ sh:path ottr:value ;
      sh:minCount 1;
      sh:maxCount 1;
      sh:name "Argument value" ;
      sh:message "An argument can only have one value."
    ] ;
  ## if listExpander, then must be blanknode/list
  ## modelled as not A or B.
  sh:or (
    [ sh:not [ sh:path ottr:modifier ; sh:hasValue ottr:listExpand ] ]
    [ sh:path ottr:value ; 
      sh:nodeKind sh:BlankNode ;
      sh:message "An argument with a ottr:listExpand modifier must have a blanknode (possibly representing a list) as value.";
    ]
  ) 
.

# 1. instance, canonical arguments
[] ottr:of ex:template ;
   ottr:arguments (
      [ ottr:value _:A ]
      [ ottr:value ottr:none ]
      [ ottr:value _:C ]
      [ ottr:value _:D ] ) .

# 2. instance, compact argument values
[] ottr:of ex:template ;
   ottr:values ( _:A  ottr:none  _:C  _:D ) .

[] ottr:of ex:template ;
   ottr:modifier ottr:cross ;
   ottr:arguments (
      [ ottr:value ( 1 2 3 4 ) ; ottr:modifier ottr:listExpand ]
      [ ottr:value ( ex:a ex:b ex:c ) ]
      [ ottr:value "string" ] 
      [ ottr:value ottr:none ]
      [ ottr:value rdfs:subClassOf ] ) .

The ottr:Signature class has two subclasses, ottr:Template and ottr:BaseTemplate, which are disjoint. We require that instances of these classes are explicitly typed with at least the most specific class.

A ottr:Signature must be identifiable by a concrete IRI (and not a blank node).

A ottr:Signature must have ottr:parameters which is a (possibly empty) RDF list of ottr:Parameter-s.

A ottr:Signature may have any number of ottr:annotation-s which are ottr:Instance-s.

ottr:SignatureShape a sh:NodeShape ;
  sh:targetClass ottr:Signature ;
  sh:targetSubjectsOf ottr:parameters, ottr:annotation ;
  sh:class ottr:Signature ;
  sh:nodeKind sh:IRI ;
  sh:message "A signature must have the type ottr:Signature or one of its subclasses, and be identified by an IRI." ;
  sh:property 
    [ sh:path ottr:parameters ;
      sh:minCount 1 ;
      sh:maxCount 1 ;
      sh:node shsh:ListShape ;
      sh:property [
        sh:path ( [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
        sh:node ottr:ParameterShape ;
      ] ;
      sh:name "Signature parameter list" ;
      sh:message "A signature must declare exactly one parameter list, which must contain parameters."
    ]
.

ex:signature a ottr:Signature ;
  ottr:parameters ( );
  ottr:annotation 
   [ ottr:of ex:templateA ; ottr:values ( ex:signature "this an annotation" ) ] ,
   [ ottr:of ex:templateB ; ottr:values ( ex:signature "this is also an annotation" ) ] .

A ottr:Parameter MUST have a ottr:variable which MUST be a blank node.

The blank node represents the variable and is not the variable itself [1], since variables and constants are disjoint [2].

A blank node representing a variable MUST NOT represent another variable or be used as a constant, so that the representation is unambiguous within the blank node scope.

A ottr:Parameter can have a ottr:name which is a string with the lexical space of an xsd:token.

A ottr:Parameter can have a ottr:type. How types are specified is described below.

A ottr:Parameter can have a ottr:default value which is an RDF resource.

A ottr:Parameter can have several ottr:modifier-s which are ottr:ParameterModifier-s. A ottr:ParameterModifier is either ottr:optional or ottr:nonBlank.

ottr:ParameterShape a sh:NodeShape ;
  sh:targetSubjectsOf ottr:variable, ottr:type, ottr:default ;
  sh:property 
    [ sh:path ottr:variable ;
      sh:minCount 1 ;
      sh:maxCount 1 ;
      sh:name "Parameter variable" ;
      sh:message "A parameter must have exactly one variable.";
    ] ,
    [ sh:path ottr:type ;
      sh:node ottr:TypeListShape ;
      sh:maxCount 1 ;
      sh:name "Parameter type" ;
      sh:message "A parameter can only have one type, which must be a permissible type value."
    ] ,
    [ sh:path ottr:name ;
      sh:maxCount 1 ;
      sh:name "Parameter name" ;
      sh:datatype xsd:token ;
      sh:message "A parameter can only have one name."
    ] ,
    [ sh:path ottr:default ;
      sh:maxCount 1 ;
      sh:name "Parameter default value" ;
      sh:message "A parameter can only have one default value."
    ] ,
    [ sh:path ottr:modifier ;
      sh:node [ sh:in ( ottr:optional ottr:nonBlank ) ] ;
      sh:name "Parameter modifier" ;
      sh:message "A parameter can only have the modifiers ottr:optional or ottr:nonBlank."
    ] 
.

ottr:VariableShape a sh:NodeShape ;
  sh:targetObjectsOf ottr:variable ;
  sh:nodeKind sh:BlankNode ;
  sh:property
    [ sh:path [ sh:inversePath ottr:variable ] ;
      sh:maxCount 1 ;
      sh:name "Variable representation" ;
      sh:message "A blank node may represent at most one variable."
    ] ;
  sh:name "Variable" ;
  sh:message "A variable must be represented by a blank node which represents no other variable."
.

ottr:ModifierShape a sh:NodeShape ;
  sh:targetObjectsOf ottr:modifier ;
  sh:xone 
    ( 
      [ sh:path [ sh:inversePath ottr:modifier ] ;
        sh:node ottr:InstanceShape 
      ]
      [ sh:path [ sh:inversePath ottr:modifier ] ;
        sh:node ottr:ArgumentShape 
      ]
      [ sh:path [ sh:inversePath ottr:modifier ] ;
        sh:node ottr:ParameterShape 
      ]
) .

ex:signature a ottr:Signature ;
  ottr:parameters ( 
    [ ottr:variable _:class ]
    [ ottr:variable _:property; ottr:modifier ottr:nonBlank ]
    [ ottr:variable _:string; ottr:modifier ottr:optional ]
  ) .

Parameter types are specified using an RDF list, where the last element in the list must be a basic type, the least upper bound type ottr:LUB can only occur as the next to last element (which may also be the first), and the list types identifiers rdf:List or ottr:NEList can not be the last element.

This RDF list (written in RDF Turtle syntax): ( rdf:List ottr:NEList ottt:LUB xsd:string ) represents the type List<NEList<LUB<xsd:string>>>. If the type of a ottr:Parameter is a basic type, it can be specified using (just) the type IRI (and not a singleton RDF list containing the type).

ottr:TypeListShape a sh:NodeShape ;
   sh:targetObjectsOf ottr:type ;
   sh:xone 
     (
       [ sh:node shsh:ListShape ;
         sh:property 
           [ sh:path ( [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
             sh:node ottr:TypeShape ;
             sh:minCount 1;
           ] ;
         sh:name "Complex parameter type" ;
         sh:message """Unrecognised complex type. A type is specified either as a list of types, 
         where the last item in the list must be a basic type, the second last can be a 'least upper bound' 
         type, and the types preceeding it can be list types."""
       ] 
       [ sh:node ottr:BasicTypeShape ;
         sh:name "Basic parameter type" ;
         sh:message "Unrecognised basic type. A type is specified either as an RDF list of types or a single basic type."
       ]
     )
.

# A list of xsd:int-s -- List<xsd:int>
(rdf:List xsd:int) 

# A non-empty list of xsd:int-s -- NEList<xsd:int>: 
(ottr:NEList xsd:int) 

# A list of list of owl:Class-es -- List<List<owl:Class>>:
(rdf:List rdf:List owl:Class) 

# The least upper bound of owl:ObjectProperty -- LUB<owl:ObjectProperty>:
(ottr:LUB owl:ObjectProperty)

# A list of least upper bounds of owl:ObjectProperty -- List<LUB<owl:ObjectProperty>>:
(rdf:List ottr:LUB owl:ObjectProperty)

The class ottr:Template is a subclass of ottr:Signature. A ottr:Template must therefore also follow the shape specification for ottr:Signature-s.

A ottr:Template may have a ottr:patten which is composed by any number of ottr:Instance-s.

ottr:TemplateShape a sh:NodeShape ;
  sh:targetClass ottr:Template ;
  sh:targetSubjectsOf ottr:pattern ;
  sh:class ottr:Template .

ex:template a ottr:Template ;
  ottr:parameters (
    [ ottr:variable _:thing ]
    [ ottr:variable _:label;   ottr:type xsd:string; ottr:modifier ottr:optional ]
    [ ottr:variable _:comment; ottr:type xsd:string; ottr:modifier ottr:optional ] 
  ) ;
  ottr:pattern 
    [ ottr:of ottr:Triple; ottr:values ( _:thing rdfs:label _:label ) ] ,
    [ ottr:of ottr:Triple; ottr:values ( _:thing rdfs:comment _:comment ) ] 
  .

The class ottr:BaseTemplate is a subclass of ottr:Signature. A ottr:BaseTemplate must therefore also follow the shape specification for ottr:Signature-s.

A ottr:BaseTemplate cannot have a ottr:pattern.

ottr:BaseTemplateShape a sh:NodeShape ;
  sh:targetClass ottr:BaseTemplate ;
  sh:class ottr:BaseTemplate ;
  sh:property 
    [ sh:path ottr:pattern ;
      sh:maxCount 0 ;
      sh:message "A base template cannot have a pattern."
    ] .

ottr:Triple a ottr:BaseTemplate ;
  ottr:parameters (
    [ ottr:type ottr:IRI; ottr:variable _:subject ]
    [ ottr:type ottr:IRI; ottr:variable _:predicate; ottr:modifier ottr:nonBlank ]
    [ ottr:type rdfs:Resource; ottr:variable _:object ] ) .

Records when a term entered the vocabulary and when it last changed. Both arguments are version IRIs, not strings, so that the release they name can be dereferenced.

o-wottr:Version a ottr:Template ;
  ottr:parameters (
    [ ottr:variable _:IRI; ottr:type ottr:IRI ]
    [ ottr:variable _:introduced; ottr:type ottr:IRI; ottr:modifier ottr:optional ]
    [ ottr:variable _:changed; ottr:type ottr:IRI; ottr:modifier ottr:optional ]
    [ ottr:variable _:deprecated; ottr:type ottr:IRI; ottr:modifier ottr:optional ]
  ) ;
  ottr:pattern
    [ ottr:of ottr:Triple; ottr:values ( _:IRI ottr:introducedIn _:introduced ) ] ,
    [ ottr:of ottr:Triple; ottr:values ( _:IRI ottr:changedIn _:changed ) ] ,
    [ ottr:of o-wottr:Deprecated; ottr:values ( _:IRI _:deprecated ) ] .

_:version is deliberately not optional, so that an instance carrying ottr:none expands to nothing at all. That is what ties the two triples together: a term either has both a deprecation version and owl:deprecated true, or neither. Tools that do not know ottr:deprecatedIn read the second; nothing has to remember to write it.

o-wottr:Deprecated a ottr:Template ;
  ottr:parameters (
    [ ottr:variable _:IRI; ottr:type ottr:IRI ]
    [ ottr:variable _:version; ottr:type ottr:IRI ]
  ) ;
  ottr:pattern
    [ ottr:of ottr:Triple; ottr:values ( _:IRI ottr:deprecatedIn _:version ) ] ,
    [ ottr:of ottr:Triple; ottr:values ( _:IRI owl:deprecated true ) ] .

"Basic" tests are not specific to the wOTTR specification.

# INCORRECT: rdf:asdf in an incorrect IRI.
[] rdf:asdf [] .

# INCORRECT: rdfs:asdf in an incorrect IRI.
[] rdfs:asdf [] .

# INCORRECT: owl:asdf in an incorrect IRI.
[] owl:asdf [] .

# INCORRECT: sh:asdf in an incorrect IRI.
[] sh:asdf [] .

# INCORRECT: ottr:asdf in an incorrect IRI.
[] ottr:asdf [] .

# INCORRECT: An RDF list cannot have two firsts.
[ rdf:first 1 ;
  rdf:first 2 ;
  rdf:rest rdf:nil ]

# INCORRECT: An RDF list cannot have two rests.
[ rdf:first 1 ;
  rdf:rest 2, rdf:nil ]

# INCORRECT: An RDF list cannot be a loop.
_:A rdf:first 1 ;
    rdf:rest [ rdf:first 2 ; rdf:rest _:A ] .