[Fwd: Re: [om-list] System Design]

[Luke Call]

Mis-addressed this the first time.

-------- Original Message --------
Subject: Re: [om-list] System Design
Date: Mon, 30 Oct 2000 07:26:25 -0700
From: Luke Call <lacall at onemodel.org>
To: Mark Butler <butlerm at middle.net>

Mark Butler wrote:

 > The idea is to create a standard format to allow data to be imported and
 > exported from databases with widely different internal assumptions and
 > architectures.

So you are talking about an exchange format, not the native storage
medium. If so, this is the clarification I was looking for.


 > Of course.  But none of the object oriented models we have discussed 
so far
 > are capable of representing very simple logical statements, such as 
for every
 > huamn being there exist exactly two biological parents, *unless* you 
convert
 > such simple sentences into a couple dozen different objects 
corresponding to
 > some sort of parse tree for the sentence.

Human is already an object in the system after the first user identifies
himself.  As soon as he mentions his biological parents you have one
example. The way genetic engineering is going, there may some very
strange situation in the future with a true single-parented person
(given the world we now live in). Or maybe not. But truth may be a set
of observations, rather than a set of rules. Because we don't really
know all the rules or all circumstances that may ever exist (not that I
advocate new approaches to biological parenting!). But if in the
meantime we need to establish a constraint, no problem, we put a
constraint on the relationship between person & parent, or on the person
class somehow, which may well be expressed as some type of logical
statement. No problem...?


 > No they don't.  First of all, a class is *not* a query.  A class is a 
set with
 > ill defined and often unknown boundaries and composition.  Some synthetic
 > classes may be defined to be identical to well defined matching 
criteria over
 > the set of all objects, but most are not.  You would be very hard put 
to make
 > a query that can distinguish correctly between a dog and a cat for 
example.

A cat has different genetics. Meows. Different abilities. Any of those
could be that query. And I don't utterly rule out explicit class
relationships. The first user who wants to include dog or cat in the
system won't want to bother with genetics, so maybe the entry of
distinguishing characteristics doesn't happen there for the first
dog/cat user, but later on when he needs to distinguish. I don't know
for sure.



 > ....describe the properties of the earth's orbit around the sun.  We 
need to be
 > able to represent at the very least, a second order non-linear 
differential
 > equation with at least the positions of the earth, the moon, and the 
sun as
 > independent variables.  Neglecting the problem of solving or 
expressing the
 > solution to the equation, how do you represent the basic laws of physics
 > themselves in an object oriented data model without converting it 
according to
 > a grammar system of a formal logical language?
 >
 > As I suggested before, there is no way to express the simplest 
mathematical or
 > geometric truths in a system that is not equivalent to a formal logical
 > language.  As an exercise, please express the Pythagorean theorem in 
an object
 > model.

Must the entire system be equivalent to a formal language, or can it use
one internally, embedding it in objects when rules are needed? This
seems like a use for inheritance, where physical objects all obey
physical rules, as we understand them. Such rules might work nicely as
constraints on physical objects, expressed in the language of our
choice, and can be changed as understanding grows. I still see no real
conflict here.


 > No on all three counts.  First, because typical OO models are 
oriented towards
 > expressing only binary relationships.  Second, because non-binary
 > relationships have to be force fit into such simplistic systems, 
forcing them
 > to become an expensive version of more powerful ones.  Third, because 
the laws
 > that govern the natural world, at their simplest, are non-linear 
multivariable
 > differential equations (such as Newton's law of Gravitation or Maxwell's
 > Equations), not simple binary relationships.

It seems to me that relationships can have many participants, unless I
misunderstand what you mean by binary relationships. And such equations
have a place in an OO system! I mean the entire body of such things when
I say constraints and methods. I just haven't managed to say it well
enough yet or something.


 > That is a misconception - the semantics are not any simpler than the 
syntax.
 > Another test exercise-Translate the following into a semantic object 
model:
 >
 > John believes that the fundamental reason for the American civil war was
 > unresolved tension between the state and national governments over 
the correct
 > interpretation of the Constitution.

Sure:  In John's model or context within a larger model, there are
objects for governments and a constitution. There is a record of a war,
as individuals and governments engaged in activities of aggression
(methods!?) over time. (These objects may not be specified beyond name,
depending on his needs at this time. But I hope they would be easy to
enter and relate, using the software.) There is also disagreement (a
conflict/nonalignment, or as Tom stated for our requirements, a lack of
coherency) between the models or contexts of understanding used by some
of those internal objects--such as the governments) or emotion (we can
store emotion as a scale of some property, and perhaps even predict it,
by an observed disparity between expectations [another context or
submodel] and reality). All these things don't have to be complicated to
model, but can become complicated if the user desires. Many of them
would already exist in the system as a byproduct of John's interest, if
he uses the system for his notetaking or study. And I haven't yet
thought enough about how to model cause/effect to say for sure: it might
be cause/effect due to the properties of physics you mention above for
some situations, but a belief in cause/effect might be enough for a user
to simply create a relationship indicating it. Again, the intent is to
capture the meaning behind the words, which are symbols for reality. We
translate to different symbols (sometimes more accurate ones).


 > One of the main points of that article is that a knowledge representation
 > system entails a set of ontological commitments due to its necessary 
