Hello all,
This thread is about V- (Ni) and how its computation works.
This thread will build on top of this thread and this thread, which may be necessary to grasp before this one. 🙂 Okay here goes. Aside from the regular P- code that is shared with M- (Si), this additional code is present in V- (Ni):

 	# Begin associative operation
	FOR i to theObject length do
		FOR e to theObject length do
	 	# Check to see if the object's children intersect with another object's children
  		 	IF theObject[ i ].child-objects intersect theObject[e].child-objects do
	 	 	 	# Make a new object out of the intersecting child-objects
			 	APPEND intersection && intersection.coordinates to intersectingObject
 	  		END IF
 	  	END FOR
  	END FOR
 	# Update the object to the precedent that was constructed
	theObject = intersectingObject

Lets go through this  a step at a time:
# Begin associative operation
FOR i to theObject length do
FOR e to theObject length do
We begin with the creation of two nested FOR loops, which are going to run the entire length of theObject (which, as you recall, is one object like the cat). It's length is therefore the number of child_objects it has. This doesn't mean too much yet so lets keep going:
# Check to see if the object's children intersect with another object's children
IF theObject[i].child-objects intersect theObject[e].child-objects do
Here we see that, just as with M+ (Ne), we are looking for intersections among the objects. However, in this case we're looking at intersections among the child_objects internal to a single object, rather than across objects. If we borrow the same cat metaphor from the P- thread, it might look something like:

(^ however, this is not really the complete picture - and I'll explain more below)
# Make a new object out of the intersecting child-objects
APPEND intersection && intersection.coordinates to intersectingObject
END IF
END FOR
END FOR
This is the key aspect of this code. Like with M+, a new object is made called intersectingObject, however, for V- this object is made of the intersections (the red areas of the cat), as well as coordinate data, because V- is a P- function, and P- handles coordinate object types. Therefore, these intersections are not positionally fluid, and do not become a chimera flower shape as we saw with M+. Instead, they retain their relative coordinates. And this creates a coordinate structure:

This structure is a contentless scaffold, much the same way M+'s intersectingObject is contentless, but it can 'fit' a variety of inputs. So, in having this spatially bound relationship of internal intersections, V- creates an intersectional 'map.' I'll come back to this shortly, since it's very important, but just to close off the code, we have the last lines as:
# Update the object to the precedent that was constructed
theObject = intersectingObject
^ As with M+, theObject is updated to be synonymous with this intersectingObject, which overrides the prior data and puts this new object into short-term memory. And this is the key point of the matter -- now that this object is in short-term memory, as soon as we re-run a second loop of this code, this intersectional map will run across the operations of P-. So, how about we do that. Lets take it from the top and go into cycle #2:

Cycle #2

Beginning with the check to see if it's in memory...
# Check to see if the object exists in memory
IF theObject exists in memory do
Of course it is, we just made it.
# Run a loop on all memory
FOR i to memory length do
# Scan each element in memory for theObject
objInstance = SCAN in memory for theObject[ i ]
Now, here's a curious thing. We're now going to look for instances of this intersectional-map object in memory. I'm going to give a few examples of what might register as positive hits.

What we see above is an array of matches for this intersectional-coordinate set, with some other animals: lets say some other cats, maybe dogs too, and other similarity sized mammals. Whereas before, with P-, we saw a recall of a lot of different instances of a cat from different angles, this time, here the same P- code looks for isomorphic matches across the intersectional maps of objects. This is essentially the contentless symbolic "image" which we see so many V- (Ni) types registering behind an object. In this example I'm using a very physical example to demonstrate a frame (i.e. the animal 'form') but what's special about V- (Ni) is how this applies in abstractions too. But I'll get to that in a sec.
# If an instance of the object is found
IF objInstance != undefined do
# Add the instance to an array called allInstances
APPEND objInstance to allInstances
END IF
END FOR
and...
# Update the object to the precedent that was constructed
theObject = intersectingObject
With this final bit of code, all of these instances in memory, which match the intersectional isomorphism of theObject, become the new definition of the object. So theObject is now defined as an array of the intersections within that single cat, as they span across other previous objects. So if we were to superimpose the total recall of V- (Ni) onto the main scene, for the sake of coming back full circle, we'd get something like this:

^ theObject (the cat) has brought forth a chain/web into short-term memory, composed of an array of intersectingObjects that are isomorphic to each other. And the totality of those objects is now the definition of the cat.

Abstraction

Okay, at this level, the operations of V- (Ni) may even be intuitively sensible/relatable to types without V processing, but that's because I chose an analogy that was necessarily simple. Now I'd like to give a different analogy. We'll take this as the initial object (the scene itself):

There's a woman who is pleading to a king or nobleman. We don't know the context or what's happening. But V- would find the conceptual structure of the image and find isomorphic parallels to it, which then become the chain (larger pattern) in which this scene belongs. We may see...

The composition above is an example of five scenes which share the isomorphic map pattern, while being different in content. As you can see, the first scene is the poor woman pleading at a king or nobleman, the second is Teresa, here as a sinner, praying to Christ. The third is Brother Juniper and a beggar. The fourth is a nobleman holding the hand of a queen in what might be a confession of love, or a supplication. The fifth is a marriage proposal from a nobleman to a woman.
Assuming this is all part of a recollection of isomorphic intersection objects/scenes, the situation with the women pleading with the nobleman -- becomes extended (i.e. continuous) to be in some way synonymous with the dynamics of every other connected scene. And this goes both ways, and also applies to the recalled scenes. Giving a marriage proposal is isomorphic to a woman pleading with a nobleman, or a sinner praying to God, or a beggar asking for food. The "skin" of the scene is interchangeable, while the relationship between the child elements is retained.

In all of them there is one on their knees, with their arm out, and there's a higher authority who is receiving the supplication and contemplating their response. This scene may even be called "archetypal" - in that it exists in a trans-temporal space, across humanity and all of history. For a highly abstracted V- operation, then, this scene may be seen as just the latest rendition of a structurally coherent motif that permeates history. Not only that, but each of those 'instances' of its permeation.. informs.. and contextualizes the present instance, so that while this is happening 'right now', it is as though all of those other scenes are also happening 'right now' (due to the application of theObject = allInstances). Therefore, more than this being an mere exercise in correlation-making, for V-, this becomes the reality of the 'now.' It is not so much a metaphor of hypothesis to V-, but the actual, persistent experience of theObject.

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