From Cognitive Typology Wiki
Jump to navigation Jump to search
Part of a Model 2 series on



View Computation Index

J+ (pronounced: /ʤeɪ plʌs/), also known as Procedural Processing, is a function module in the cognitive typology architecture responsible for managing vector object types. It works to calculate how objects move in the world through vector-interactions with one another. J+ corresponds to Je in Model 1.


The operation of J+ is represented computationally using pseudocode, allowing it to be syntactically convertible to any programming language. The following code is a representation of J+ as of Dec 8, 2020.

	# Load the necessary assets
	IMPORT jSystem
	SIDELOAD motorSystem
	SIDELOAD languageSystem

	# Define all objects as their vectors
	theObjects = GET theObjects vectors

	# Define the ideal order as exactly 1
	theOrder = SCALE theOrder to 1

 	# Run a loop on each object-vector
	FOR i = 1 to theObjects length do

		#Measure the caliber, as a decimal, of each object against theOrder
		currentSituation = theObjects[i] / theOrder

		# Subtract the difference between the currentSituation and theOrder
		theDifference = theOrder - currentSituation

		# Filter out objects with differences lower than half
 		IF theDifference < 0.5 do
 			FILTER theDifference

		# Add theDifferences to a new array
 		APPEND theDifference to newOrder

		# Arrange the object-vectors into a new arrangement based on the greatest differences
 		newOrder = SORT newOrder by DESCENDING
	# Pass this information to adjacent systems
	PASS newOrder to motorSystem
	PASS newOrder to languageSystem

	# Update the ideal order to the new result, for the next cycle
	theOrder = newOrder


Diagram of J+ structure

The function begins by loading the necessary libraries for its operation: the judgment, motor and language systems. It then takes the array of objects in the environment and re-defines objects only as their vector properties. Objects have more properties to them than vectors, but the J+ operation, in isolation, treats objects only as their vectors. Next, each object-vector is compared against the latest ideal (theOrder) to evaluate its caliber (or proximity to the ideal), where the latest ideal would equal 1. This converts all object-vectors into decimals between 0 and 1, each measuring their merit (caliber) in relation to the ideal. This becomes the currentSituation of the object-vector. The difference between the currentSituation of the object-vector and the ideal Order is then calculated as theDifference, denoting how much each object-vector would need to change in order to resemble the Order. This difference is then stored in a new array called newOrder and arranged into a hierarchy of most to least in need of adjustment towards order, essentially acting as a sequential list of instructions. Objects with little need for adjustment are filtered/removed. This information is then passed onto the motor system and language systems as an array, where the array can be read as a list of instructions to execute, to actualize the newOrder into reality. However, J+ by itself does not handle external locomotion, and only computes what the new ordering would be - allowing the rest of the body to decide what to do based on all other considerations. At the end of the cycle, theOrder is changed to the newOrder, updating the standard in use for the next cycle.

Emergent Effects

The following effects result from the code above playing forward across thousands of cycles, generating highly abstracted objects.

J+ Causal Understanding

The continual application of theObjects = GET theObjects vectors causes objects to register as vectors at both microscopic and macroscopic scales. Over the course of time, abstract object-vectors are registered by J+ as complex vector sequences. A car, as an object, is registered as "a-driving-thing", a knife is "a-cutting-thing" - where driving and cutting are sequences of specific actions/vectors forming one meta object-vector. Abstract objects thus become synonymous with their corresponding vector sequences. As a result, the difference between the currentSituation and theOrder becomes an array of vectors or actions that can be executed in necessary sequence, to bridge the divide represented by theDifference = theOrder - currentSituation. The abstraction of object-vectors into vector sequences eventuates naturally into an understanding of causality, or the net difference between an initial condition and the outcome.

J+ Explicit Deductive Reasoning

The J+ process is also connected to the linguistic centers through PASS newOrder to 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 newOrder to motorSystem. This passes the object-vectors of J+ to the motor cortex, where it may physically execute object-vector changes 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.