choice of
 > representation approximations.  Without a reasonable proposal to 
express the
 > simplest logical expressions in an object model, my position is that 
it is
 > fundamentally inferior to a formal language based model for a general
 > knowledge representation system.  This is why people in the field 
generally
 > use LISP rather than traditional databases.

Another of its main points is to use the benefits of multiple
approaches, by combining them in a way that takes advantage of their
different strengths. I think that is clearly what we need to do. What
about doing just that, along the lines of the my above suggestions,
where an OO model uses rules when needed to express constraints, action,
and perhaps other things in order to represent and simulate the real
world? I think our respective views are like abilities that can be
complementary rather than mutually exclusive.

By the way, would LISP store a description of the dimensions of a box
and its contents, and their chemical properties, together with their
typical responses to various kinds of radiation, as a large body of
parenthesized rules?  I think an OO model with all needed rules, lending
itself to simulation, would be a wonderful tool for study and learning,
using any knowledge of physics that may already be entered into the
system (perhaps as rules/constraints/methods or such, on supertypes).


 > I have yet to run into any successful implementation that translates
 > knowledge of any linguistic complexity into any sort of conventional 
database,
 > object oriented or otherwise.  The reason for this is strictly 
performance.

I think performance for the examples I've given above could be acceptable.


 > If we want do put a comprehensive model of knowledge into a database 
we will
 > have to design a database architecture from scratch optimized for the 
purpose
 > of storing extremely sophisticated semantic relationships typical of 
the laws
 > of nature and the way the humans actually reason and express themselves.

We are not modeling strictly language--we are also modeling the concepts
that language attempts to represent, beginning with a noun usually being
an object. We can store the content of documents in their original form
as a record of source material, or there may be a better way to handle
them. Modeling linguistics itself is an area where a linguist will have
to see how to use the system, but again, I see no limits.


 > > I think natural language (at least in current forms) seems like an
 > > inefficient way to communicate thoughts. We learn visually much faster.
 >
 > You are confusing bandwidth with brevity of representation.  Natural 
language
 > is by far the most efficient way to communicate information with any 
degree of
 > abstraction.  How well could you teach history, philosophy, or 
religion if you
 > were limited to showing films with no written or spoken words?

We could express belief of cause/effect relationships and show movies of
simulations, whether they be war, atonement, or engine design (always
within the limits of our understanding!), but I don't know that the
system would replace human mentors/teachers. That's quite a bit farther
out, it seems. It could certainly augment them well.



 > Natural language is not first order, but rather arbitrary order. 
Traditional
 > object oriented databases are *zeroth* order, because they have no way to
 > represent a variable (a repeatible symbolic placeholder for the same 
object in
 > an expression) at all.

What is "nth" order?  I see no reason why it could not hold any number
or type of variables, in methods with hooks to be used by simulations.
The variables could be filled by the simulation configuration, or by the
system as a result of the path taken to invoke the method.


 > In addition, the argument for supporting complex statements does not have
 > anything to do with where we get the ones we choose to store.

I'm not sure I follow your meaning on that one.


 > closet until it gets done.  There may be an impressive brand of 
social recluse
 > who can write large portions of major software projects in his spare 
time, but
 > I don't think I am one of them, unfortunately.

I may be testing the limits of your patience here; and you may well be
right on all points, but I prefer not to quit until I know for sure. I
can only specify systems I understand well enough to buy into. You may
get sick of that pretty fast. But I don't expect to be quitting no
matter how long this takes, one lifetime or many.  Also, circumstances
may change at some point, allowing one or more of us to devote more
time. In the meantime, if a trickle of work is all I can do during some
times, it's still worth it to me.

Clearly, face-to-face conversation, or some other realtime method, would
probably make this go faster. That's the biggest reason I'd like to meet
everyone around Thanksgiving and see what comes of it. Maybe an
occasional conference call would simply make communication easier, which
I wouldn't mind setting up because it would be worthwhile and useful. If
others are interested let me know what times of week work for you and
I'll see what they cost to get a number we dial in to and talk. Maybe I
can just do it.

Luke

------------------
Help us put all knowledge in one bucket: www.onemodel.org.


-- 
Help us put all knowledge in one bucket: www.onemodel.org.
Note to friends/family: my email address is changing from 
lcall at pobox.com to lacall at onemodel.org.