Ali
It is a commendable work for your Master’s
thesis. Congratulations!
I will visit your link and get tuned. How
easy is it for one to understand that underlying axioms have been logically
correctly matched in the repository?
Thanks.
Ravi
(Dr. Ravi Sharma)
313 204 1740 Mobile
drravisharma@xxxxxxxxx
From: ontolog-forum-bounces@xxxxxxxxxxxxxxxx
[mailto:ontolog-forum-bounces@xxxxxxxxxxxxxxxx] On Behalf Of Ali Hashemi
Sent: Tuesday, January 27, 2009
4:12 PM
To: [ontolog-forum]
Subject: [ontolog-forum]
Using Repositories for Ontology Design and SemanticMapping
Hello all,
Last week in the Next Steps in Using Ontologies as Standards discussion, I
alluded to some of the work I did for my thesis and how it related to the topic
at hand.
Well, I've finally bound and
submitted it, so I'm going to share
it with all of you.
The thesis has three main contributions which i think are of immediate interest
to the ontology community:
- an architecture for ontology repositories
that enable
- an ontology design algorithm (with correctness
proof)
- a semantic mapping algorithm (with correctness
proof)
A quick overview:
Thus it uses (1)
ontology repositories as a centralized, semi-open, inverted pseudo-upper level
ontology to facilitate (2)
ontology design and (3)
semantic mapping.
The Repository
It's semi open in that any one can
submit theories for inclusion (though there is a vetting process). I will
explain the pseudo-UO below.
It is predicated on the idea of metaphor - that disparate concepts share
underlying logical substructures.
The repository is organized in two directions: it consists of "abstraction
layers" and within those abstraction layers, it contains
"core-hierarchies." It uses a loose notion of primitive, which i call
logical lego blocks. These theories populate the lowest layer of the
repository, and are connected to other layers by either Representation Theorems
or Mapping Axioms (we're unsure
which is the best way to move forward). The two following algorithms do not
rely on how the layers are connected to one another.
The theories of the lowest level are drawn from mathematics, and include but
are not limited to symmetries, orderings, groups, geometries, topologies etc.
The layer atop is more akin to traditional Upper Ontologies (UO), and is
populated by concepts such as space, time, mereotopologies, etc. Additional
layers may be added, corresponding to more specialized theories.
A key difference with a UO is that we're
not taking a position on what is the
correct concept of space, time etc. Instead, it relies on what the language can
express (i call it, its biases). Thus the lowest layer is fundamentally about
how the rules of FOL let us define interesting theories just by looking at
abstract symbols. The other layers which connect to the real world, then come
on top.
A core-hierarchy consists of non-conservative extensions of one theory (or
relation). I've implemented one for
partial orders. So at the root of the hierarchy are the basic poset axioms, and
further modules (theories) that extend that theory, in effect construct a map
of poset theories. The only stipulation is that no core-hierarchy can share a
non-conservative extension with another core-hierarchy in the same abstraction
layer.
Ontology Design Algorithm
With this stipulation, I can construct an ontology design algorithm.
The novelty of the approach is two-fold. First, it does not require a subject
matter expert to be well versed in FOL (or CL), either theoretically or with
its syntax / grammar. Second, it relies on a model theoretic approach to axiom
specification. Thus, instead of writing axioms, users define relations based on
their models (in the Tarski sense). Basically, I ask a user to construct at least one model for the relation they
are trying to define. They do so in a Sandbox Environment which i have thus far
implemented for binary relations, in the guise of a graph. A complete diagram
(set of all positive and negative literals), is then generated from each user
model. The only stipulation for how models can be drawn is that the same
complete diagram may be generated unambiguously and repeatedly for a given
"picture".
These FOL statements (the complete diargam) are now tested against an abstract
layer with each (or user specified) core-hierarchy. Basically, we will scour
the repository and see which theories are satisfied by this model.
However, clearly this is not enough to get at the user's
intended axioms. Once we have identified the theories in the repository that
are consistent with the user models, we look to the scientific method
(falsification) and the map we have of each hierarchy to intelligently traverse
the repository to find "the strongest set of axioms which capture the user's intended models."
We do so by generating models and proposing them to the user. In this way, we
grow sets of Accepted and Rejected models. Based on user feedback, we arrive at
the strongest theories in the repository that capture the user's intended models. All without requiring the user
to know FOL particularly well, or even look at the underlying axioms. They only
need to be able to "draw" one model of their idea, and to determine
whether a proposed model fits their view or not. The nuances of this approach
(as well as a correctness proof) are available in the thesis. I'd like to stress that this approach need not be
restricted to simply visual models. Conceivably, it can be extended to
auditory, tactile and other senses. Again the only stipulation is that the
model may be unambiguously and repeatedly interpreted in the same way.
Semantic Mapping Algorithm
Similarly, given a repository with the above architecture, we can conduct
semi-automatic semantic mappings. The mapping being done is that of alignment
as specified by Choi and Noy (see thesis for references and more detail).
We can create alignment between n
ontologies. The way it works is simple. The axioms for a single target ontology
are imported, and using a mapping axiom (which can
be generated automatically), we test the target ontology, T1, against theories
in the repository using an automated reasoner. We collect all theories that are
consistent, which constitutes the image
of T1 in the repository. We may repeat this for any number of ontologies. Once
we have all the images, we can construct a notion of similarity and difference.
Similarity in this context, is
simply the intersection of all the target ontologies, yielding the theories
which are commonly consistent to all. Thus, if the Im(T1) = {A, B, C} and Im(T2)
= {A, D} and Im(T3) = {A, B, E}, their similarity is Sim(Group)=A.
Difference is slightly more
nuanced. It requires that we pick a single ontology and compare it to a group.
The difference for (T1, Group) are the theories which are consistent with T1
but inconsistent with at least one Ti in Group. So if Group = {T1,T2,T3}, then
Diff(T1,Group) = {B,C}
Next Steps
Michael Gruninger's Semantic
Technologies Laboratory will be implementing one such repository, using CLIF
over the next few months. Work is also starting to map existing UOs into the
repository to populate the second layer. The algorithms should be implemented
as a web accessible service over the summer.
In terms of the ontology design algorithm -- it's
only really scratching the surface. Right now it's
providing axioms for one relation at a time (though the specification of other
relations and functions fall out as a corollary) . It'll
be interesting to extend this to multiple relations simultaneously. Also,
creating graphics that are more natural for a subject matter expert's particular domain is an interesting extension of
the idea.
// ontolog held up my initial message cuz the attachment was >3Mb, so here
is a link if you're interested:
http://www.yousendit.com/download/WnBRN3RaMGtmVFpMWEE9PQ
--
Cheers,
Ali Hashemi
MASc (waiting to convocate)
Semantic Technologies Laboratory
University of Toronto
PS (i'm graduating in one month, but
don't want to start phd till 2010.
if anyone has an interesting project (that pays better than grad student salaries)
i'd be very interested and willing to move!
:P )
--
(•`'·.¸(`'·.¸(•)¸.·'´)¸.·'´•)
.,.,