P- as a Visual Explanation

[Juan E. Sandoval]

This is a companion thread to P+ (Pe) as a Visual Explanation, and is aimed at introducing the functionality of P- (Pi). Last time we took a look at a metaphor using a little robot car going around the room like so:

But this time, I'm going to focus on the other half of this story (Pi/P-) and how the two come together. So, P functions first fundamentally help us map reality concretely, and it's at this physical level that we need to conceptualize their computational structure. Exponential cycling takes care of higher abstractions later on in life, but at the computational level, the P functions need to tangibly form a view of our physical reality -- so this is what this thread will focus on demonstrating.

Environmental Scanning (P+) and Mapping (P-)

I would like to use modern 3D scanning technology as a metaphor -- (or actually, it may not be a metaphor, but the actual thing since, if A.I. ever comes to be conscious it would have Perception functions that would work very much like this.)
The task of perception has at least two core operations that it must perform:

• 1: Scan for uncharted areas within one's map
• 2: Save or archive that map for later recollection

In the GIFs above, you can see a little drone (P+) hovering around the room. This is the same as the robot car (P+)  in the previous thread. As it moves around the room it finds objects, and those are appended to short-term memory. Short-term memory, in this metaphor, is the current camera viewport. However, we need to be able to store the data if we go to another room which is outside of this viewport. This would be what P- does. This example may help illustrate what I mean:

^ Here is a 3D scanning app that is building up a mesh of a room. If you notice, halfway through the GIF the computer chair falls out of the viewport. The question may be asked "If I go look at the chair again, would I have to re-map it?" Well, if all you had was P+ (Pe), yes, you would have to re-map it every time your viewport changed.
But because of P- (Pi), you don't have to. If P- is working, then it would retain the chair in memory, despite it not being in the viewport anymore. It acts like a computer "cache" that saves loading time.
Now, this has pros and cons. On one hand, P+ is correct to re-scan an area anew because you never know what has changed. In those 10 seconds something could have happened to the chair. But on the other hand, without saving this cache, you wouldn't be capable of complex tasks that require contextual persistence. A fully P- psychology would suffer from never updating its cache, and therefore remain outdated. A fully P+ psychology would suffer from never saving anything in cache, and therefore have an attention/retention disorder.

Notes

I was watching a computational model video the other day, where they showed this crucial moment happening in the development of a baby, when he reaches behind himself to grab a cube which is not in his line of sight:

^ This is P- (Pi) in the most basic sense. It's about "object persistence" even when objects are not in view. The baby here knew there was another object behind him, which means he had a "concept" of the object in his head. This is the very beginning of abstraction.
Another example of P- in basic, concrete use is in inferring the backside of an object:

^ When we look at an object, if we just had P+ active, we wouldn't know what the occluded areas are. However, the reason we know is because when P- accesses a certain object from memory, it also loads up all other instances of that object (i.e. from other angles) and forms a complete image of that object.

Abstraction

Okay, now that I've explained all of that, I think what we all want to know is how this applies to our conceptual life. Well, for instance, knowing the "back-side" of a concept entails understanding the "non-visible" aspects of it. For example, if you're thinking about getting that credit card or loan because it's offering up $5,000 interest free -- P- views that object holistically and asks "what is the back side of this" or "what is the whole object." It may conclude that "the whole object" is composed of a temporal sequence involving quick money up front, then hidden fees later, followed by penalties for late pay -- all of which add up to a net profit for the bank over time -- which is what makes this business strategy not as free as it looks, cuz no company gives out free money and survives.
This example is not different from the man above whose back side is non visible, except now we're talking about temporal occlusion. The two scenarios can be compared side by side like so:

A person with strong use of P- will have a perception of these occluded areas in their immediate environment-- all the way up to society at large and the histories of civilizations.

= = = = =

This post ended up being super long just to explain the overall concept, so I'll get to the code bit on a followup post.
But I hope this is clear in explaining the jist of what is meant by P+ and P- in Model 2, and how both work together to literally stitch together our perception of the world.

• This topic was modified 4 years, 3 months ago by Juan E. Sandoval.

[drionbh3]

This is great! Will you be detail on this post how P+ data gets rendered as P- data? Like Se to Ni, Ne to Si.
 
There's definitely some differences in preference and attitudes for each type, but it seem like the rendering process for each of these 2 ways is similar. I've looked at Se->Ni as looking at the literal environment and build a big worldview based on it in your head. For Ne->Si, it's like looking at the big picture and possibilities and etching the details and experiences in your head.

[Juan E. Sandoval]

hi and welcome!
yes, first i'm describing P+ , P-, J+, J- (Pe, Pi, Je, Ji) then I'll be describing the individual functions (i.e. M+ (Ne), V+ (Se)), then finally the interplay between the two codes as one.
 

[Juan E. Sandoval]

