Introduction

Work on units and scales in data models and in XML has been going on for years without reaching a conclusion, so if we are going to do something which sticks we have to be very formal.

Units and scales are mathematical things, so MathML is a good starting point.
Unit quantities

Metre (a "quantity" - VIM term 1,1) is a unit within length (a "quantities of the same kind" - VIM term 1.2). So is Kilometre. Expressing this in RDF-XML, we have:

<vim:Quantity rdf:about="&unit;Metre">
 <rdf:type rdf:resource="&iso31;Length"/>
</vim:Quantity>

<vim:Quantity rdf:about="&unit;Kilometre">
 <rdf:type rdf:resource="&iso31;Length"/>
</vim:Quantity>

<owl:Class rdf:about="&vim;Quantity"/>

<owl:Class rdf:about="&iso31;Length">
 <rdf:type rdf:resource="&vim;Quantities_of_the_same_kind"/>
</owl:Class>

<owl:Class rdf:about="&vim;Quantities_of_the_same_kind">
  <rdfs:subClassOf rdf:resource="&owl;Class"/>
</owl:Class>

or in RDF-N3:

unit:Metre       a   vim:Quantity ;
                 a   iso31:Length .

unit:Kilometre   a   vim:Quantity ;
                 a   iso31:Length .

vim:Quantity     a   owl:Class .

iso31:Length     a   owl:Class ;
                 a   vim:Quantities_of_the_same_kind .

vim:Quantities_of_the_same_kind
                 rdfs:subClassOf owl:Class .

NOTE 1 The statements shown in red are inconvenent, and may be ignored or kept in a separate ontology.

We can say:

kilometre = 1000 · metre

where · is a binary operator such that (real, length) ? length.

This is easily expressed in MathML, as follows:

<math xmlns="http://www.w3.org/1998/Math/MathML">
 <apply>
  <eq/>
  <ci>kilometre</ci>
  <apply>
   <times/>
   <cn>1000</cn>
   <ci>metre</ci>
  </apply>
 </apply>
</math>

NOTE 2 MathML is imprecise about the times operator (· in the previous expression), but then so are most people most of the time.

The MathML symbols can be identified by URIs as follows:

<math xmlns="http://www.w3.org/1998/Math/MathML">
 <apply>
  <eq/>
  <ci definitionURL="&unit;kilometre"/>
  <apply>
   <times/>
   <cn>1000</cn>
   <ci definitionURL="&unit;metre"/>
  </apply>
 </apply>
</math>

In this MathML, the number 1000 is a literal, but we could name the number "kilo", and reference it as <ci definitionURL="&siPrefix:kilo"/>.

So do we embed the MathML definition in the OWL as follows:

<vim:Quantity rdf:about="&unit;Kilometre">
 <rdf:type rdf:resource="&iso31;Length"/>
 <rdfs:isDefinedBy rdf:parseType="Literal" xmlns="http://www.w3.org/1998/Math/MathML">
  <apply>
   <eq/>
   <ci definitionURL="&unit;kilometre"/>
   <apply>
    <times/>
    <ci definitionURL="&siPrefix;kilo"/>
    <ci definitionURL="&unit;metre"/>
   </apply>
  </apply>
 </rdfs:isDefinedBy>
</vim:Quantity>

or do we invent an RDF version of MathML?
Units and scales

A metre is a length. There is also a metre-scale which enables any length to be represented by a real number. Hence we have:

metre-scale: length ? real

which is defined such that:

l = metre-scale(l) · metre

for each length l.

Many measurements rely upon scales which are not derived simply from units. The International Temperature Scale of 1990 is not defined with respect to a unit.

A metre-scale is particularly convenient for representation.

EXAMPLE MyShip has a waterline length of 12 metres. This can be recorded using a scale in RDF-XML as:

<nautical:Ship rdf:about="#MyShip">
 <nautical:waterlineLength>
  <iso31:Length>
   <scale:metre>12</scale:metre>
  </iso31:Length>
 </nautical:waterlineLength>
</nautical:Ship>

or in RDF-N3 as:

:MyShip nautical:waterlineLength [ scale:metre 12 ] .

To record the relationship between the metre and metre-scale formally requires lambda calculus. We say:

? (l, (l / metre)) = metre-scale

where "/" is the inverse of the · operator defined above.

This can be expressed in MathML as follows:

<declare type="function">
 <ci definitionURL="&scale;metre"/>
 <lambda>
  <bvar>
   <ci>l</ci>
  </bvar>
  <apply>
   <divide/>
   <ci>l</ci>
   <ci definitionURL="&unit;metre"/>
  </apply>
 </lambda>
</declare>

It is also possible to specify that the domain of metre-scale is length and that the range (or co-domain) is the reals in MatML as follows:

<apply>
 <eq/>
 <apply>
  <domain/>
  <ci definitionURL="&scale;metre"/>
 </apply>
 <ci definitionURL="&iso31;length"/>
</apply>

<apply>
 <eq/>
 <apply>
  <codomain/>
  <ci definitionURL="&scale;metre"/>
 </apply>
 <reals/>
</apply>

The MathML can be embedded in the OWL definition of metre-scale as follows:

<owl:DatatypeProperty rdf:about="&scale;metre">
 <rdfs:domain rdf:resource="&iso31;Length"/>
 <rdfs:isDefinedBy rdf:parseType="Literal" xmlns="http://www.w3.org/1998/Math/MathML">
  <declare type="function">
   <ci definitionURL="&scale;metre"/>
   <lambda>
    <bvar>
     <ci>l</ci>
    </bvar>
    <apply>
     <divide/>
     <ci>l</ci>
     <ci definitionURL="&unit;metre"/>
    </apply>
   </lambda>
  </declare>
 </rdfs:isDefinedBy>
</owl:DatatypeProperty>

NOTE 1 There is no need to embed the MathML specification of the domain, because this can be directly specified by RDF.

The MathML range (or co-domain) is reals. This is more correct, because the reals are not literals. If we wanted to be pedantic, we would have:

<owl:FunctionalProperty rdf:about="&scale;metre">
 <rdfs:domain rdf:resource="&iso31;Length"/>
 <rdfs:range rdf:resource="&maths;Reals"/>
</owl:FunctionalProperty/>

<owl:DatatypeProperty rdf:about="&maths;decimal">
 <rdfs:domain rdf:resource="&maths;Reals"/>
</owl:DatatypeProperty/>

so that the instantiation of the simple example above becomes:

<nautical:Ship rdf:about="#MyShip">
 <nautical:waterlineLength>
  <iso31:Length>
   <scale:metre>
    <maths:Reals>
     <maths:decimal>12</maths:decimal>
    </maths:Reals>
   </scale:metre>
  </iso31:Length>
 </nautical:waterlineLength>
</nautical:Ship>

or in RDF-N3:

:MyShip nautical:waterlineLength [ scale:metre [ maths:decimal 12 ] ] .

Do we want to compel people to be this pedantic? Do we want to give people the option to be this pedantic?