Structure of the NDDI Node

3. Structure of the NDDI Node

Components · D-section · Values · Activities · Connectors · Facets

3. 1. General Principles

NDDI is the only type of entity in the GNET network. Everything that exists in the network is NDDI and the relationships between them. Operational networks (OPNT), administrators (ANOD), D-component repositories, sensors, effectors — all are NDDI, differing only in their component composition.

NDDI consists of components. A component is the elementary unit of a node, possessing a value, status, and the ability to participate in relationships through connectors. A component is not just a variable. It is a feature of the node: value + status + connectors + metadata. Components of the same type can be grouped for visualization purposes — facets of the NDDI polyhedron (v-facet, a-facet, d-facet, etc.).

Not all component types are present in every NDDI. The set of components is defined by the D-section — and it is the D-section that is the first component to consider, as it creates the NDDI as an entity.

Order of component emergence. D-components are primary. They represent object code (ELF) stored in the repository node. Until the D-components are assembled and linked, the NDDI does not exist as a living entity. When D-components are linked and the resulting code is executed, V-components (values) and A-components (activities) appear. The set D + V + A gives a minimally living node capable of storing values and responding to inputs. This is sufficient to create a network at the SERN level.

As new D-components (genes) are added and relinked, higher-level components appear:

The evolutionary hierarchy of DOM from Book 1 (GTOM) is reflected in the component composition of NDDI: each new DOM level consists of new D-components (genes) which, when linked, generate new types of components in the node.

Persistence. An NDDI is created forever and is never deleted — similar to neurons in the human brain. The created node with all its components and grown connectors is placed on permanent memory storage, which is its primary storage location.

For activity (reacting to incoming relationships, computations, transmitting values through connectors), the NDDI must be activated in RAM. However, the primary storage remains permanent memory.

Critical data — components with external connectors, connectors with counter-names, the D-section — are always synchronized with permanent memory. Writing critical data is a synchronous operation, similar to transactions in a DBMS with a strict ACID model. This causes delays — but guarantees that in case of any failure, no relationship is lost and no critical value is corrupted.

Non-critical data — internal variables, intermediate computations, caches — can exist only in RAM and are lost upon node deactivation. Upon reactivation, they are recalculated from critical data.

Traditional model: the program lives in RAM, sometimes saved to disk. GNET model: NDDI lives in permanent memory, sometimes activated in RAM for computations. Permanent memory is the source of truth. RAM is cache.

3. 2. D-Components (Node DNA)

D-components are primary — without them, the NDDI does not exist as an entity. All other components (V, A, L, R, B, T, S, N, P, C, W) appear as a result of linking and executing D-components.

Nature of a D-component. A D-component is compiled object code in ELF format (relocatable .o file). By analogy with biology, a D-component is a gene: an independent module that in isolation is just a record, but when assembled with other genes produces a living organism.

D-components are stored in two places:

1. 

   In repository nodes. These are specialized NDDI containing libraries of D-components — the "gene pool" of the system. Repositories are the source of genes for creating new nodes. OPNT accesses the repository, selects the required D-components and assembles a new NDDI from them.

2. 

   In the D-section of a specific NDDI. After the node is created, its D-components are stored in the D-section on permanent memory. They are the primary description of the node, from which the executable code can be reassembled at any time.

Composition of the D-section. The D-section of an NDDI contains:

1. 

   D-components (genes) — a set of ELF object files. Each implements specific functionality: one gene may handle v-relationships, another calculate a b-vector, a third handle internal activation logic. The number of genes determines the complexity of the node.

2. 

   Linker scripts (.ld) — rules for assembling genes into executable code. Main function: fixing absolute LOCN addresses for components with external connectors. The linker script tells the linker: “variable v_component_1 MUST reside at address 0x00001000”. This guarantees that external connectors of partners remain valid after any relinking.

3. 

   ELF tables of the linked program — symbol table, Global Offset Table (GOT), relocation table and other service structures. Required for the operation of linked code and for subsequent relinking.

