Monday, October 18, 2004
Mapping the expression of
social symbols à
Previous beads in this thread are about algorithm using Orbs
à [63]
Algorithm development using Orbs
By Tom Adi,
October 18 (afternoon), 2004
1. Background
In 1983, Adi developed a theory of the Arabic language by looking at an old Arabic book and asking a single question thousands of times: "Do the many contexts in which a word is used point to an invariant abstract parallel between the word structure and the structure of the physical context the word refers to?"
In Arabic, unlike most other natural languages, there is one-to-one correspondence between letters and sounds. Arabic has 28 letters and four vowels. Most Arabic word roots are verbs and most of them consist of three consonants. Vowels are added to create words out of roots. Vowels do not change the basic meaning. First, Adi examined the contextual usage of prepositions, pronouns and articles that consisted of a single consonant and a vowel. Then he turned to roots that had two soft consonants
(ya, hamza, waw, ha).
Soft consonants are related to vowels and are known to add much less meaning to roots than other consonants. Then, he examined roots with one soft consonant, and finally roots without soft consonants. Adi started by examining roots that denote simple processes that are easy to visualize. The Readware framework of knowledge is based on the results of Adi's 1983 analyses.
2. The Readware Substructural Ontology
We start with some technical definitions.
Define a frame as a unity, indicated by "(-)", filled with a list
-, so (a b c) is a frame with the list: a b c.
Define list((-)) = - , where "(-)" is a frame, so list((a b c)) = a b c.
list(X) =
list of elements of X, where X is a set, so list({a, b, c}) = a b c.
Define frame(-) = (-), where "-" is a list, so frame(a b c) = (a
b c)
Define set(-) = {elements of the list - }, so set(a b c) = {a, b, c}.
Let F = { f(i) | i = 1 to 4 } be the set of basic frames. For convenience we may write f1 for f(1), f2 for f(2), f3 for f(3) and f4 for f(4). We have
f1 = (closed)
f2 = (open)
f3 = (engaged)
f4 = (separate)
The derivation of f(i) will be discussed later.
Let P = { p(i) | i = 1, 2, 3 } = {assignment, manifestation, containment} be the set of basic processes. For convenience we may write p1 for p(1), p2 for p(2) and p3 for p(3).
We enumerate the power set of P
P* = {s(i) | i = 1 to 8}
= { nul set,
{p1}, {p2}, {p3},
{p1, p2}, {p1, p3}, {p2, p3} ,
{p1, p2, p3} }
Remember that size(P*) = 8.
We now define the "puts" operator on F x P*
puts(s(i),
f(j)) = frame( list( set( list( f(j) ) ) union s(i) ) )
This operator "puts" one or more basic processes in a basic frame.
The element-generating function B is defined from F x P* to the 4x8 matrix O
O = [ o(i, j) | i = 1 to 4 and j = 1 to 8 ]
where o(i, j) = puts(s(i), f(j))
|
(closed) |
(open) |
(engaged) |
(separate) |
|
|
(closed assignment) |
(open assignment) |
(engaged assignment) |
(separate assignment) |
|
O = [ |
(closed manifestation) |
(open manifestation) |
(engaged manifestation) |
(separate manifestation) |
] |
|
(closed containment) |
(open containment) |
(engaged containment) |
(separate containment) |
|
|
(closed assignment manifestation) |
(open assignment manifestation) |
(engaged assignment manifestation) |
(separate assignment manifestation) |
|
|
(closed assignment containment) |
(open assignment containment) |
(engaged assignment containment) |
(separate assignment containment) |
|
|
(closed manifestation containment) |
(open manifestation containment) |
(engaged manifestation containment) |
(separate manifestation containment) |
|
|
(closed assignment manifestation containment) |
(open assignment manifestation containment) |
(engaged assignment manifestation containment) |
(separate assignment manifestation containment) |
|
O contains the basic elements of the substructural ontology.
If we arrange the 4 vowels and 28 consonants of the Arabic language in a certain order in a 4x8 matrix A
A = [ a(i, j) | i = 1 to 8 and j = 1 to 4 ]
|
vowel_i |
vowel_a |
vowel_u |
sukoon |
|
|
ya |
hamza |
waw |
ha |
|
A = [ |
meem |
fa |
dal |
thal |
] |
|
'ain |
noon |
qaf |
ghain |
|
|
ra |
lam |
ba |
ta |
|
|
seen |
zay |
ssad |
tha |
|
|
kaf |
ddad |
tta |
kha |
|
|
hha |
sheen |
geem |
zza |
|
then we have an ontological correspondence between A and O. There is a one-to-one ontological correspondence between the vowels and consonants of the Arabic language and the elements of our substructural ontology.
In the following section, we will see how Arabic consonants and vowels combine into Arabic words that knowledge-represent the structures of simple real-world processes.