rOTTR: Adapting Reasonable Ontology Templates to RDF

top
examples: show / hide

Adapting Reasonable Ontology Templates to RDF (rOTTR)

Adaptation of the OTTR abstract model to RDF: types, terms, modifiers, expansion and base templates.

Version: 0.2.3
Previous version: rOTTR 0.2.2
Depends on: mOTTR 0.1.2
Published: Tue Sep 22 19:55:39 2026
Authors: Leif Harald Karlsen
Martin G. Skjæveland
Issues: https://gitlab.com/ottr/language/rOTTR/issues

Front matter

Abstract

Adaptation of the OTTR abstract model to RDF, including the representation of types and terms, blank-node handling, and base templates.

Documents

This specification consists of the following files:

./index.html: This document.
./types.owl.ttl: OWL ontology of all basic and complex types (no pun types).
./puntypes.owl.ttl: OWL ontology of the pun type extension to basic and complex types.
./types.shacl.ttl: SHACL shape of all permissible types.
./tpl: The base templates this specification defines, one file each. o-rottr: resolves under this directory, so it must be published.

Versions and dependencies

The table below sets the version of this specification and lists dependencies to other OTTR specifications.

Specification	Version	Previous	Note
rOTTR	0.2.3	0.2.2	This specification.
mOTTR	0.1.2		Concepts and abstract model.

Every IRI this specification defines is versioned - with one exception: the ontology IRI is deliberately version-independent, using owl:versionIRI to specify the version of the ontology.

Document conventions

Notation

This is a defined term.

This is a mention of a defined term. Terms may be defined in depending specifications.

The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, NOT RECOMMENDED, MAY and OPTIONAL are to be interpreted as described in BCP 14 [2] [3] when, and only when, they appear in all capitals.

Prefixes

In this document, we assume the following prefix declarations. The prefixes that carry a version are generated from No description for this link; the rest are fixed.

@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl:   <http://www.w3.org/2002/07/owl#>.
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
@prefix skos:  <http://www.w3.org/2004/02/skos/core#> .
@prefix sh:    <http://www.w3.org/ns/shacl#> .

@prefix ottr:  <http://ns.ottr.xyz/0.4/> .

@prefix t-pnd: <http://types.ottr.xyz/std/0.1/PunnedTypes#> .

@prefix rottr-doc: <http://spec.ottr.xyz/rOTTR/> .
@prefix rottr-ver: <http://spec.ottr.xyz/rOTTR/0.2.3/> .
@prefix o-rottr: <http://spec.ottr.xyz/rOTTR/0.2.3/tpl/> .
@prefix mottr-ver: <http://spec.ottr.xyz/mOTTR/0.1.2/> .
@prefix o-mottr: <http://spec.ottr.xyz/mOTTR/0.1.2/tpl/> .

Changelog

0.2.2

Noted that a blank node without the rdf:first~/~rdf:rest structure is not a list, and so cannot carry a list expander.
Variables are no longer RDF terms. A serialisation language now MUST specify how it represents a variable; the substitution B of expansion is correspondingly simplified to replace every blank node.
Removed the requirement that a variable of type List<T> or NEList<T> be represented by a blank node, a holdover from when variables were themselves RDF terms; it is contradicted by stOTTR's uniform variable syntax and was never more than a recommendation in wOTTR.
A blank node in a parameter's default value is now freshened with those of the pattern, by one substitution, so an instance falling back on the default gets its own blank node and the default and the pattern agree where they name the same one. Annotation instances are stated not to be freshened.
Defined blank node scope and required every OTTR serialisation language to state its own, with the template definition as the lower bound. Made explicit that expansion does not replace blank nodes occurring in arguments.
Ontologies now carry a version-independent owl:ontologyIRI with owl:versionIRI beside it, and the ontology IRI carries the file extension so it agrees with owl:imports targets.
Corrected the specification's base IRI: rottr/0.2/ was neither the published path (rOTTR/) nor a resolvable version.

1. Introduction

This specification adapts the OTTR abstract model, defined in the mOTTR specification [1], to RDF. It specifies how OTTR types and terms are represented in RDF, resolves peculiarities that arise from RDF's blank nodes, and defines the base template ottr:Triple.

This specification does not define a serialisation format for OTTR in RDF, but sets requirements that any such serialisation must satisfy.

2. Types

A type is either a basic type, a list type (List<> and NEList<> (non-empty list)) or a LUB-type. These are presented below.