Linking. When creating an NDDI (or when receiving new D-components via d-relationships), linking is performed: the linker takes D-components and linker scripts and assembles executable code. During linking, all references to components with external connectors are rigidly bound to their absolute LOCN addresses.

Relinking. When a new D-component is received via a d-relationship from another node, the gene is added to the D-section. Relinking does not occur immediately — it is performed during the node’s inactivity period (analogous to biological sleep and default mode network). The new code is assembled in a backup area, and only upon successful assembly does an atomic switch to the new code occur. In case of assembly error, the node continues to run on the old code. Data (V-components) are not affected — their LOCN addresses are fixed and preserved during relinking.

Transfer of D-components (d-relationship). D-components can be transferred from one NDDI to another via a d-relationship. This is the mechanism of “horizontal gene transfer”. A d-relationship always uses confirmed delivery mode — loss of even one byte of object code is unacceptable.

3. 3. V-Components (Values)

A V-component is an analogue of a variable in the von Neumann architecture, but a more complex structure. A V-component is a value written to a memory cell, plus its statuses, connectors and metadata.

Value. A numeric value of a certain format: integer (int32, int64), floating point (float32, float64), or array. The format is determined by the D-component that created this V-component during linking.

Status. A V-component can be in the following states:

1. 

   Actual — the value is calculated and is current.

2. 

   Changed — the value was updated by an incoming relationship but has not yet been processed by an A-component.

3. 

   Undefined — the value is not initialized (after a cold start).

Changing the status to “Changed” is a trigger for activating A-components.

Connectors. A V-component can have any number of incoming and outgoing connectors (POCN). Through incoming ones, the node receives values from other NDDI. Through outgoing ones, it transmits its value to others. All connectors of a V-component participate only in v-relationships.

Criticality. A V-component with at least one external connector is critical: its LOCN is fixed forever, its value is synchronized with permanent memory. A V-component without external connectors is non-critical.

3. 4. A-Components (Activities)

An A-component is a pair (event + handler). Event = change of a V-component via an incoming connector. Handler = function from the Code Section. A-components define behavior: what the node does when it receives a new value.

Nature of an A-component. An A-component is a pointer to a function in the executable code. When a V-component changes to “Changed” status, the associated A-component is triggered: control is transferred to the corresponding function, which processes the new value, computes results and may update other V-components.

Two types of A-components.

A-components are divided into two types that determine the nature of the work performed:

Activity Package (APAK — Activity PAcKage). A block of sequential code: one or more instructions executed linearly from start to finish. APAK receives values of V-components as input, performs computations and writes results to other V-components. Analogue: function body in C/C++/Rust, block { ... }, sequence of processor instructions. Visualized as a pink rectangle.

Activity Iota (AIOT — Activity IOTa). Logical transition: a branching point that, based on a condition, directs the execution flow to one of the packages. AIOT does not perform computations — it only evaluates the condition and chooses the path. Analogue: if/else, switch/case in C/C++/Rust, conditional jump jne/jmp in assembly. Visualized as a yellow hexagon.

Together APAK and AIOT form the execution graph inside the NDDI: packages perform computations, iotas control the flow. This is analogous to a flowchart, where rectangles are operations and hexagons are conditional transitions.

Example: an incoming v-relationship writes a new temperature to the V-component “sensor_temp”. This event activates an AIOT, which checks: is the temperature above the threshold? If yes — control is passed to the APAK “alarm”, which updates the V-component “alarm_state” and triggers sending via an outgoing connector. If no — control is passed to the APAK “normal”, which updates the V-component “status”.

Chain of reactions. Updating one V-component activates an A-component (APAK or AIOT), which may update another V-component, which activates the next A-component — and so on. The chain continues until all updated V-components have been processed. This is analogous to the propagation of excitation in a neural network.

Outgoing relationships. If during the reaction chain a V-component with outgoing connectors is updated, a splice-datagram is formed for each connector and transmitted to the network. The node’s internal activity generates network events.

Connection with D-components. The functions pointed to by A-components (both APAK and AIOT) are defined in D-components (genes). During relinking, A-components are updated — pointers are redirected to the new code. V-components (data) remain in their places.

