Re: An approach to describing the relationships between units-of-measure

["Roger L. Costello" <costello@mitre.org>]

Hi Folks,

Thanks for the excellent discussions.  Below I summarize
three of the issues that were raised.  Comments welcome.
/Roger
---------------------------------------------------------------

ISSUE #1: Incorporate Tolerance into Set Definition

The discussions noted that this set definition:

    {(k, m) | k = m * 1.62}

is not particularly useful since, due to precision 
differences, many (k, m) pairs would be rejected that 
we really want considered to be contained in the set.

Tolerance needs to be directly incorporated into the set 
definition:

    {(k, m, t) | k - (m * 1.62) <= t}

"The set of all k (kilometer), m (mile), and t (tolerance) 
triples such that k minus m times 1.62 is less than or equal 
to t."

In other words, this is the set of kilometer/mile pairs 
that is within a certain tolerance.

Examples:

If tolerance = 2 then

    (6340, 3914) is in the set.
    (6340, 3915) is NOT in the set.
    (6341, 3914) is in the set.
    (6339, 3914) is in the set.

The narrower the value for tolerance, the smaller the set.
The broader the value for tolerance, the bigger the set.

This ability to define "fuzzy sets" is very powerful.

Here is how the Distance class should be specified:

<Class id="Distance">
    <equivalentInstances>
        {(k, m, t) | k - (m * 1.62) <= t}
    </equivalentInstances>
</Class>

ISSUE #2: Identify which UOMs are being Related

Note: UOMs = unit-of-measures

The discussions also pointed out that there needs to be a way 
of identifying the units-of-measure that the set is relating.

I would like to propose that the UOMs being related 
be identified in the set definition:

{(k:kilometer, m:mile, t:tolerance) | k - (m * 1.62) <= t}

"The set of all k (of type kilometer), m (of type mile), 
and t (of type tolerance) triples such that ..."

MathML has a rather nice way of associating a symbol
with a type.

MathML has an attribute called definitionURL.  Here is 
how it is defined:

definitionURL: specifies a URL that contains information on
the semantics of the symbol.

definitionURL can be used to associate "k" with a standard 
definition of kilometer, and "m" with a standard definition 
of mile.

Here is how it can be used in the set definition:

<Class id="Distance">
    <equivalentInstances>
        <!-- S = {(k:kilometer, m:mile, t:tolerance) | k - (m * 1.62) <=
t}-->
        <math>
            <declare type="set">
                <ci>S<ci>
                <set>
                    <bvar>
                         <ci
definitionURL="http://www.nist.org#kilometer";>k</ci>
                    </bvar>
                    <bvar>
                         <ci
definitionURL="http://www.nist.org#mile";>m</ci>
                    </bvar>
                    <bvar>
                         <ci
definitionURL="http://www.nist.org#tolerance";>tolerance</ci>
                    </bvar>
                    <condition>
                        ...
                    </condition>
                    <list><ci>k</ci><ci>m</ci><ci>tolerance</ci></list>
                </set>
            </declare>
        </math>
    </equivalentInstances>
</Class>

Through the use of definitionURL we can unambiguously
state:

    "This <equivalentInstances> element contains the set
     definition for equivalent kilometer/mile pairs."

What do you think about using MathML's definitionURL
for identifying which UOMs are being related?  Do you
think that it is too "implicit"?  Perhaps it needs to 
be stated more explicitly?

ISSUE #3: Reusing Set Definitions

Rather than burying set definitions within a class,
it would be beneficial to make the set definitions
standalone so that they can be reused, e.g.,

kilometer-to-mile = {(k:kilometer, m:mile, t:tolerance) | k - (m * 1.62)
<= t}

<Class id="Distance">
    <equivalentInstances resource="#kilometer-to-mile">
</Class>

The set is defined and associated with a name 
(e.g., kilometer-to-mile).  Then, a class simply 
references the set name.

Thoughts on this?  /Roger