Ferenc and John,

I think of a predicate as a FOL _expression_,
with the usual *and or
not xor coin* etc operators, and all the *terminal* *symbols* are each
filled by either property names or property constant ranges.

A predicate returns True iff the predicate
function is satisfied over the property values, False otherwise.

Let me define “product normal form”
as the sequence of predicates in Anded (product) form only:

P(x,i) := P(x,0) ^ P(x,1) ^ .. ^ P(x,N)

Some prefer to use the opposite view, the “sum
of products” method for representation of predicate functions, but in
this case there is no SUM, just one big PRODUCT of PREDICATEs. So the
P(x,i) can be calculated with sums (or)s internally, therefore can compute
anything computable.

Given a bunch of Things (a Universe), and
their property values, wherever the property values are known at time t for the
Things, Each predicate represents a traversal from the root node down to a
terminal node. So each predicate selects at least one subThing (for Or
expressions) from among the chaff at that level, perhaps a large number of
subThings, but preferable fewer subThings than that node’s parent node. Except
for the root node, which holds the whole universe of Things in its confines.

Given that starting point as the structure
(see 7,209,923), any kind of distinction can be made. So the distinction
of what is an object, what is a type, relation, and so forth can be based on
the properties first defined by capability of the agent’s sensors. Anything
built on top of that sensor information is, by definition, not primitive, but
nonterminal.

At least that is my personal FOL ontology,
and I’m sticking with it because I like the long strings of predicates it
generates.

HTH,

-Rich

Sincerely,

Rich Cooper

EnglishLogicKernel.com

Rich AT EnglishLogicKernel DOT com

**From:**
ontolog-forum-bounces@xxxxxxxxxxxxxxxx
[mailto:ontolog-forum-bounces@xxxxxxxxxxxxxxxx] **On Behalf Of **FERENC KOVACS

**Sent:** Sunday, February 07, 2010
1:39 PM

**To:** ontolog-forum@xxxxxxxxxxxxxxxx

**Subject:** [ontolog-forum]
Foundation Ontology Primitives

Objects, Properties annd Relations are
the *cosmonomy* of the world of concepts. In descrbing them verbally and
representing them graphically (2D) you need to apply a *creative force*, the
*genezis* process that has a philo- and ontogenetic version. No higher math is
needed and representing what you have in a RDB is possible in 2D, a piece of
paper. (Description of the old system). My examples are from translating
between L1 and L2

So we start of with One, and we can zoom
in and out to be focused on the *one* in a text. A lot depends on what you
consider as one, it is not one word, no atomic view is correct. On the
contrary, you pick the longest string of words that are to be translated as one
(phrase, cluster, indentifier of a chunk of reality - named by a heading,
title, etc.). You want a complete entity as only complete entites make sense.
When you take a look at the next complete entity, a message, you need to have a
predicate, a verb which is not complete without specifying grammar person and
time.

Now properties may be part (adjective,
noun) of a predicate so they need to be paraphrised to be collected in a class
of identical grammar forms. So you need to make use of mental operations here
as well as with objects (not detailed here)

A property - used to describe *an object
is an adjective*. But this may be or may not be a terminal state. You may
rewrite it as *has property* (created from adjective above).

But more often than not, you come to the
above statements from a number of observations that involve messages *object
did this*, (*object did that*), etc.

You shave pilled my coffe - you are
clumsy, etc.

OMHO Without showing these relations you
will remanin stuck with atomism.