3. 5. Minimal Node: D + V + A

The set D + V + A is a minimally living node. It is capable of:

1. 

   Existing on permanent memory (D-section stores the code)

2. 

   Being activated in RAM

3. 

   Receiving incoming v-relationships (value is written to a V-component)

4. 

   Reacting to changes (A-component processes the new value)

5. 

   Transmitting results via outgoing connectors (splice-datagram)

This is sufficient to create a network at the SERN level — a sensory-reflexive network in which nodes store values and react to inputs. A closed loop “sensor → processing → motor” is implemented by a chain of NDDI connected by v-relationships.

The minimal node D + V + A is a digital analogue of the simplest neuron: received a signal, processed it, transmitted it. All the complexity of higher levels appears through the addition of new D-components — genes that generate new types of components.

3. 6. Higher-Level Components

As D-components (genes) are added to the D-section and relinked, higher-level components appear in the node. Each higher-level component type inherits the properties of a V-component (value + status + connectors + criticality), but adds a specific value format and a specific type of relationship.

L-component (Location, DOM1). Position of an object in the spatial map MAP1. Value: coordinate vector. L-relationships link L-components of different nodes to build an allocentric model of space.

R-component (Recognition, DOM2). Invariant object recognition. Value: Feature Vector — a compact representation, product of the convolutional neural network CNN1. R-relationships transmit Feature Vectors between nodes.

T-component (Target, DOM3). Target state of an object. Value: coordinates or parameters of the target state. T-relationships link nodes in the context of goal-setting.

B-component (Behavior, DOM3). Splice vector of the physical level (b-vector). Value: pair of states — initial and target. B-relationships transmit behavioral impulses — directed changes in physical space.

S-component (Symbolic, DOM6). Symbolic component without spatial binding. Value: vector in semantic space, product of the convolutional neural network CNN2. S-relationships link symbols between nodes.

N-component (Narrative, DOM8). Narrative structure. Value: element of the KLEN triad graph. N-relationships transmit narrative structures between nodes.

P-component (Predicate, DOM8). Predicative splice vector of the symbolic level. Value: identifier of KLEN triad + relationship weight. P-relationships establish semantic links between symbols.

C-component (Concept, DOMA). Concept. Value: vector in MAPA space, product of the convolutional neural network CNN3. C-relationships transmit Concepts between nodes.

W-component (Widerspruch, DOMB). Contradiction vector. Value: distance between two C-components (C-is → C-ought). W-relationships transmit motivational impulses.

Each component type participates only in relationships of its own type. This is strict typing: the splice-datagram contains the relationship type, and the receiving side checks the correspondence between the packet type and the target component type.

3. 7. Connectors (POCN)

A connector (POCN — Point Of CoNnection) is a data structure that enables a component to participate in a relationship with another node. Visually, a connector is represented as a pin (outgoing) or socket (incoming) on the body of the component.

Each connector is a separate data structure with its own LOCN and contains:

Dynamic creation. Connectors are created during the node’s lifetime via the SYGN protocol (Chapter 4). A new connector is a new “synapse”: a data structure is created, a LOCN is assigned, and the counter-name is written.

Directionality. A connector is either incoming (socket — receives values) or outgoing (pin — transmits values). One relationship between two nodes consists of an outgoing connector on one side and an incoming one on the other. For bidirectional exchange, two relationships are required.

Multiplicity. One component can have any number of connectors. A V-component with three outgoing connectors transmits its value to three different nodes simultaneously. A V-component with five incoming connectors receives values from five sources.

Criticality. All connectors are critical data: their LOCN is fixed, their counter-names are saved to permanent memory. Loss of a connector means breaking the relationship.

Transmission mechanism. When a component is triggered (its value changes), the node’s code iterates through all outgoing connectors of that component and forms a splice-datagram for each, containing the counter-name (UNON+LOCN of the partner) and the new value. The splice-datagram is passed to the routing system, which determines the delivery level (G1/G2/G3) and sends the packet.

