Model 2: J+ Procedural Processing

Home Page Forums Cognitive Functions Model 2: J+ Procedural Processing

  • Auburn
    Keymaster
    • Type: TiNe
    • Development: l--l
    • Attitude: Adaptive

    Hello,

    Here is a first draft of the Model 2 definition of J+ (Je), minus the code: link. Although the finalized code is pending, I hope the computational reasoning is evident to see. This article follows from the previous articles such as the CTA & Objects. I’ve copy/pasted the main text below:



    Computational Effects

    The following effects result from the code above playing forward across thousands of cycles, in its registration of objects.

    J+ Causal Understanding

    The continual application of get_objects[í].vectors; causes J+ to register an object’s vector with each cycle. When this happens over sufficient time, the vectors of objects are observed not only for the linear path they follow, but for how they change their trajectory based on collisions with other vector-objects. In the same manner as Feynman diagrams, vectors are soon understood as hitting one another and being moved by this interaction. This causes the registration of vectors to eventually become an understanding of causality. Then, when higher abstraction is introduced, mental objects are registered by J+ as being in possession of complex vector-sequences. These objects then become synonymous with their corresponding vector sequences. A car is “a-driving-thing”, a knife is “a-cutting-thing”, and so forth. J+ achieves this causal understanding by integrating abstract vector properties onto objects themselves, and treating objects as units of causality.

    J+ Explicit Deductive Reasoning

    The J+ process is also connected to the linguistic centers through pass.order(languageSystem);. This passes the causal vectors of J+ onto the language center, where they are translated into speech. However, insofar as speech is isomorphic to the pre-verbal processing of J+, the same vector-based-logic will apply to the language that is reconstructed. This results in J+ verbalizing in terms of explicit deductive reasonings, which are isomorphic to vector-interactions. The construct of if→then is the grammatical equivalent of Feynman diagrams. Thus, the thinking of J+ gives rise to a deductive form of logical reasoning and object-oriented explication.

    J+ Procedural Organization

    The J+ process is also connected to the motor centers through pass.order(motorSystem);. This passes the object-vectors of J+ to the motor cortex, where it may physically execute object-vector changes as part of order(objects[í].vectors); towards the proper aim for “order.” The continual application of this cycle will cause J+ to be conscientious and organized in real life. However, J+ is a cognitive process where order is chiefly modeled abstractly by idealizing a new arrangement of vectors. This is experienced as a conceptual solution or desired arrangement. The motor system then may, or may not, carry out the commands that J+ posits would lead to order, given other real-world constraints.

    • This topic was modified 2 weeks, 1 day ago by Auburn.
    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 1 week, 1 day ago by safsom.
    • This reply was modified 1 week, 1 day ago by safsom.
    Auburn
    Keymaster
    • Type: TiNe
    • Development: l--l
    • Attitude: Adaptive

    @safsom Oh, I see the problem, I think.

    Come to think of it, Je also is a valuing process, like Ji, in that it measures the caliber of vectors (their effect/impact/relevance) in relation to Order, yes. So both Ji and Je would ‘judge’ an object’s properties against an  [ ideal ] (mono or order), and give objects a “score/value”, which for Ji is the monistic caliber, and for Je that could be its effective caliber – or impact, as you put it.  This value/score is indeed a necessary step for measuring against the ideal. What do you think of this?

    • This reply was modified 1 week, 1 day ago by Auburn.
    • This reply was modified 1 week, 1 day ago by Auburn.
    • This reply was modified 1 week, 1 day ago by Auburn.
    • This reply was modified 1 week, 1 day ago by Auburn.
    • This reply was modified 1 week, 1 day ago by Auburn.
Viewing 3 posts - 1 through 3 (of 3 total)
  • You must be logged in to reply to this topic.

© 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