[67] home [69]

 

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

 

The Readware Framework of Knowledge

 

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.