Reply To: Model 2: J+ Procedural Processing

Index Forums Cognitive Functions Model 2: J+ Procedural Processing Reply To: Model 2: J+ Procedural Processing

safsom
Participant
  • Type: NiTe
  • Development: ll-l
  • Attitude: Unseelie

I must say that I think that the analogy of a means to monitor vector interactions is quite an accurate one to capture the essence of Je – I see it in a very similar way (but also a subtly different way from the one you have outlined here, which I think will be a point of agreement), where the organization of objects in terms of vector-interactions is done so to implement a decision causally in the most efficient manner (in terms of a desired object-interactional component as an outcome). I agree with the computational exposition of the process as one being centered around causality. However, I do not think that these emergent properties (especially those centered around structuring and reorganizing objects efficiently, and using the schematics to do so) necessarily follows from the code that is posted above in the link. To be specific, I think that one of the problems with the code is that there is not the necessary scope-restriction that is essential to Je (and indeed, essential to its optimization-oriented goals).

open_logosSystem;

objects = get_objects[í].vectors;
ready_logosSystem.motorSystem;
ready_logosSystem.languageSystem;

Ok, so far this seems fine. The logosSystem component is loaded (which from seeing this on the Ji post, I assume is a construct unique to the J systems, the conceptual compartmentalization of concepts generally seems benefical here), the vectors of each object (perhaps in terms of a spatial coordinate relative to other objects because of Je’s orientation) is gathered, and the adequate systems for the executive manifestation of however those objects are configured is set up. Assuming that this is something to be taken in isolation, there is absolutely nothing wrong with this setup; except that it has one cardinal limitation, which is that the scope of the objects themselves (i.e what they deal with) is not well-defined, which leads to some problems when it comes to executing the next few lines of code.

foreach (objects[í]) {
if (objects[í].vectors != order) {

order(objects[í].vectors);
pass.order(motorSystem);
pass.order(languageSystem);
}

There is a similarity here to the excerpt pasted on Ji where the state of the vector interactions are compared against some abstract ‘order’ (which I think captures the essentially anti-realist, or rather more accurately anti-perceptual) nature of the J axes However, there are two flaws here. Since the scope of the objects for which the vector interactions were determined (or essentially the set of states that Je operates on) was not defined accurately, a designation as general variable through which the vectors are accessed comes with two possible outcomes; one could be because there is no explicitly restriction on ‘objects’ means that Je works in relation to every vector contained in the object-space at once (which also, by consequence, involves constant environmental intake in relation to that object, because you cannot store the entire environment in a static variable, hence it must be a continually updated value, by the background) with a lack of discrete prioritzation. This is obviously a problem for Je, because while Je is organized (and uses the knowledge of causality to organize), it also realizes on a certain end-state for organization. Now it could be said that this has been provided in terms of order, yet that also refers to any sort of deontologically arranged or even ideal (and not necessarily pragmatic) sense of order – indeed, for Je, the process needs an additional variable to impose a restriction on the ‘object’ set (so it doesn’t regress to infinitely circling environmental input and only takes relevant input), and this should precede “order”. This makes sense because Je’s ordering is done against a specific reference frame or goal, not without it.

Perhaps the most efficient solution to this is to add an extra step, where before ordering the objects, there is a premediated prioritization of those in relation to something like applicablityor impact(which are different from order, as they add a level of discrimination as to what is actually ordered, based on criteria like impact, which is not the same as order, ordering things without impact is impractical categorization, against the nature of Je), so that the vector-space is collapsed to an appropriate set, with a clear goal in mind (from a limited data set), and emergent environmental gathering restricted by that (due to the ‘shaving’ of the value from the whole space, as necessitated by the code above). To provide a quick sketch of how I’d write it:

open_logosSystem;

objects = get_objects[í].vectors;

impact = loadSystem.impactSystem;
ready_logosSystem.motorSystem;
ready_logosSystem.languageSystem;

prioritize(get)objects.vectors, impact); // "shave" unnecessary vectors through impact

foreach (objects[í]) { // no need for "impact" here as it's already been used for shaving
if (objects[í].vectors != order) {

order(objects[í].vectors);
pass.order(motorSystem);

pass.order(languageSystem);
}

else if (objects[í].vectors == order) { // no need for "impact" here as it's already been used for shaving

ignore(objects[í]);

}

 

  • This reply was modified 4 months, 1 week ago by safsom.
  • This reply was modified 4 months, 1 week ago by safsom.

© Copyright 2012-2020 J.E. Sandoval
SEE HERE FOR MORE INFORMATION

DISCLAIMER

The content on this site is not
intended for medical advice, diagnosis,
or treatment. Always seek the advice
of your physician or other qualified
health provider with questions you
may have regarding a medical condition.
For more information visit this link.

SHARE: FACEBOOK, SUPPORT: PATREON