2.1. Basic types

Table 1 lists all permissible basic types and specifies the subtype relationship using the inverse relation supertype; Figure 1 illustrates the hierarchy. All basic types except ottr:IRI, ottr:string and ottr:Bot are common types or classes taken from the RDF, RDFS, OWL and XSD standards. ottr:IRI is the class of all rdfs:Resource's which are not rdfs:Literal's. ottr:string represents all strings with or without language tag. ottr:Bot represents the type Bot, while Top is represented by the IRI rdfs:Resource.

Table 1: Basic types
Type	Supertype	Description
`rdfs:Resource`		'All things described by RDF are called resources, and are instances of the class rdfs:Resource'
`ottr:Bot`
`ottr:IRI`	`rdfs:Resource`	'An IRI (Internationalized Resource Identifier) within an RDF graph is a Unicode string that conforms to the syntax defined in RFC 3987.'
`owl:Class`	`ottr:IRI`	'Classes can be understood as sets of individuals.'
`owl:NamedIndividual`	`ottr:IRI`	'Individuals in the OWL 2 syntax represent actual objects from the domain.'
`rdfs:Datatype`	`ottr:IRI`	'Datatypes are entities that refer to sets of data values. Thus, datatypes are analogous to classes, the main difference being that the former contain data values such as strings and numbers, rather than individuals.'
`owl:ObjectProperty`	`ottr:IRI`	'Object properties connect pairs of individuals.'
`owl:DatatypeProperty`	`ottr:IRI`	'Data properties connect individuals with literals. In some knowledge representation systems, functional data properties are called attributes.'
`owl:AnnotationProperty`	`ottr:IRI`	'Annotation properties can be used to provide an annotation for an ontology, axiom, or an IRI.'
`rdfs:Literal`	`rdfs:Resource`	'The class rdfs:Literal is the class of literal values such as strings and integers'
`ottr:string`	`rdfs:Literal`	'Character string with or without language tag'
`rdf:langString`	`ottr:string`	'Character string with language tag'
`xsd:string`	`ottr:string`	'Character strings (but not all Unicode character strings)'
`xsd:normalizedString`	`xsd:string`	'Whitespace-normalized strings'
`xsd:token`	`xsd:normalizedString`	'Tokenized strings'
`xsd:language`	`xsd:token`	'Language tags per [BCP47]'
`xsd:Name`	`xsd:token`	'XML Names'
`xsd:NCName`	`xsd:Name`	'XML NCNames'
`xsd:NMTOKEN`	`xsd:Name`	'XML NMTOKENs'
`owl:real`	`rdfs:Literal`	'The set of all real numbers'
`owl:rational`	`owl:real`	'The set of all rational numbers'
`xsd:decimal`	`owl:rational`	'Arbitrary-precision decimal numbers'
`xsd:integer`	`xsd:decimal`	'Arbitrary-size integer numbers'
`xsd:long`	`xsd:integer`	'-9223372036854775808…+9223372036854775807 (64 bit)'
`xsd:int`	`xsd:long`	'-2147483648…+2147483647 (32 bit)'
`xsd:short`	`xsd:int`	'-32768…+32767 (16 bit)'
`xsd:byte`	`xsd:short`	'-128…+127 (8 bit)'
`xsd:nonNegativeInteger`	`xsd:integer`	'Integer numbers >=0'
`xsd:positiveInteger`	`xsd:nonNegativeInteger`	'Integer numbers >0'
`xsd:unsignedLong`	`xsd:positiveInteger`	'0…18446744073709551615 (64 bit)'
`xsd:unsignedInt`	`xsd:unsignedLong`	'0…4294967295 (32 bit)'
`xsd:unsignedShort`	`xsd:unsignedInt`	'0…65535 (16 bit)'
`xsd:unsignedByte`	`xsd:unsignedShort`	'0…255 (8 bit)'
`xsd:nonPositiveInteger`	`xsd:integer`	'Integer numbers =<0'
`xsd:negativeInteger`	`xsd:nonPositiveInteger`	'Integer numbers <0'
`xsd:double`	`rdfs:Literal`	'64-bit floating point numbers incl. +-Inf, +-0, NaN'
`xsd:float`	`rdfs:Literal`	'32-bit floating point numbers incl. +-Inf, +-0, NaN'
`xsd:date`	`rdfs:Literal`	'Dates (yyyy-mm-dd) with or without timezone'
`xsd:dateTime`	`rdfs:Literal`	'Date and time with or without timezone'
`xsd:dateTimeStamp`	`xsd:dateTime`	'Date and time with required timezone'
`xsd:time`	`rdfs:Literal`	'Times (hh:mm:ss.sss…) with or without timezone'
`xsd:gYear`	`rdfs:Literal`	'Gregorian calendar year'
`xsd:gMonth`	`rdfs:Literal`	'Gregorian calendar month'
`xsd:gDay`	`rdfs:Literal`	'Gregorian calendar day of the month'
`xsd:gYearMonth`	`rdfs:Literal`	'Gregorian calendar year and month'
`xsd:gMonthDay`	`rdfs:Literal`	'Gregorian calendar month and day'
`xsd:duration`	`rdfs:Literal`	'Duration of time'
`xsd:yearMonthDuration`	`xsd:duration`	'Duration of time (months and years only)'
`xsd:dayTimeDuration`	`xsd:duration`	'Duration of time (days, hours, minutes, seconds only)'
`xsd:hexBinary`	`rdfs:Literal`	'Hex-encoded binary data'
`xsd:base64Binary`	`rdfs:Literal`	'Base64-encoded binary data'
`xsd:boolean`	`rdfs:Literal`	'true, false'
`xsd:anyURI`	`rdfs:Literal`	'Absolute or relative URIs and IRIs'
`rdf:HTML`	`rdfs:Literal`	'HTML content'
`rdf:XMLLiteral`	`rdfs:Literal`	'XML content'

