# Adaptive Information Processing Network ## Concept v0.1 **Status:** Initial draft **Purpose:** Establish a precise conceptual vocabulary for adaptive information-processing networks operating on high-level semantic information objects. ### 1. Intent An **Adaptive Information Processing Network (AIPN)** is a persistent network of semantic information-processing entities whose internal state changes in response to information arriving from its environment. The network is intended to learn regularities in its own operation and in the environment with which it interacts. Learning modifies future activation, prediction, selection, and eventually network structure. Unlike conventional artificial neural networks, the primary entities of an AIPN are intended to retain explicit domain semantics. Typical nodes may represent concepts such as: - `DocumentType` - `Invoice` - `EmployeeRole` - `WorkstationClass` - `SupplierClass` - `Process` - `Capability` - `Goal` - `Risk` - `Observer` Concrete entities such as a particular invoice, employee, document, machine, message, or material occur as information objects that activate parts of the network. The network therefore operates at a semantic level suitable for organizational, business, technical, and socio-technical systems. ### 2. Foundational Idea The system distinguishes between: 1. **persistent semantic structure**, and 2. **temporary concrete activation**. A node such as: ```text Invoice ``` may persist for years. A concrete invoice: ```text Invoice #4711 ``` may activate that node during a processing episode. The persistent network accumulates knowledge from many such episodes. The foundational processing cycle is: ```text Environment ↓ Information Object ↓ Semantic Activation ↓ Activation Propagation ↓ Prediction / Selection / Action ↓ Environmental Consequence ↓ Observation ↓ Feedback Signal ↓ Learning ↓ Modified Network ``` The network is therefore both: - a model of its environment, and - an adaptive mechanism participating in that environment. ### 3. Design Principles #### 3.1 Semantic explicitness Nodes and edges SHOULD have explicit meaning. The system SHOULD prefer interpretable representations such as: ```text Invoice → requires → Approval ``` over anonymous latent dimensions whenever doing so does not fundamentally prevent useful learning. #### 3.2 Structure and activation are distinct Persistent knowledge MUST be distinguishable from temporary processing state. The existence of: ```text Invoice → Approval ``` does not imply that either node is currently active. #### 3.3 Observation and evaluation are distinct The system MUST distinguish: ```text what happened ``` from: ```text whether what happened was desirable. ``` An observation is evidence. A signal is an evaluation or regulatory consequence derived from evidence. #### 3.4 Prediction and utility are distinct An event can be highly probable but undesirable. For example: ```text Complaint → ManualEscalation ``` may have: ```text probability = 0.92 utility = -0.63 ``` The network MUST therefore avoid reducing expectation and desirability to a single weight. #### 3.5 Learning is local where possible Learning SHOULD be attributable to identifiable nodes, edges, episodes, and signals. This supports: - explainability, - debugging, - governance, - intervention, - comparison, - rollback. #### 3.6 Delayed consequences are expected Actions frequently produce consequences much later. The network SHOULD retain temporary evidence that earlier activations contributed to later outcomes. This mechanism is represented by **eligibility traces**. #### 3.7 Goals belong to the modeled world Goals SHOULD be represented within the network rather than existing solely as hidden implementation configuration. Examples: ```text MinimizeCost ReduceLatency AvoidFraud MaintainCompliance PreserveHumanAttention ``` Goal activation may vary with context. #### 3.8 Viability precedes optimization The network SHOULD distinguish: ```text remaining within viable operating bounds ``` from: ```text optimizing preferred outcomes. ``` Some states may therefore be unacceptable regardless of their apparent local utility. #### 3.9 Learning and authority are distinct Learning that an action appears beneficial MUST NOT imply that the system is authorized to perform it. The system MUST distinguish at least: ```text can may does should must ``` where appropriate. This permits learning under constrained authority. #### 3.10 Higher-order structure may emerge Repeated or coherent patterns MAY be represented as new network entities. The network can therefore progressively construct abstractions from recurrent processing structure. ### 4. Core Ontology The minimum core vocabulary consists of: ```text Node Token Edge Activation Episode Context Prediction Action Observer Signal Goal ViabilityVariable EligibilityTrace Chunk ``` These concepts form the initial kernel. ### 5. Node A **Node** is a persistent semantic entity capable of participating in information processing. A node represents a meaningful distinction recognized by the network. Examples: ```text Invoice EmployeeRole WorkstationClass OCRCapability FraudRisk HumanReview CustomerComplaint ``` A node SHOULD possess stable identity independent of its temporary activation state. Conceptually: ```yaml node: id: Invoice kind: DocumentType ``` Useful semantic kinds include: ```text EntityType State Role Capability Process Resource Context Goal Risk Observer Policy Concept ``` A node MAY maintain learned or temporary state including: ```text activation frequency recency confidence memory statistics prediction models utility estimates ``` ### 6. Token A **Token** is a concrete information object participating in a processing episode. Examples: ```text Invoice #4711 Employee Alice Workstation WS-328 Shipment #91284 Customer Request #882 ``` A token MAY activate multiple nodes simultaneously. Example: ```text Invoice #4711 ``` might activate: ```text Invoice SupplierInvoice PDFDocument HighValueTransaction Supplier:Acme MonthEnd ``` Tokens MAY be transient, persistent, externally referenced, or reconstructed from event history. ### 7. Edge An **Edge** is a persistent relationship between network entities. Example: ```text Invoice → requires → Approval ``` Edges SHOULD be typed. Possible examples include: ```text is-a part-of uses requires precedes associated-with predicts enables inhibits routes-to observed-by contributes-to ``` An edge SHOULD NOT be reduced to a single scalar weight. A useful conceptual form is: ```yaml edge: source: Invoice target: HumanReview relation: routes-to association: 0.42 transition_probability: 0.18 confidence: 0.91 utility: correctness: 0.94 latency: 0.31 cost: 0.22 activation: 0.12 ``` ### 8. Activation **Activation** represents the current relevance, readiness, or excitation of a network entity. Activation may originate from incoming tokens, neighboring nodes, current goals, context, prediction, surprise, explicit attention, regulatory state, or remembered association. Activation SHOULD normally decay over time unless sustained. ### 9. Context A **Context** is a semantic representation of conditions that modulate processing. Examples: ```text MonthEnd EmergencyOperation HighSystemLoad CustomerFacing ProductionEnvironment NightShift ``` The network SHOULD be capable of distinguishing: ```text A → B ``` from: ```text A + Context X → B ``` ### 10. Episode An **Episode** is a bounded trace of related network activity. An episode MAY contain input tokens, activated nodes, traversed edges, contexts, predictions, actions, observations, and resulting signals. Episodes provide a unit for learning, replay, explanation, comparison, attribution, experimentation, and auditing. ### 11. Prediction A **Prediction** expresses an expectation concerning future observations or network states. Prediction error arises from the difference between expected and observed outcomes. Both occurrences and absences may be informative. ### 12. Action An **Action** is an intervention generated or selected by the network that may affect its environment. Examples: ```text RouteToHumanReview SendNotification ApproveDocument RequestMissingData DelayProcessing Escalate ``` The concept distinguishes: ```text something happened ``` from: ```text the network caused something to happen. ``` An action MAY be: ```text possible permitted recommended selected executed mandatory ``` These states MUST NOT be treated as equivalent. ### 13. Observer An **Observer** is an entity that evaluates or interprets observations, states, episodes, or consequences. Multiple observers MAY interpret the same episode differently. ### 14. Signal A **Signal** is evaluative or regulatory information capable of changing future network behavior. Signals may represent success, failure, reward, penalty, prediction error, novelty, surprise, constraint violation, human feedback, or viability deviation. Signals SHOULD normally permit multiple dimensions. ### 15. Goal A **Goal** is a modeled desired tendency, condition, outcome, or constraint. Goals participate in processing through activation. Goal conflicts are expected and SHOULD remain visible rather than silently flattened. ### 16. Viability Variable A **Viability Variable** represents a system condition that should remain within an acceptable operating range. Examples: ```text QueueDepth CashLiquidity SecurityExposure OperatorLoad CustomerWaitingTime ComputeCapacity ErrorRate ``` Deviation from viable ranges MAY itself create activation and signals. ### 17. Eligibility Trace An **Eligibility Trace** is temporary evidence that a previous activation, edge traversal, prediction, or action may have contributed to a later outcome. Eligibility traces address delayed credit assignment. ### 18. Chunk A **Chunk** is a higher-order semantic entity representing a recurring or coherent structure. A chunk may summarize a sequence, subgraph, recurring context, workflow, behavioral pattern, or causal configuration. Chunks MAY themselves participate as ordinary nodes. ### 19. Core Learning Modes The initial concept distinguishes four primary learning modes: - Associative Learning - Predictive Learning - Instrumental Learning - Structural Learning An optional fifth is Regulatory Learning. ### 20. Optional Fifth Learning Mode: Regulatory Learning Question: > Which interventions restore or preserve viable system conditions? ### 21. Edge Semantics The network SHOULD distinguish at least four independent properties of a relationship: - Association - Prediction - Utility - Confidence These MUST NOT automatically collapse into one scalar. ### 22. Inhibition Relationships need not only increase activation. An edge MAY inhibit another node, relationship, or action. ### 23. Competition When multiple candidate actions become active, they MAY compete. Selection may depend on activation, predicted utility, confidence, goals, authorization, cost, uncertainty, or exploration policy. ### 24. Attention **Attention** is the allocation of limited processing resources toward selected activations. Attention MAY be driven by high activation, high surprise, high uncertainty, high expected utility, high risk, explicit human focus, or active goals. ### 25. Memory The concept recognizes at least three useful forms of memory: - Structural memory - Statistical memory - Episodic memory ### 26. Temporal Semantics The network SHOULD distinguish co-occurrence, ordering, duration, delay, recency, and periodicity. ### 27. Causality The network MUST distinguish association from causation. Causal confidence MAY be increased through interventions, controlled experiments, repeated counterfactual evidence, external knowledge, or structural assumptions. ### 28. Exploration and Exploitation A purely exploitative network risks becoming trapped in existing behavior. The system SHOULD permit controlled exploration. ### 29. Plasticity Not every network component should learn equally quickly. A useful distinction is: ```text fast plasticity slow plasticity frozen structure ``` ### 30. Consolidation Frequently reinforced patterns MAY transition from flexible to stable representation. ### 31. Forgetting The network SHOULD permit information to weaken. Possible mechanisms include activation decay, confidence decay, edge weakening, evidence aging, and chunk dissolution. ### 32. Structural Formation A potential structural-learning progression is: ```text Level 0 — Fixed topology Level 1 — Edge weight adaptation Level 2 — Edge creation/removal Level 3 — Context-dependent structure Level 4 — Chunk formation Level 5 — Hierarchical concept formation ``` ### 33. Processing Cycle A reference processing cycle is: ```text 1. Observe 2. Interpret 3. Activate 4. Propagate 5. Predict 6. Select 7. Act 8. Observe consequences 9. Evaluate 10. Assign credit 11. Learn 12. Consolidate or forget ``` ### 34. Minimal Formal Model An AIPN may be represented as: \[ N=(V,E,T,G,O,H) \] where: - \(V\) = nodes - \(E\) = edges - \(T\) = tokens - \(G\) = goals and viability variables - \(O\) = observers - \(H\) = retained history or memory A node may be represented as: \[ v=(id,type,state,A,M) \] An edge may be represented as: \[ e=(s,t,r,W,P,U,C) \] An episode: \[ \tau=(inputs,context,activations,predictions,actions,observations) \] Observers generate signals: \[ O(\tau,G)\rightarrow S \] Learning updates the network: \[ L(N,\tau,S)\rightarrow N' \] ### 35. Reference Example: Invoice Processing A concrete token: ```text Invoice #4711 ``` Semantic interpretation activates: ```text Invoice 1.00 SupplierInvoice 0.94 Supplier:Acme 0.87 AccountsPayable 0.76 PurchaseOrderMatching 0.63 FraudRisk 0.11 ``` The network predicts outcomes, selects actions, observes results, and updates eligible structures. ### 36. Example of Surprise If `ApprovedInvoice → Payment` is expected but `ApprovedInvoice → CustomerComplaint` occurs, the event creates surprise and may activate investigation, fraud risk, process anomaly, or human attention. ### 37. Human Interaction Humans MAY interact with the network by providing tokens, activating goals, providing explicit feedback, authorizing actions, adding or removing semantic structure, challenging learned relationships, annotating chunks, changing viability ranges, and constraining learning. ### 38. Agent Interaction Artificial agents MAY occupy the same general roles. The concept does not require a fundamental semantic distinction between human and artificial participants. Authority and reliability may differ independently. ### 39. Governance Boundary Some network structures MUST be capable of being declared non-learnable or only learnable under explicit authority. ### 40. Explainability Requirement Any learned decision SHOULD, where practical, permit reconstruction of: ```text what was active? what was predicted? which actions competed? which goals mattered? which evidence supported the choice? what feedback changed the network? ``` ### 41. Provenance Learned structures SHOULD retain evidence of origin. ### 42. Uncertainty Unknown and uncertain states SHOULD remain explicitly representable. ### 43. Multi-Level Organization The same conceptual machinery MAY operate at multiple abstraction levels. ### 44. Recursion A chunk at one level MAY become a node at another. ### 45. Core Distinctions The following distinctions SHOULD remain explicit: ```text type ≠ instance node ≠ token structure ≠ activation observation ≠ evaluation association ≠ prediction prediction ≠ causation prediction ≠ utility utility ≠ authorization goal ≠ viability constraint action ≠ occurrence confidence ≠ probability learning ≠ execution adaptation ≠ unrestricted autonomy ``` ### 46. Initial Maturity Ladder ```text AIPN-0 — Semantic Event Graph AIPN-1 — Activation Network AIPN-2 — Associative Learner AIPN-3 — Predictive Learner AIPN-4 — Outcome Learner AIPN-5 — Regulatory Learner AIPN-6 — Structural Learner AIPN-7 — Concept Former AIPN-8 — Reflective Network ``` ### 47. Research Questions Open questions include representation, activation, credit assignment, causality, structural learning, stability, goal formation, viability, hierarchy, authority, forgetting, and explanation. ### 48. Initial Implementation Hypothesis A first experimental implementation SHOULD remain modest: ```text one bounded domain 10–50 node types hundreds to thousands of instances a small number of explicit goals several observers fixed topology initially learned association and prediction ``` ### 49. Minimal Experimental Kernel ```text Node Token Edge Activation Episode Prediction Observer Signal EligibilityTrace ``` ### 50. Working Definition > A persistent semantic network whose entities are activated by concrete information objects and environmental conditions; whose activation propagates through learned relationships to generate expectations and possible actions; whose consequences are evaluated by observers and regulatory goals; and whose accumulated experience modifies the network's future activation, prediction, utility estimates, and ultimately its semantic structure. ### 51. Short Form > **Semantic structure + activation + prediction + feedback + adaptation.** Operationally: ```text sense → activate → predict → act → observe → learn → reorganize ``` ### 52. Scope of v0.1 This version establishes the conceptual language. It intentionally does **not** yet standardize storage representation, distributed architecture, graph database model, learning algorithms, message protocols, API formats, numerical activation functions, optimization methods, agent implementation, ontology language, or persistence strategy. ### 53. Proposed Next Artifacts ```text AdaptiveInformationProcessingNetworkConcept.md ArchitectureBlueprint.md ResearchProgram.md ReferenceScenario-InvoiceProcessing.md LearningModel.md NetworkObjectModel.md ExperimentProtocol.md ``` The immediate next useful artifact is probably `NetworkObjectModel.md`, translating the conceptual entities defined here into a precise executable object model while deliberately remaining independent of implementation language or storage technology. --- ## Appendix — Cross-lens notes Added 2026-10-12 under ASSEMBLY-WP-0002-T09, applying `Glossary.md`. These notes connect this concept with the society lens and do not change the sections above. - **Chunks are assemblies at organism scale (§ 18).** In cross-lens or societal statements, use *assembly*. *Chunk* remains the name of the internal mechanism. - **Observers are selection mechanisms (§ 13).** Use *selection* for the process and *observer* for the entity performing it. - **Viability variables (§ 16)** correspond to GADM stock floors. Constitutional floors are non-tradeable (see `NetworkObjectModel.md` § 6.4). - **Action states (§ 12) and agency.** Organisms have *action repertoires*, not agency. *Agency* is reserved for humans and groups. The gap between *possible* and *permitted* is where domination operates at society scale. - **Forgetting (§ 31) is disassembly** at organism scale. - The precise object model for this concept is `NetworkObjectModel.md`.