The primary expression which shows representation is the function of "as" ;

X as Y X ; Y

But there are other symbolic ways to express a representation .

For instance, there is "of" or "from" using the colon :

If we consider the frame of vision, we extract objects from the frame. Negative and positive space from and image or an object and background of an image.

This string is an object: xxxxffxxxxx

a representation can be made as ff of xxxxffxxxxx or

ff : xxxxffxxxxx

here we make a representation as:

AW:xxxxffxxxxx = xxxxffxxxxx -> **xxxxffxxxxx;ff** -> ff = AW:ff

Here we represent ff as being the ff of xxxxffxxxxx:

AW:ff = ff = ff;(ff:xxxxffxxxxx) -> ff:xxxxffxxxxx -> xxxxffxxxxx = AW:xxxxffxxxxx

or (AW:ff) ; (ff:xxxxffxxxxx) -awareness of an object can be an object itself. All objects are objects of representation.

Here we represent PP as being the PP of xxxxffxxxxx:

AW:PP = PP = PP;(PP:xxxxffxxxxx) -> PP:xxxxffxxxxx -> xxxxffxxxxx = AW:xxxxffxxxxx

of course, this kind of representation making makes no sense, WHEN WE EVALUATE IT. We can arbitrarily make any kind of representation. The fact that there is no PP:xxxxffxxxxx is about the context of xxxxffxxxxx we evaluate. We can say there is a PP:xxxxffxxxxx and that is a representation or we can say there is no PP:xxxxffxxxxx and that is a representation.

We would expect an AI, or any developing repper, to make exactly these kinds of representations, or guesses, and when then test them out. That is, evaluate this representation PP:xxxxffxxxxx to other representations. This process of evaluation is a kind of representaiton making where the arbitrary representation of PP:xxxxffxxxxx is associated to other representations... such as truth or falsity representations.

How do we EXPRESS, wrong, or not true?

Like so: (PP:xxxxffxxxxx) ; not true - as "not true"

or (PP:xxxxffxxxxx) !; true - not as "true"

or (PP:xxxxffxxxxx) ! true - not "true"

or (PP:xxxxffxxxxx) ;! true - as not "true"

or (PP:xxxxffxxxxx) ;! xxxxffxxxxx - as not xxxxffxxxxx

This last way to express a not representation is probably what happens.

(PP:xxxxffxxxxx) and xxxxffxxxxx do not evaluate to each other. If we think of the repper as running on a neural network, the network that expresses xxxxffxxxxx has no connection or link to PP. In representational terms, there is no connection between PP and xxxxffxxxxx apart from this one repersentation that is made. And what happens in real life, because representations are constantly being made, is that there should be other kinds of connections between PP and xxxxffxxxxx. PP:xxxxffxxxxx does NOT evaluate to very much so we think of it as not true.

"Of" functions are going to produce objects that can evaluate to "not" representations. PP:xxxxffxxxxx exists, but it evaluates to a "not" representation. it is a dead end that does not let representations flow. PP:xxxxffxxxxx does not let us make new representations from xxxxffxxxxx or from PP.

Another basic representation is the "and" or "," "And" is not a mathematical plus! It can be plus, but plus is a special mathematical condition of "and".

for instance:

AW:xf = xf -> xf;x = x = AW:x -concurrent awareness

-> xf;f = f = AW:f -concurrent awareness

What happens in awareness is that x:xf and f:xf exist as separate objects of awareness.

There is AW:x and AW:f. Thus:

AW:x = x -> x:xf -> xf <- xf:f <- f = AW:f

or AW:xf = xf -> xf;(x,f) -> (x,f) = (AW:x, AW:f)

(xxxxffxxxxx ; (x,x,x,x,f,f,x,x,x,x,x) ) ; true

xxxxffxxxxx ; (a,b,c,d) is a fanciful representation. and expressions are again representations that fail to evaluate to anything but themselves we would expect to think of them as fancies or errors.

what about xxxxffxxxxx ; (4,2,5) does that evaluate to something else? yes it does. because we make more representations from this expression.

xxxxffxxxxx ; (4,2,5) -> 4:(4,2,5) -> 4 -> 4;(count:x) -> (count:x) ; xxxx

-> 2:(4,2,5) -> 2 -> 2;(count:f) -> (count:f) ; ff

-> 5:(4,2,5) -> 5 -> 5;(count:x) -> (count:x) ; xxxxx

what do we see? count:x here the idea of count is representationally made to an object. count of object. it is arbitrary, but it is also meaningful because counts of things are "extracted" or taken "from" the things themselves. If it is not obvious, a count is a meta representation that requires an awareness of counting for those representations to make sense. We make xxxxx ; countable

I am not showing all the kinds of representations that "counting" is going to make. But we can MAKE many representations to counting representations if we want to... fingers and toes are countable, light and water are not countable. (volumes of water are countable, but not water itself.)

it is important to remember, that these are symbolic ways to EXPRESS representations. That fact is, there are representations. these are ways to express what those representations are. "of/:" and "and/," are (=) ways (= -> ; () ! ) to express complex structures of representation and awareness.

I believe that all representation is the same function as/; and more complex structures are multi-dimensional webs of representation and awareness.

Using these expressions, it may be easier for us to build a data based repper.

representational functions of awareness:

; : :;/;: ( ) , <- -> = !, ;!/!;

as, of, of as/as of, set or list, sequence/flows, identity, not, as not/not as

we can take flows of objects x -> x;y -> y and treat those as objects themselves, as objects of awareness:

(x -> x;y -> y) = AW:(x -> x;y -> y)

x:(x -> x;y -> y)

y:(x -> x;y -> y)

(x;y) : (x -> x;y -> y)

(x, y, x;y) ; (x -> x;y -> y)

all these expressions are just representations. We could instead say x ; x;y ; y

We make representations from flows, or from groups (and) or from objects of, or from representations. We can create lists and sets from those objects.

Here is a list (x, y, x).

Here is a set (x, y).

Here is another kind of list or set (x;y)

Some logical rules of list processing and set theory would seem to apply to these kinds of representations.

each representation is a different kinds of object. Thus we see objects from/of those lists or sets:

x:(x,y,x)

x:(x,y)

x:(x;y)

This is higher order representation making. But it must rest on a basic premise of representation making.

It is important to remember that there is a basic representational function that is approximated symbolically using ;. We can use other symbols to express more complex relationships. But the use of symbolic expressions for representations will be useful in modeling and constructing an artificial intelligence, or repper.

Keep in mind that the fact of representation is not only a feature of external objects, but is something in awareness. x;y = AW: x;y

Representational objects (x;y) always instantiate in awareness, just like all other objects. The awareness of a representational object is that representational object. AW:(x;y) = (x;y). It must be so in an AI as well.

note:

Idealism argues that the properties of objects, which are representations, is a feature of the mind. Materialism argues that properties of objects (properties are representations) is a feature of the objects themselves. Both positions are arguable philosophies of how to represent the functioning of reality where awareness of objects and representations (one object as another object) are facts of that reality.

By contrast, we should not see idealism as a philosophy in a factually materialist reality and we should not see materialism in a factually idealist reality. We must account for how those philosophical positions are reasonable in a universe that includes them both.

Idealism and Materialism are both attempts at descriptions of global representational functioning. Here we are describing a basic function of awareness and representation that opens a path for both philosophies to arise and co-exist. It would seem natural that any kind of intelligence would develop idealist and materialist philophies, and we should expect to see that behavior in sufficiently advanced artificial intelligences. (reppers)