John Graybeal wrote: (01)
> +1 for stepping up and for the very nice list of actions. (Similar to
> what we're doing for a device ontology, over there in W3C world.) (02)
Thanks. And I'm not surprised. (03)
> Comment:
> - I think you skipped over a step in which the side-by-side ontology
> models are compared for value/relevance/suitability, and some process is
> followed to integrate the conceptual models into one. (Since it isn't
> enough to just select the applicable concepts and 'load them in'.) Or
> do you plan to consider the model only after you have the 'big pile of
> concepts'? It might be helpful, in the latter case, to have someone
> working "in the meantime" on articulating the overlaps and differences
> in the source models, so that the alternatives can be readily compared
> by the group, and the rationale(s) for choosing one approach over
> another can be discussed. (04)
Good point. (05)
> Suggestions, for what they are worth:
> - Google docs spreadsheet would be a reasonably optimal collaborative
> form for documenting the "table of all the distinct UoM concepts".
> Reasons why: Fast editing and import of content, familiar interface,
> real-time collaboration, spreadsheet tools, everyone can see but editors
> can be limited as needed, tables hard to do in wikis. (Reasons why not:
> Not part of the same wiki. Some don't like/don't use Google.) An
> alternative could be a vocabulary repository together with a term
> mapping tool....
> - I was just exposed to CMAP Ontology Editor (COE), and I really enjoyed
> its "thoughtfully informal" graphical presentation of ontologies. Just
> as a suggestion to add to the pile of candidates. (06)
Useful suggestions. (07)
> - UDUnits was not mentioned as representing a 'model of UoM', is it just
> too flat? (08)
I named the ones that I saw mentioned in the Web teleconference; I have
every reason to believe that the list will get longer. I know nothing
about UDUnits, but if you want to be the expert for that one, then it
goes in the table. (09)
> - We quickly developed a set of (basic) attributes for evaluating
> ontologies [1] for the W3C SSN Incubator Group [2]. There may be
> other/better lists of same, but it's a resource. (010)
I'd have to look at your reference. I am uncomfortable with the term
"evaluating ontologies" unless it is followed by "against our perceived
reasoning requirements". (011)
> And a question:
>
>> That means: individuals who are familiar with each ontology will
>> volunteer to be the "named expert", do the abstraction, and put the
>> result in a *document* in a Wiki repository. (If we get wrapped around
>> an ontology repository that only accepts ontologies in OWL, it is of
>> no use, because each of these extracts will be in the language of the
>> upper ontology.)
>
> 1) Just wondering, why a *Wiki* repository? Use of it wasn't mentioned
> in the rest of the text, that I noticed. (012)
We need to have pages editable by multiple people that are linked to
short uploaded documents and other pages. Because I was talking about
uploading "extracted ontologies", I was contrasting the Wiki to the
"ontology repository" kind of thing. Other web technologies that are
wiki-like in this regard would be fine. (013)
> 2) I don't understand the last sentence, can you elucidate? (014)
The last sentence was the alternative I was rejecting. This is not
about a public repository of reference ontologies that is based on an
ontology for ontologies, etc. Our purpose is different -- we are
talking about a collection of ontology fragments (and lesser models) in
various languages that enrich our common understanding of the solution
space. (015)
> Also, if you don't mind teaching a little, can you explain or give
> example of an 'axiomatic form' vs an '(extended) DL form' of the language? (016)
By an "axiomatic form", I mean a First-Order-Logic form that uses
explicit well-defined quantifiers and connectives according to a grammar
of sentential forms. The (usually two) non-terminals whose meaning is
not specified are satisfied by elements of a "vocabulary" of
user-defined relations and constants. Some relations and constants are
"undefined terms" -- their intent is specified in natural language, and
the set of axioms given for them does not necessarily distinguish them
from other concepts in the universe. Others are completely specified by
the axioms given for them. The reference standard is ISO 24707 Common
Logic, which defines a number of different surface grammars for the same
concept set, notably a LISP-like grammar called CLIF (and an XML form,
and some others). But there are several RDF vocabularies that are
nearly equivalent to CLIF, including Sowa's concept graphs. (017)
A Description Logic (DL) form is a language whose grammatical elements
include "classes" and "properties" and constants and some specific
relations that apply to classes, properties, and instances. The notable
distinguishing feature is that DLs have no direct equivalent of AND or
OR or IF/THEN. Instead they have versions of them for classes and
versions of them for properties: Union, Intersection, Subsumption, and
participation cardinality. The reference standard is OWL/DL, which
itself has a few extensions to classical description logic. But OWLv2
extends this further, and combines it with a primitive types reasoning
facility (e.g., it includes arithmetic). (018)
<Example caveat="long"> (019)
Every quantity value consists of a number and a measurement unit. (020)
In CLIF, "quantity-value", "number", "unit", "value-has-number", and
"value-has-unit" are relations. (021)
The basic CLIF grammar is:
(relation operand1 ... operandN)
(quantifier operand1 ... operandN) expression
(connective expression1 ... expressionN)
where expression is any of the above
quantifier is 'forall' or 'exists'
connective is 'if', 'iff', 'and', 'or', 'not', etc.
'not' takes one operand, 'if' and 'iff' take two operands,
'and' and 'or' take any number of operands. (022)
"Every quantity value has a number and a unit" is written:
(forall v)(if (quantity-value v)
(exists n)(and (number n) (value-has-number v n))
)
(forall v)(if (quantity-value v)
(exists u)(and (unit u) (value-has-unit v u))
)
and probably:
(forall v n)(if (and (quantity-value v) (value-has-number v n))
(number n)
)
That is, any thing named n that is the number of a quantity value must
be a number. (023)
And also:
(forall v n1 n2)(if (and (value-has-number v n1)
(value-has-number v n2))
(= n1 n2)
)
i.e., a quantity-value has exactly one number -- if two numbers (n1 and
n2) are both the number of the same quantity value, they must be the
same number. (024)
I am not going to try to describe the OWL XML grammar.
But in OWL, I can write:
<owl:Class rdf:ID="QuantityValue">
<rdfs:label rdf:datatype=
"http://www.w3.org/2001/XMLSchema#string";
>QuantityValue</rdfs:label>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty>
<owl:ObjectProperty rdf:ID="value-has-unit"/>
</owl:onProperty>
<owl:minCardinality rdf:datatype=
"http://www.w3.org/2001/XMLSchema#nonNegativeInteger";
>1</owl:maxCardinality>
<owl:maxCardinality rdf:datatype=
"http://www.w3.org/2001/XMLSchema#nonNegativeInteger";
>1</owl:maxCardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty>
<owl:ObjectProperty rdf:ID="value-has-number"/>
</owl:onProperty>
<owl:minCardinality rdf:datatype=
"http://www.w3.org/2001/XMLSchema#nonNegativeInteger";
>1</owl:maxCardinality>
<owl:maxCardinality rdf:datatype=
"http://www.w3.org/2001/XMLSchema#nonNegativeInteger";
>1</owl:maxCardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf rdf:resource=
"http://www.w3.org/2002/07/owl#Thing"/>
</owl:Class>
<owl:DatatypeProperty rdf:ID="value-has-number">
<rdfs:domain rdf:resource="#QuantityValue"/>
<rdfs:range rdf:resource=
"http://www.w3.org/2001/XMLSchema#decimal"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:ID="value-has-unit">
<rdfs:domain rdf:resource="#QuantityValue"/>
<rdfs:range rdf:resource="#MeasurementUnit"/>
</owl:ObjectProperty> (025)
This defines a class labelled "QuantityValue" that is a subclass of
- the generic OWL class Thing
- the class of things that participate exactly once in property
'value-has-unit'
- the class of the things that participate exactly once in the
property 'value-has-number'.
It defines 'value-has-unit' to relate a QuantityValue to a
MeasurementUnit, and it defines 'value-has-number' to relate a
QuantityValue to a real number (XML Schema datatype 'decimal'). (026)
These two are not so far apart, but you can see the difference in
fundamental concepts. (027)
Now, consider the definition of quantity-value: The number of the
quantity value is the ratio of the quantity denoted by the
quantity-value to the quantity that is the measurement unit.
This requires a ternary relation "ratio" such that
(ratio n d r) means r = n/d
Then, in CLIF, I can write:
(forall v)(iff (quantity-value v)
(exists q n u)
(and (quantity q)
(number n)
(unit u)
(value-denotes-quantity v q)
(value-has-number v n)
(value-has-unit v u)
(ratio q u n)
)
)
This, together with the type constraints and uniqueness axioms above, is
a formal definition of 'quantity-value' in terms of the other relations.
(Probably not a useful one.) (028)
In OWL, there are no ternary relations, only binary ones. So we define
a "class" called 'ratio' that has three "properties" -- one for each of
the roles: numerator, denominator, ratio. But I can't really write the
relationship above, because the CLIF 'iff' must be modeled in OWL as an
equivalence between classes. 'and' is modeled as a union, and we, can
define a class to be a union, but the relations of the conjunction above
aren't all classes. I don't know whether we can define the class of all
quantities q that are denoted by a given v, but in any case, you can see
what happens in mapping logical relations and connectives to the set
paradigm of OWL. (029)
</Example> (030)
DLs are known to be less expressive than FOL, and it is amazing how
quickly you run into expressiveness limitations and the need for
work-arounds in OWL that say something like what you meant. But the
advantage is that there is a reasoning algorithm for the constrained
language that guarantees that any assertion can be validated, disproven
or proved to be unprovable in a bounded length of time that is
determined by the size of the ontology. By comparison, pure FOL is
known not to be boundable in this regard -- in any interesting ontology,
there are likely to be statements you can ask that will send a correct
reasoning algorithm off for an unknown length of time. (031)
The advantage of FOLs is that you can say exactly what you mean. The
advantage of DLs is that the reasoners are reliable. Each has its place. (032)
[The above is a bit crude. There are better experts in the Forum who
could give you a much clearer and more correct description.] (033)
-Ed (034)
--
Edward J. Barkmeyer Email: edbark@xxxxxxxx
National Institute of Standards & Technology
Manufacturing Systems Integration Division
100 Bureau Drive, Stop 8263 Tel: +1 301-975-3528
Gaithersburg, MD 20899-8263 FAX: +1 301-975-4694 (035)
"The opinions expressed above do not reflect consensus of NIST,
and have not been reviewed by any Government authority." (036)
_________________________________________________________________
Message Archives: http://ontolog.cim3.net/forum/uom-ontology-std/
Subscribe: mailto:uom-ontology-std-join@xxxxxxxxxxxxxxxx
Config/Unsubscribe: http://ontolog.cim3.net/mailman/listinfo/uom-ontology-std/
Shared Files: http://ontolog.cim3.net/file/work/UoM/
Wiki: http://ontolog.cim3.net/cgi-bin/wiki.pl?UoM_Ontology_Standard (037)
|