Figure 1: Hierarchy of basic types. Bot is not correctly related to the other types.

2.2. List and Least upper bound types

The list types List<> and NEList<> are denoted respectively by the IRI rdf:List and the IRI ottr:NEList. The LUB<> type is represented by the IRI ottr:LUB. These types are listed in Table 2.

Each OTTR serialisation language must introduce a means of representing complex types, such as NEList<LUB<String>>.

Table 2: Complex types
Type	Label	Description
`rdf:List`	'List<>'	'`rdf:List` represents the mOTTR list type List<>. The type contains all list terms.'
`ottr:NEList`	'NEList<>'	'`ottr:NEList` represents the mOTTR list type NEList<>. The type contains all non-empty list terms.'
`ottr:LUB`	'LUB<>'	'`ottr:LUB` represents the mOTTR list type LUB<> (least upper bound).'

2.3. Pun types

To support OWL 2 punning [1], which allows a term to have multiple types under some restrictions (see [1]), we provide an extension to the above type hierarchy that captures all the possible combinations of "pun types" from the OWL standard. These types and their supertypes are listed in Table 3.

Table 3: Pun types
Type	Supertype
`t-pnd:Punned-Class-NamedIndividual`	`owl:Class`	`owl:NamedIndividual`
`t-pnd:Punned-Class-ObjectProperty`	`owl:Class`	`owl:ObjectProperty`
`t-pnd:Punned-Class-DatatypeProperty`	`owl:Class`	`owl:DatatypeProperty`
`t-pnd:Punned-Class-AnnotationProperty`	`owl:Class`	`owl:AnnotationProperty`
`t-pnd:Punned-Datatype-NamedIndividual`	`rdfs:Datatype`	`owl:NamedIndividual`
`t-pnd:Punned-Datatype-ObjectProperty`	`rdfs:Datatype`	`owl:ObjectProperty`
`t-pnd:Punned-Datatype-DatatypeProperty`	`rdfs:Datatype`	`owl:DatatypeProperty`
`t-pnd:Punned-Datatype-AnnotationProperty`	`rdfs:Datatype`	`owl:AnnotationProperty`
`t-pnd:Punned-NamedIndividual-ObjectProperty`	`owl:NamedIndividual`	`owl:ObjectProperty`
`t-pnd:Punned-NamedIndividual-DatatypeProperty`	`owl:NamedIndividual`	`owl:DatatypeProperty`
`t-pnd:Punned-NamedIndividual-AnnotationProperty`	`owl:NamedIndividual`	`owl:AnnotationProperty`
`t-pnd:Punned-Class-NamedIndividual-ObjectProperty`	`owl:Class`	`owl:NamedIndividual`	`owl:ObjectProperty`
`t-pnd:Punned-Class-NamedIndividual-DatatypeProperty`	`owl:Class`	`owl:NamedIndividual`	`owl:DatatypeProperty`
`t-pnd:Punned-Class-NamedIndividual-AnnotationProperty`	`owl:Class`	`owl:NamedIndividual`	`owl:AnnotationProperty`
`t-pnd:Punned-Datatype-NamedIndividual-ObjectProperty`	`rdfs:Datatype`	`owl:NamedIndividual`	`owl:ObjectProperty`
`t-pnd:Punned-Datatype-NamedIndividual-DatatypeProperty`	`rdfs:Datatype`	`owl:NamedIndividual`	`owl:DatatypeProperty`
`t-pnd:Punned-Datatype-NamedIndividual-AnnotationProperty`	`rdfs:Datatype`	`owl:NamedIndividual`	`owl:AnnotationProperty`

