Difference between revisions of "Holon mechanism"
(from Holarchy section) |
m (Nad moved page The holon mechanism to Holon mechanism without leaving a redirect) |
(No difference)
| |
Revision as of 14:42, 8 April 2024
|
Contents
The mechanism
The system as we've introduced it so far, is a nice-to-have system organised into a tidy philosophical package. But it's just an academic curiosity if we can't represent it with a clearly definable "nuts and bolts" mechanism. In other words what data structure is involved at a program level and how the code operates on it to bring about our two axes that combine to yield the quadrant behaviours.
We introduced the four quadrants above as coming from the individualised form of the class-instance concept being extended to also include a collectivised form of the pair. In this section we introduce a data structure and a process operating on it that brings about just such a basic individualised form of the class and instance concept. And it has an inherent complimentary process that represents the collectivised extension, thus yielding the four-quadrant basis.[1]
For the purposes of this discussion, we start with the assumption that we have a local hierarchical namespace functionality such as an associative array. This assumption is fine in the context of information technology, but in the context philosophy we must even define the mechanism of names and symbols which is beyond the scope of this article, please see our Four quadrant holon philosophy article for our thoughts on this aspect.
What this foundation gives us in terms of the holarchy is the possibility to create graphs of holons that can contain arbitrary content and relationships to each other. Holons here are within a typical key:value pair space in which the keys are always class-names and values are always instances of that class. Note that we don't depend on the concepts of class and instance existing within our executional context, these concepts are provided by the four-quadrant holon mechanism extending the basic associative array functionality.
Two trees
In terms of data structure, class and instance are a pair of graphs that each relate the single set of holons together in two distinct, but complimentary, grouping strategies. We call these two structures trees, although technically only the instances are connected in the form of a true DAG (directed acyclic graph or one-to-many tree) and the classes are connected as a "semantic network" or "ontology".
These trees are very much like what we see in traditional OOP where there is a structure of live actualised instances and an ecosystem of classes from which instances are instantiated and which determines how they operate.
The instance-tree in the holarchy system is easily understood because it's much like a runtime structure of object instances in any traditional running OO program. Instances control a set of "child siblings" as a parent context itself being a sibling performing a function in the next layer of abstraction higher.
As discussed above, the class aspect of the system as a semantic network or ontology, which is formed from all the many local instances of each class. This aspect of connectivity is not so intuitive, because in traditional OOP there is no inherent connection between instances by virtue of them being of the same class.
The class tree is created by a global process of merging all variations of the class across all the instances of it in the tree. The class tree does not define how variations can arise, just how to integrate them into a global whole if they were to arise somehow. The class tree defines the structure of classes, and as a whole defines the shared unified ontology of classes.
The merging of variations essentially means that the parent-child relationships in this tree are not black and white, but rather each relationship is itself a tree of optional relevant variations.
Instances take on the form defined by their respective classes, and the classes are the collective product of their instances. So the class-instance relationship is in the form of a co-evolving feedback loop.
The two-tree process is a way of permitting a tree to extend itself within subjectively. This leads to two separate graphs of one set of nodes, each having an inside-outside perspective of scope that together constitute the subjective world of meaning within. From here the four quadrants can be actualised by allowing mergeable process execution within the context of each scope-pair.
Multiplexing
The two trees are created, maintained and related by a simple process called time-division multiplexing.[2] This is a process by which a continuous flow of executional focus is quantised into arbitrary[3] units which cyclically iterate the entire instance-tree structure.[4]
This iteration process is a movement of executional focus from one node to another. When focus enters a node it's akin to the calling of a function (sub-routine) in a program, because it's moving "down" into a more specific context that is deeper within the structure. Conversely the leaving of focus after completion corresponds to the returning from the function back up the "call-tree" to the "caller" above. The movement downward is a process of division of focus, and the movement upward is a process of information integration, aggregation and propagation "upward", "outward" or "beyond".
As with traditional OOP, or indeed with organisational structure in general, this vertical directionality gives rise to a structured scope system where there is an outer public side and an inner private side to every node. These correspond to the outward-facing and inward-facing concepts in Koestler's holon model, to the outside and inside of a biological cell, or to the public and private property contexts of organisation.
In the holon, the kind of time being multiplexed is executional focus (or agentic attention more generally). The multiplexing movement of focus throughout the structure is a repeating pattern determined by the structure itself. This pattern exhibits a continuous bidirectional flow of function-like calling and returning. This can be considered as a way of representing organisational structure in general.
The multiplexing pattern of focus moving amongst the scopes is what creates hierarchy and its return. Objectively it's just a flat graph, but the movement of focus over time creates the subjective perspective of hierarchy seen from within private scopes. The return flow makes possible the sharing of structure amongst these perspectives.
Multiplexing in this way can be considered as the "collectivised" version of function calling. The compliment of function-calling is to return the result of action, which taken to it's collectivised version is a scale-independent merging or aggregation operation.
Multiplexing is the mechanism behind our implementation of the blackboard pattern and its decoupled approach to private scope. We now have a system where the operation is decoupled both horizontally (blackboard and production-rules) and vertically as well via the "collectivised" function calling and returning model.
The multiplex: This name refers to the concept of a actual running multiplexing instance, occupying real space, in a particular state and requiring real resource for its continuance and progress. The multiplex only has meaning from within the subjective perspective (described above).
- lead out with connection back to four quadrants
The diagonals
The diagonal axes were introduced above as being the form of the second abstraction layer of the model that connects the the four quadrants into the evolutionary and economic feedback loops. In this section we look at how they're an inherent aspect of the mechanism we've described that gives rise to the class-and-instance concept.
By default, the layer one dynamic that bought about the class-and-instance (the multiplexing and its complimentary aggregation process) are also present in the inner subjective scope too (because the scope is extending this dynamic). In the inner scope, we have one diagonal extending the class concept with the objective dynamic, and the other diagonal extending the instance concept with it. In this section, we'll first look at how the diagonals come about in this mechanism, and then go into the details of what they mean conceptually.
The diagonals come from the fact that there are only two ways of combining the horizontal and vertical axes. Conversely we can say that with each quadrant interacting only with its opposite partner, the two original dipoles can be embodied.[5]
The diagram to the right shows the two different ways of combining the original pair of axes. The ends of each axis have been assigned a letter so we can keep track of which are present in the combined results. Each way of combining the axes leads to a new axis connecting a combined pair of ends as shown by the green arrows. These green arrows can then overlaid on the original pair oriented orthogonally to each other, revealing that the green arrows connect the quadrants diagonally.
Executional focus appears in each of these four scope-compositions in order to create the first layer class-and-instance mechanism. Each of these sessions of focus can be extended with a second-level process which yields the two diagonal loops.
This diagonal axis that consists of the top-left and bottom-right quadrants is the evolutionary loop, and the axis orthogonal to it consisting of bottom-left and top-right is the economic loop.
The evolutionary loop is a feedback loop involving knowledge embodiment and use, and its metrics and selection. The information being aggregated here in this layer two extension is agent centric (knowledge performer), which extends the layer one aggregate that is purely related to the knowledge being performed, not to the performer of it. In other words, the class of behaviour is extended with its instances and their performance.
The economic loop is a feedback loop between producer and consumer. Producer is like the "service provider", defining the terms of engagement and selection. Consumer is the source of demand that animates the flow of resource. The information being aggregated in this layer two extension is the commitment-backed supply and demand. In this diagonal axis, it's the first layer instance context that gets extended by the layer two aggregate information. This loop is the layer two view of the "calling" and "returning" cycle set up by the multiplexing in the first layer.
Intersection of evolution and economy
- past and future, knowledge and economy, class and instance
The purple dot in the centre of the diagram is the aforementioned starting point for our description, the focus. The diagonal axes intersect in the centre forming the focus. In this way, the present moment is the intersection of the future and past axes, and the synthesis of the four quadrants of focus.[6]
These perspectives all come together at the conceptual centre of the holon as the subjective self in the here and now. By every holon behaving in both these ways at every scale, a unified holistic evolving indeterminate harmony emerges.
This central point of focus is the intersection of the two diagonal axes, and is shown in the diagram as the purple dot in the centre. Each quadrant's effect on the local shared scope is in accord with its specific conceptual meaning. The process by which the quadrants "come together" in focus, is that each of the four receive independent attentional focus (the attentional energy the holon controls is divided internally into four).
Relevance
- relevance and dependency form the back-bone of the holarchy, form the structure
- relevance and dependency are similar, just that the latter necessary while the former is optional
- relevance is evolutionary
Focus is in the present, but interacts with the past and the future. When in focus, each axis connects their own two quadrants by a matching process.
The past axis is all about agency, the agency that's needed for production in the bottom-right, and the reputable candidates to perform it in the top-left. These comes together in the centre as the relevant candidates.
The supply and demand nature of the future axis match in the middle to yield a potential flow of exchange and production. Potential means that there is nothing missing in terms of local resource, actualisation is a matter of commitment to a process that can achieve it.
This matching process can be performed by the cheapest agency, but can also be guided by any agency present that might choose to intervene. The focus of a holon is within the present moment which is the synthesis of the four quadrant aspects. The matching process at the intersection of the axes is the mechanics of the cognitive architecture. This abstract centre point is the elusive Self in the here and now from the subjective perspective of the holon.
The most relevant types of activity through which energy can potentially flow become prominent from matching the past with the future. Over time this process guides the allocation of energy over the complex landscapes of intention and production to yield the evolutionary collective aspects of ontology and economy.
To merge or maybe not
All activity that takes place in the system is in the form of potentials being reduced by action. The potentials are all in the form of two class names, one as parent and the other as child. This connection once completed generates reputational data which enables the continuously improving local control loops and evolution of the collective.
Both sides of the match are an axis, but are essentially a class-name, so it's really class names themselves that comes with the special non-local extension. Primarily as the extension of instance into the name-connected graph, then in their connection with other names in the parent-child relationship the non-local aspect extends further to the future and past forms of non-local information.
Scale-independence
- subjective non-locality
- decoupled operation (horizontally and vertically)
- continuous-able - scale-independence is not only about size and depth, it's also discrete/continuous agnostic
Multiplexing is a scale-independent process, which means that the same dividing process applies to arbitrary depth (and may be part of larger structure beyond), forming a hierarchy of threads from what is ultimately just a single thread. The width or depth of any local group of threads is all arbitrary in the sense that the multiplexing mechanism itself is content agnostic.
The cycle of top-down and bottom-up movement is used to create the class-tree. Since the process is responsible for dividing the executional focus throughout the whole instance tree cyclically, it also has the option of using a portion of that focus unconditionally for maintaining the class-tree.[7]
Classes are not associated with any specific time or location, which is why the class-tree is called abstract and non-local.
The two trees define the different scopes of operation within the holarchy system. The class-tree defines non-local scope which groups all instances of the same class together regardless of their whereabouts in the holarchy.
The non-local connection of an instance to its class-group does not occur instantaneously, it only appears so from the local POV since it happens between successive quanta of focus at that level. The instance-tree defines public scope (public is not necessarily actually public, it simply means not encapsulated) and private scope which correspond to a specific locations and times.
The general structure of the ontology is defined by what is established in usage. Which path variations are chosen locally becomes a non-local landscape of variation tied to the contexts they appear in. The ontology is thus a semantic network formed by established and evolving dependence and relevance.
Revisiting first-class citizenry
- the origin is private-scope and the concept of encapsulation
- this means the child is responsible for its own actions, and for apprehending the conditions
- encapsulation makes the system decoupled vertically, the essence of scale-independence
- this is the self-assertive behaviour, the support of true autonomy by the collective, and the source of sovereignty and liberty
Mechanism conclusion
First we introduced the four quadrant system generally as a model and what it means from a real-world organisational perspective. We finished that discussion by tying the system in to it's overall alignment to scale-independent harmonious organisation.
Then we introduced a specific mechanism that represents this four-quadrant model. This mechanism is simple and symmetrical, and is entirely mechanical in the sense that all its interactions depend entirely on its own structure and state.
The first abstraction layer is just a pair of tree structures changing in accord with a process that operates in accord with the structure of those trees, yielding a self-organising tree-pair. The behaviour of each tree is simple and deterministic, but yet they're complimentary, and together they open up a second abstraction layer in which the class-instance concept is manifest and usable.
This second abstraction layer is the same dynamic again, but this time in the local private context of subjective value. This local scope takes the form of the two diagonals, the economic and evolutionary loops. Even though this second layer functionality involves high-level concepts, it's still entirely mechanical, extending the first layers dynamics recursively within with the same dynamic again.
This is an amazing conclusion which is hard to believe[8]. It's showing us that there's a class-instance concept inherently hidden within the simple process of multiplexing (combined with its complimentary aggregation process), which is itself amazing. But it goes further saying that when used within the context of itself, this same dynamic reveals the high-level feedback dynamics of evolution and economy. The multiplexing dynamic when connected back onto itself inherently manifests holarchy, the self-organising holarchy of self-organisations.[9]