Analogy: component — neuron. Connectors — synapses. One neuron can have thousands of synapses, each leading to another neuron. When the neuron is excited, the signal is transmitted through all synapses simultaneously.

3. 8. Sensory and Effector Components

Some NDDI contain components connected not to other nodes via connectors, but to physical devices.

Sensory component — a V-component whose value is determined not by an incoming relationship, but by a physical signal: light, sound, pressure, temperature, voltage. A sensory component is the entry point of the GNET network: physical reality enters the network through the values of sensory components.

Effector component — a V-component whose value change leads not to the formation of a splice-datagram, but to a physical action: motor movement, sound generation, voltage change. An effector component is the output point of the network.

At the GNET specification level, sensory and effector components are indistinguishable from regular V-components. Other nodes see only UNON+LOCN and the component type. The difference exists only at the GATE platform level, where specific LOCN are bound to hardware registers.

3. 9. Facet of the Polyhedron

For visualization of NDDI, the polyhedron metaphor is used. Each facet contains components of one type:

1. 

   D-facet — D-components (code, genes, linker scripts)

2. 

   V-facet — V-components (values)

3. 

   A-facet — A-components (activities)

4. 

   L-facet — L-components (positions)

5. 

   R-facet — R-components (recognition)

6. 

   T-facet — T-components (targets)

7. 

   B-facet — B-components (behavior)

8. 

   S-facet — S-components (symbols)

9. 

   N-facet — N-components (narratives)

10. 

    P-facet — P-components (predicates)

11. 

    C-facet — C-components (concepts)

12. 

    W-facet — W-components (contradictions)

Connectors are visualized as pins and sockets on the body of components, protruding beyond the surface of the facet. A relationship between two nodes is a wire connecting a pin of one node to a socket of another.

For a cube — three facets are visible simultaneously, which is sufficient in most cases to display the main component types. For more complex nodes, polyhedra with a larger number of facets can be used.

Visualization is a development and debugging tool, not part of the GNET specification.

3. 10. NDDI Lifecycle

Creation. An NDDI is created by the operational network (OPNT). OPNT selects D-components from the repository node, assembles the D-section, and initiates node creation on the GATE platform. The platform assigns a GANN, performs linking of D-components, and places the node on permanent memory. OPNT establishes initial relationships via SYGN.

Activity. When an incoming relationship arrives at a node in an inactive state, the GATE platform activates the node in RAM: loads the code and critical data, passes the received value to the target component, and starts the chain of A-component reactions. After processing is complete, the node may remain active (if new relationships are expected) or be deactivated.

Deactivation. In the absence of activity, the GATE platform may deactivate the node: critical data is already on permanent memory (synchronized via ACID), non-critical data can be discarded, and the code does not need to be saved (it is reassembled from the D-section). Upon reactivation — the code is relinked from the D-section, critical data is loaded from permanent memory.

Relinking (evolution). When a new D-component is received via a d-relationship, the gene is added to the D-section. Relinking is performed during the inactivity period. The new code is assembled in a backup area. Upon successful assembly — atomic switch to the new code. In case of error — the node keeps the old code. Data is not affected: LOCN addresses are fixed and preserved during relinking.

Relinking during inactivity is analogous to biological sleep and default mode network. The system accumulates new D-components during the active period and rebuilds its architecture during rest. “Morning is wiser than evening” — because during the night the D-section was relinked.

Non-deletability. An NDDI cannot be deleted in the usual way. Deletion is possible only by a privileged administrator (ANOD) in exceptional cases and is accompanied by notification of all nodes that have connectors to the deleted NDDI, for correct breaking of relationships.

3. 11. Transition to Chapter 4

This chapter defined the internal structure of NDDI: components as elementary units of the node, D-components as primary (creating the NDDI as an entity), V and A as the minimal set for a living node, higher-level components, connectors as points of participation in relationships, and persistence as a basic property.

Chapter 4 defines the format of the splice-datagram — the packet that implements the relationship between nodes — and the detailed specification of each type of relationship.