3. Terms

The set of constants is the set of valid RDF terms [2], i.e., IRIs, literals with optional language tag or type, and blank nodes.

Variables are disjoint from constants [1], so no RDF term is a variable. An OTTR serialisation language MUST specify how it represents variables. It MAY use RDF terms to represent variables.

The set of constants also include RDF-lists, where an RDF-list is either the empty list, denoted by rdf:nil, or a resource which has exactly one rdf:first-related term denoting the first element of the list, and exactly one rdf:rest-related element which is either a list or rdf:nil, denoting the rest of the list. We require that lists are finite. Note that a blank node which is not a list has the type LUB< rdfs:Resource >, and can therefore not be the value of an argument with a list expander [1].

The name in a template signature is an IRI.

Constant terms have type accordingly:

a list has a type as described in the mOTTR specification [1];
a non-list blank node has type LUB< rdfs:Resource >;
an IRI has type LUB< ottr:IRI >;
a literal has type equal to its contained datatype (e.g. "3"^^xsd:int has type xsd:int) or xsd:string if no datatype is present.

An OTTR serialisation language must introduce a special constant none that represents a missing value (or no value); its type is ottr:Bot.

4. Blank node scope

Unlike IRIs and literals, a blank node is identified relative to the artefact it is written in: the same blank node label in two RDF documents denotes two different blank nodes [2]. An OTTR serialisation language must therefore state how far within its artefacts that identification reaches.

A blank node scope is an extent of an artefact written in an OTTR serialisation language such that

two occurrences of the same blank node label within one blank node scope denote the same blank node, and
occurrences of a blank node label in two different blank node scopes denote two different blank nodes, whether or not the labels are equal.

A serialisation language MAY in addition provide a syntax for minting fresh blank nodes. Each occurrence of such a syntax denotes a blank node distinct from every other blank node.

An OTTR serialisation language MUST define its blank node scopes, and MUST do so for every blank node that can occur in an artefact written in it, whether the blank node is written in the artefact or produced from data the artefact refers to.

A template definition MUST NOT be split across blank node scopes. Otherwise a pattern would not be able to use a blank node to relate two of its own instances.

Note that variables are not blank nodes, hence a blank node scope says nothing about them. A variable belongs to the signature declaring it [1] whatever the blank node scope of the RDF term representing it: two signatures within one blank node scope which represent a variable by the same blank node declare two different variables. A serialisation language MAY require the representation to be unambiguous within a scope.

5. Modifiers

In addition to the optional parameter modifier defined in the mOTTR specification [1], this specification introduces the modifier nonBlank. For a template dataset to be valid, we additionally require that for any instance I of a template T and every parameter p of T which is marked as nonBlank, I's argument to p must either be a constant which is not a blank node, or a variable whose parameter also has a nonBlank-modifier.

6. Expansion

When expanding a template T having blank nodes, fresh blank nodes must be generated for each template instance of T as follows.

Let B be a substitution replacing every blank node of T, this includes blank nodes in its pattern and those of the default values of its parameters, with a fresh blank node.

The induced substitution S of T and I [1] is now redefined using B as follows: set S := B, then for each argument a of I and its corresponding parameter p in T:

if a has value none and p has a default value d, then S := S ∪ { p / B*(*d) }
otherwise, S := S ∪ { p / a }

The result of the direct expansion of I is the set of instances resulting from applying the substitution S to the pattern of T.

B thus replaces the blank nodes of T only, and never blank nodes in the arguments of I. A blank node in a default value is T's own, so each instance that makes use of the default value gets a fresh blank node — the same one as that blank node's occurrences in the pattern, B being a single substitution. Blank nodes in annotation instances are not replaced: annotations are expanded once for the signature, not per instance [1].