Okay, so now for the actual code of P- found here.

 # Select one object to focus on
theObject = theObjects[0]

Here, theObject (which is an array or matrix generally involving the whole viewport) is re-defined as one object of that array, object number 0. The designtion "0" is partly a convenience here, as it could be any one single object, whether that is object 0, 20, or 104. The point is that the function focuses on one only. This first line is critical in that P- is an "introverted" process, which means it looks intra-object. J- is also like this. To put this into perspective, imagine there's a scene here:

^ As you can see, there are many objects in the scene, each denoted by the black bounding box I've added here. The cat here is what we might call theObject[0], while the whole scene is theObject before this code starts. But as we know, due to the nested nature of objects in neural networks, including our own, this cat object is itself composed of child-objects -- so the operation of P- is focused on the interior of this cat:

# Check to see if the object exists in memory
IF theObject exists in memory do
So now what we do is we run an operation "IF" this object exists in memory. So, memory is a special place here, that is different from st-memory (short-term memory). This is an archive that is broader, and you can liken it to a hard drive. Again, P- isn't memory itself, but it's a function that recalls from memory. So now we're going to see if this cat is in memory or not, and if so.... "do" the following
# Run a loop on all memory
FOR i to memory length do
Now we initiate a FOR loop, which is going to run this operation across all of memory for all hits, and do something for each positive hit.
# Scan each element in memory for theObject
objInstance = SCAN in memory for theObject[i]
Okay, so now what this says is that if there is a positive hit for this object in memory, that hit is defined as "objInstance", or an "instance" of that "object." There may be many such hits from memory, so each positive 'hit' is an instance. For example, a person may have hundreds of memories involving this cat. So the next question is - what happens to all these instances?
# If an instance of the object is found
IF objInstance != undefined do
# Add the instance to an array called allInstances
APPEND objInstance to allInstances
What this says is that every time an instance of the object (the cat) is founded, it is APPEND'ed to an array called allInstances. So lets think about this for a moment. Here you have a cat, and you're looking for all the instances of this cat in memory, then making a meta-object out of all these instances. Lets visualize this like so:

Lets say these are allInstances of the object "cat." Well, they involve different angles of course, and different situations. But together, all of them have the potential to generate a coherent temporal and spatial image -- but only if they're sorted properly. If this is done, we'd get a product like so:

A mental model of the cat can be formed by stitching together these objInstances into a coordinately-coherent sequence. But for that we need the following operations:
# Restructure allInstances according to location
allInstances = SORT allInstances.child-objects by spatial-coordinates
# Restructure allInstances according to temporality
allInstances = SORT allInstances.child-objects by temporal-coordinates
What this says is basically.. you take all the child-objects of allInstances.. which are the individual objInstances... and you SORT them according to spatial coordinates. The GIF above demonstrates how this would look like, such that you can see the body parts of the cat all in the right place, as you change your 3D spatial angle/coordinate.
As for "by temporal coordinates", this would sort the instances more like this:

^ Here what we see is a walking sequence of the cat, which takes temporal coordinates. First the front leg moves, then it goes behind, while the other leg moves. This movement loop requires the child-objects to be arranged in such a way that they can produce this coherent effect.
I realize "SORT" here is doing a lot of heavy lifting and I'm not explaining the details of how this happens computationally, since these SORT operations are built into the hypothetical structure of this program. Partly I don't know the best solution yet, but part of the reason I don't go into its structure is that I am first and foremost concerned with modeling the 8 functions -- and all parts of the code that I'm touching upon relate specifically to upcoming differences in how V, M, R and G handle these processes. So for the time being the nuances of the SORT function are irrelevant to an initial draft of the differences between the 8 functions.
Okay, so now we have a "mental model" (object) of this cat, which can be conceptualized from all angles, and also as a temporal sequence. The last thing left to do is to add all this processing back into the main st-memory environment by:
# Update the object to the precedent that was constructed
theObject = allInstances
^ basically, what this last code does is it overrides the definition of theObject[0] with this temporal and spatial sequence we've just created. It essentially makes this "cat" synonymous with the conceptual construction we've just made. Henceforth, any operations that are performed on this cat, will be performed on the allInstances array/matrix we just built.
And with that we're done!
The code of P- has successfully allowed us to see a cat on a desk, and "echo" out into short-term memory all of this data, which includes the back side of the cat, as well as its animations over time. Notice that the operation of P- never left this single cat, and it totally neglected any other objects in the room.
In reality, it would perform this operation one at a time to each object in the room - or however many it can get to.
~ ~ ~
p.s. - What I'm not mentioning at the moment is a situation where the whole 'room' is treated as one object, which does happen, but that's still different from inter-object dynamics. But this requires its own post later.

• This reply was modified 4 years, 3 months ago by Juan E. Sandoval.

[Author]

Posts