7. Base template

This specification specifies a single base template ottr:Triple which represents an RDF triple. The template has three parameters:

?subject, type: ottr:IRI
?predicate, type: ottr:IRI, modifier: nonBlank
?object, type: rdfs:Resource

8. Appendix

8.1. From tables to ontologies with templates

We eat dogfood and generate the type ontologies from the table 1 and table 2 by translating the tables straight-forwardly to template instances of custom-built templates. The templates and instances are given below.

8.1.1. Templates

Type template

o-rottr:Type a ottr:Template ;
  ottr:parameters (
    [ ottr:variable _:IRI; ottr:type owl:Class ]
    [ ottr:variable _:label; ottr:modifier ottr:optional ]
    [ ottr:variable _:super; ottr:type owl:Class; ottr:modifier ottr:optional ]
    [ ottr:variable _:description; ottr:type xsd:string; ottr:modifier ottr:optional ] 
  ) ;
  ottr:pattern 
    [ ottr:of ottr:Triple ; ottr:values ( _:IRI rdfs:label _:label ) ] ,
    [ ottr:of ottr:Triple ; ottr:values ( _:IRI ottr:subTypeOf _:super ) ] ,
    [ ottr:of ottr:Triple ; ottr:values ( _:IRI skos:definition _:description ) ] ,
    [ ottr:of ottr:Triple ; ottr:values ( ottr:Bot ottr:subTypeOf _:IRI ) ] .

PunType template

o-rottr:PunType a ottr:Template ;
  ottr:parameters (
    [ ottr:variable _:IRI; ottr:type owl:Class ]
    [ ottr:variable _:super1; ottr:type owl:Class ]
    [ ottr:variable _:super2; ottr:type owl:Class; ottr:modifier ottr:optional ]
    [ ottr:variable _:super3; ottr:type owl:Class; ottr:modifier ottr:optional ]
  ) ;
  ottr:pattern
   [ ottr:of ottr:Triple ; ottr:values ( _:IRI ottr:subTypeOf _:super1 ) ] ,
   [ ottr:of ottr:Triple ; ottr:values ( _:IRI ottr:subTypeOf _:super2 ) ] ,
   [ ottr:of ottr:Triple ; ottr:values ( _:IRI ottr:subTypeOf _:super3 ) ] ,
   [ ottr:of ottr:Triple ; ottr:values ( ottr:Bot ottr:subTypeOf _:IRI ) ] .

8.1.2. Instances

Type instances

@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl:   <http://www.w3.org/2002/07/owl#>.
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
@prefix skos:  <http://www.w3.org/2004/02/skos/core#> .
@prefix sh:    <http://www.w3.org/ns/shacl#> .

@prefix ottr:  <http://ns.ottr.xyz/0.4/> .

@prefix t-pnd: <http://types.ottr.xyz/std/0.1/PunnedTypes#> .

@prefix rottr-doc: <http://spec.ottr.xyz/rOTTR/> .
@prefix rottr-ver: <http://spec.ottr.xyz/rOTTR/0.2.3/> .
@prefix o-rottr: <http://spec.ottr.xyz/rOTTR/0.2.3/tpl/> .
@prefix mottr-ver: <http://spec.ottr.xyz/mOTTR/0.1.2/> .
@prefix o-mottr: <http://spec.ottr.xyz/mOTTR/0.1.2/tpl/> .
rottr-doc:types.owl.ttl a owl:Ontology
  ; owl:versionIRI rottr-ver:types.owl.ttl
  ; owl:versionInfo "0.2.3"
  ; owl:priorVersion <http://spec.ottr.xyz/rOTTR/0.2.2/types.owl.ttl>
  ; rdfs:label "OTTR types"
  .

ottr:Type a owl:Class .

ottr:subTypeOf a owl:ObjectProperty , owl:TransitiveProperty , owl:ReflexiveProperty ;
  rdfs:domain ottr:Type ;
  rdfs:range ottr:Type .

[ ottr:of o-rottr:Type ; ottr:values ( rdfs:Resource ottr:none ottr:none 'All things described by RDF are called resources, and are instances of the class rdfs:Resource' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( ottr:Bot ottr:none ottr:none ottr:none ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( ottr:IRI ottr:none rdfs:Resource 'An IRI (Internationalized Resource Identifier) within an RDF graph is a Unicode string that conforms to the syntax defined in RFC 3987.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:Class ottr:none ottr:IRI 'Classes can be understood as sets of individuals.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:NamedIndividual ottr:none ottr:IRI 'Individuals in the OWL 2 syntax represent actual objects from the domain.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( rdfs:Datatype ottr:none ottr:IRI 'Datatypes are entities that refer to sets of data values. Thus, datatypes are analogous to classes, the main difference being that the former contain data values such as strings and numbers, rather than individuals.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:ObjectProperty ottr:none ottr:IRI 'Object properties connect pairs of individuals.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:DatatypeProperty ottr:none ottr:IRI 'Data properties connect individuals with literals. In some knowledge representation systems, functional data properties are called attributes.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:AnnotationProperty ottr:none ottr:IRI 'Annotation properties can be used to provide an annotation for an ontology, axiom, or an IRI.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( rdfs:Literal ottr:none rdfs:Resource 'The class rdfs:Literal is the class of literal values such as strings and integers' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( ottr:string ottr:none rdfs:Literal 'Character string with or without language tag' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( rdf:langString ottr:none ottr:string 'Character string with language tag' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:string ottr:none ottr:string 'Character strings (but not all Unicode character strings)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:normalizedString ottr:none xsd:string 'Whitespace-normalized strings' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:token ottr:none xsd:normalizedString 'Tokenized strings' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:language ottr:none xsd:token 'Language tags per [BCP47]' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:Name ottr:none xsd:token 'XML Names' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:NCName ottr:none xsd:Name 'XML NCNames' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:NMTOKEN ottr:none xsd:Name 'XML NMTOKENs' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:real ottr:none rdfs:Literal 'The set of all real numbers' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( owl:rational ottr:none owl:real 'The set of all rational numbers' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:decimal ottr:none owl:rational 'Arbitrary-precision decimal numbers' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:integer ottr:none xsd:decimal 'Arbitrary-size integer numbers' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:long ottr:none xsd:integer '-9223372036854775808...+9223372036854775807 (64 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:int ottr:none xsd:long '-2147483648...+2147483647 (32 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:short ottr:none xsd:int '-32768...+32767 (16 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:byte ottr:none xsd:short '-128...+127 (8 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:nonNegativeInteger ottr:none xsd:integer 'Integer numbers >=0' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:positiveInteger ottr:none xsd:nonNegativeInteger 'Integer numbers >0' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:unsignedLong ottr:none xsd:positiveInteger '0...18446744073709551615 (64 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:unsignedInt ottr:none xsd:unsignedLong '0...4294967295 (32 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:unsignedShort ottr:none xsd:unsignedInt '0...65535 (16 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:unsignedByte ottr:none xsd:unsignedShort '0...255 (8 bit)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:nonPositiveInteger ottr:none xsd:integer 'Integer numbers =<0' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:negativeInteger ottr:none xsd:nonPositiveInteger 'Integer numbers <0' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:double ottr:none rdfs:Literal '64-bit floating point numbers incl. +-Inf, +-0, NaN' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:float ottr:none rdfs:Literal '32-bit floating point numbers incl. +-Inf, +-0, NaN' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:date ottr:none rdfs:Literal 'Dates (yyyy-mm-dd) with or without timezone' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:dateTime ottr:none rdfs:Literal 'Date and time with or without timezone' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:dateTimeStamp ottr:none xsd:dateTime 'Date and time with required timezone' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:time ottr:none rdfs:Literal 'Times (hh:mm:ss.sss...) with or without timezone' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:gYear ottr:none rdfs:Literal 'Gregorian calendar year' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:gMonth ottr:none rdfs:Literal 'Gregorian calendar month' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:gDay ottr:none rdfs:Literal 'Gregorian calendar day of the month' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:gYearMonth ottr:none rdfs:Literal 'Gregorian calendar year and month' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:gMonthDay ottr:none rdfs:Literal 'Gregorian calendar month and day' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:duration ottr:none rdfs:Literal 'Duration of time' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:yearMonthDuration ottr:none xsd:duration 'Duration of time (months and years only)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:dayTimeDuration ottr:none xsd:duration 'Duration of time (days, hours, minutes, seconds only)' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:hexBinary ottr:none rdfs:Literal 'Hex-encoded binary data' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:base64Binary ottr:none rdfs:Literal 'Base64-encoded binary data' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:boolean ottr:none rdfs:Literal 'true, false' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( xsd:anyURI ottr:none rdfs:Literal 'Absolute or relative URIs and IRIs' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( rdf:HTML ottr:none rdfs:Literal 'HTML content' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( rdf:XMLLiteral ottr:none rdfs:Literal 'XML content' ) ] .


[ ottr:of o-rottr:Type ; ottr:values ( rdf:List 'List<>' ottr:none 'rdf:List represents the mOTTR list type *List<>*. The type contains all list terms.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( ottr:NEList 'NEList<>' ottr:none 'ottr:NEList represents the mOTTR list type *NEList<>*. The type contains all non-empty list terms.' ) ] .
[ ottr:of o-rottr:Type ; ottr:values ( ottr:LUB 'LUB<>' ottr:none 'ottr:LUB represents the mOTTR list type *LUB<>* (least upper bound).' ) ] .

PunType instances

@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl:   <http://www.w3.org/2002/07/owl#>.
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
@prefix skos:  <http://www.w3.org/2004/02/skos/core#> .
@prefix sh:    <http://www.w3.org/ns/shacl#> .

@prefix ottr:  <http://ns.ottr.xyz/0.4/> .

@prefix t-pnd: <http://types.ottr.xyz/std/0.1/PunnedTypes#> .

@prefix rottr-doc: <http://spec.ottr.xyz/rOTTR/> .
@prefix rottr-ver: <http://spec.ottr.xyz/rOTTR/0.2.3/> .
@prefix o-rottr: <http://spec.ottr.xyz/rOTTR/0.2.3/tpl/> .
@prefix mottr-ver: <http://spec.ottr.xyz/mOTTR/0.1.2/> .
@prefix o-mottr: <http://spec.ottr.xyz/mOTTR/0.1.2/tpl/> .
rottr-doc:puntypes.owl.ttl a owl:Ontology
  ; owl:versionIRI rottr-ver:puntypes.owl.ttl
  ; owl:versionInfo "0.2.3"
  ; owl:priorVersion <http://spec.ottr.xyz/rOTTR/0.2.2/puntypes.owl.ttl>
  ; rdfs:label "OTTR pun types"
  ; owl:imports rottr-ver:types.owl.ttl
  .

[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Class-ObjectProperty owl:Class owl:ObjectProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Class-DatatypeProperty owl:Class owl:DatatypeProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Class-AnnotationProperty owl:Class owl:AnnotationProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-NamedIndividual rdfs:Datatype owl:NamedIndividual ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-ObjectProperty rdfs:Datatype owl:ObjectProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-DatatypeProperty rdfs:Datatype owl:DatatypeProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-AnnotationProperty rdfs:Datatype owl:AnnotationProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-NamedIndividual-ObjectProperty owl:NamedIndividual owl:ObjectProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-NamedIndividual-DatatypeProperty owl:NamedIndividual owl:DatatypeProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-NamedIndividual-AnnotationProperty owl:NamedIndividual owl:AnnotationProperty ottr:none ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Class-NamedIndividual-ObjectProperty owl:Class owl:NamedIndividual owl:ObjectProperty ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Class-NamedIndividual-DatatypeProperty owl:Class owl:NamedIndividual owl:DatatypeProperty ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Class-NamedIndividual-AnnotationProperty owl:Class owl:NamedIndividual owl:AnnotationProperty ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-NamedIndividual-ObjectProperty rdfs:Datatype owl:NamedIndividual owl:ObjectProperty ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-NamedIndividual-DatatypeProperty rdfs:Datatype owl:NamedIndividual owl:DatatypeProperty ) ] .
[ ottr:of o-rottr:PunType ; ottr:values ( t-pnd:Punned-Datatype-NamedIndividual-AnnotationProperty rdfs:Datatype owl:NamedIndividual owl:AnnotationProperty ) ] .

9. References

OWL 2 Web Ontology Language New Features and Rationale (Second Edition): https://www.w3.org/TR/owl2-new-features
RDF Graphs: https://www.w3.org/TR/rdf11-concepts/#section-rdf-graph

mOTTR 0.1.2: Concepts and abstract model.: http://spec.ottr.xyz/mOTTR/0.1.2/
RFC 2119: Key words for use in RFCs to Indicate Requirement Levels: https://www.rfc-editor.org/rfc/rfc2119
RFC 8174: Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words: https://www.rfc-editor.org/rfc/rfc8174