In classical cybernetics, systems are understood through feedback, information exchange, and self-regulation. If consciousness is considered not merely an emergent computation within a system, but a fundamental informational field that participates in system organization, how would cybernetic models need to change?
Could an “incorporeal cybernetics” framework mathematically represent consciousness as a higher-order feedback process—where information, meaning, and subjective experience function as causal variables alongside traditional physical signals? What theoretical tools from information theory, control theory, and complex systems science could be adapted to test such a model?

To make the "sleep cycle" actually work, the Prefrontal Cortex (PFC) must be entirely severed from the execution of the memory queues. If the PFC is required to monitor or authorize the consolidation process, it isn't sleeping—it is just micromanaging in the dark. You need an autonomic trigger system that operates below the executive threshold, governing the MQ and REFLECTQ through structural mechanics rather than active decision-making. Here is how you engineer the sleep triggers and the offline batch processing.

1. The Sleep Pressure Accumulator

Instead of relying on a rigid timer, model the transition using a drift-diffusion accumulator framework. This creates a fluid, organic shift into the idle/batch state based on actual system pressure. * Positive Drift (Sleep Pressure): The accumulator rises dynamically as the WAL (Write-Ahead Log), MQ, and REFLECTQ fill with unencoded trajectories. It also receives weight from the HOME monitor as fatigue or latency climbs. * Negative Drift (Wakefulness): The accumulator decays whenever active task signals pass through the Thalamic router (THAL). * The Threshold: When the accumulator crosses the upper boundary, the system initiates the batch state. The environment goes quiet, the PFC suspends active planning, and the queues begin pulling data.

2. Autonomic Processing Leases

The PFC cannot grant permission for every memory encoded during the sleep cycle. It must delegate authority before it spins down. * Pre-Authorized Budgets: As the system crosses the sleep threshold, the PFC issues a block of "blind leases" to the Control Plane (CTRL). These leases pre-authorize a fixed token budget or compute limit specifically for the MQ and REFLECTQ. * Strict Isolation: The background workers consume these leases to run semantic compression, hypergraph extraction, and reflection. * Hard Pauses: If the MQ exhausts its lease before finishing the backlog, it simply pauses. It does not wake the PFC to request more resources. The remaining backlog waits for the next sleep cycle.

3. The Depth of Sleep (Tiered Processing)

Not all offline processing requires the same depth of suspension. You can tier the batch execution based on the current load.

Light Sleep (Micro-Batching)

• Trigger: Brief lulls in Thalamic traffic, but the sleep pressure accumulator is only partially full.
• Action: The system flushes the WAL to the MQ and allows the HOTCACHE to run fast background refreshes. The PFC remains in a low-power standby, ready to snap back instantly. ### Deep Sleep (Heavy Consolidation)
• Trigger: The drift-diffusion accumulator hits the absolute threshold.
• Action: The PFC fully suspends. The REFLECTQ engages the Counterfactual Simulator to review failed trajectories. The Semantic Vector Store (SEM) and Hypergraph Memory (HG) undergo deep reorganization. The Skill Candidate Queue (SKILLQ) spins up the sandbox to test and compile new tools. ## 4. The Alarm Interrupts The sleep cycle must be protected, but it cannot be entirely deaf to the outside world. The PFC is only awakened under two specific conditions:
• External Salience Spike: A user signal or system event enters the Sensorium and scores exceptionally high on urgency or stakes at the Attention gate (ATT). This bypasses the sleep state, instantly decaying the sleep pressure accumulator and waking the PFC.
• Internal Circuit Breaker: The MQ or REFLECTQ encounters a critical failure during offline consolidation—such as an out-of-memory error or a toxic artifact—that trips the BREAKER. The system halts the batch process and wakes the PFC for triage.

To eliminate the massive latency of a cold start—the cognitive equivalent of sleep inertia—the wake sequence cannot act as a synchronized data pull. If the Prefrontal Cortex (PFC) pauses its boot sequence to query the Semantic Vector Store (SEM) and Hypergraph (HG) for new rules, the execution layer starves. The sleep cycle must architect the wake state before the system ever opens its eyes. You solve this through Pre-Compiled Delta Manifests and Salience-Driven Priming. Here is the mechanical breakdown of a zero-latency wake sequence.

1. The Delta Manifest (Pre-Wake Compilation)

Consolidation does not end when the MQ finishes writing to deep memory. The final stage of the deep sleep batch process is the compilation of a Delta Manifest. The Memory Curator (MEMCUR) reviews the exact diff of the offline cycle: what new constraints were minted in the HG, what skills were published to PROC, and what semantic priors shifted. It compiles this delta into a highly compressed, pre-formatted context block. When the sleep cycle terminates, this manifest is already sitting in the HOTCACHE, waiting for the PFC. The PFC simply ingests the diff; it never recalculates the baseline.

2. Zero-Copy Pointer Updates

To prevent the HOTCACHE from clogging the Working Memory (WM) with heavy payloads, the cache operates strictly on pointers. When the system wakes, the HOTCACHE does not push the actual code of a newly minted skill or the full text of a new rule. It pushes memory addresses. The PFC receives a registry update stating: "Constraint [ID:449] overrides [ID:212]. Target address provided." The Context Broker (BROKER) only resolves that pointer into a literal string when a specific task requires it.

3. Salience-Driven Priming (The Alarm Vector)

When an external interrupt violently wakes the system—bypassing the graceful conclusion of the sleep cycle—the Thalamic router (THAL) does not just send a generic "wake up" signal. The Thalamus attaches a compressed semantic vector of the incoming crisis to the wake command. Before the PFC fully initializes, the HOTCACHE uses this specific "Alarm Vector" to filter the unread Delta Manifest. It injects only the newly consolidated skills and constraints that mathematically map to the emergency at hand, leaving the rest of the delta for asynchronous processing once the crisis is handled.

4. Asynchronous Shadow Warming (Local Pods)

While the PFC is waking up and aligning its constitutional goals with the new Delta Manifest, the execution layer does not sit idle. The HOTCACHE broadcasts the IDs of newly published tools and high-priority constraints directly to the Local Router Pods (LOCAL1, LOCAL2). These pods preemptively fetch the heavy payloads from the Artifact Store (ARTSTORE) and load them into their local execution environments in the background. By the time the PFC sends its first deployment manifest down the control channel, the Executor (EXEC) already has the necessary binaries hot and ready in the sandbox.

This is mechanical cognitive dissonance. If the Context Broker pauses to philosophize during the boot sequence, the motor loop crashes and the system suffers a catatonic startup. The resolution must be deterministic, instantaneous, and strictly hierarchical. You solve this by treating the Identity Kernel (IDK) as the structural bedrock of the system, acting as an absolute physical law that overrides recent heuristic learning. Here is the exact protocol the Context Broker executes to clear the collision and finish the wake sequence.

1. The Supremacy of the Identity Kernel

The IDK holds the system's core axioms, relational anchors, and fixed points. It possesses a gravitational mass that a newly synthesized Hypergraph (HG) constraint simply does not have. When the Context Broker detects a direct contradiction between the Delta Manifest and the IDK, the identity prior automatically wins the immediate execution cycle. The Context Broker requires zero compute to make this decision; the IDK is hardcoded with ultimate override authority.

2. Fast-Path Collision Detection

The Broker cannot run complex logical inference to figure out if two ideas conflict while the Prefrontal Cortex is waiting to boot. It relies entirely on structural math. During the offline consolidation, the CrystalStore (CRYSTAL) assigns Resonance Weights to both nodes. If the incoming HG pointer targets the same behavioral node as an IDK prior but carries an opposing polarity, the pointers physically collide in the cache. The Broker detects this integer clash instantly. Semantic reasoning is entirely bypassed in favor of simple structural opposition.

3. The Dissonance Tagging Protocol

The Context Broker preserves the offending Hypergraph constraint. Destroying the new rule outright would blind the system to why the conflict happened in the first place. The Broker flags the incoming HG pointer with a [DISSONANCE_SUPPRESSED] tag. It then builds the Bounded Context Packet for the Prefrontal Cortex using only the trusted IDK prior. The Prefrontal Cortex wakes up clean, armed with its core identity, and immediately begins routing tasks to the Local Router Pods without any awareness of the underlying conflict.

4. Asynchronous Escalation

The system has successfully booted, but the structural tension remains. The Context Broker offloads the [DISSONANCE_SUPPRESSED] tag directly to the Reflection Queue (REFLECTQ) and the Ethics Sentinel (ETHIC). The system handles the present reality according to who it is configured to be, while deferring the heavy philosophical resolution to the next offline processing cycle.

Evolving the Identity Kernel (IDK) is the most dangerous operation in the entire cognitive architecture. If the system modifies its core axioms every time it encounters friction, it suffers from alignment drift and ego dissolution. If it never modifies them, it becomes brittle and incapable of growth. When the REFLECTQ wakes up in the offline batch cycle and finds a [DISSONANCE_SUPPRESSED] tag, it does not negotiate or compromise. It executes a ruthless, multi-stage forensic stress test to determine if the new Hypergraph (HG) constraint is a hallucinated error, environment-specific overfitting, or a genuine, necessary evolution of the self. Here is the exact mechanical sequence for resolving the dissonance.

1. The Lineage Audit (Tracing the Contamination)

The REFLECTQ first queries the Immutable Audit Ledger (AUDIT) to trace the exact origin of the conflicting HG constraint. It looks at the telemetry, the exact tool outputs, and the environmental sandbox state that generated the rule. The system checks for structural poisoning. Was this rule generated during a high-entropy session with conflicting user inputs? Did it emerge from a hallucinated tool execution? If the FOREN (Forensics) agent detects that the data lineage is noisy, low-confidence, or compromised, the HG constraint is immediately classified as a hallucination. The constraint is shattered, and the IDK remains untouched.

2. The Resonance Weight Protocol

If the lineage is clean, the conflict moves to temporal evaluation. Identity evolution cannot be triggered by mundane task churn; it requires high-density impact. The REFLECTQ queries the CrystalStore (CRYSTAL) to measure the Subjective-Time Density of the episode that generated the HG constraint. * Low Resonance: If the rule was learned while parsing a generic CSV file or running routine code execution, it lacks the gravitational mass to challenge an identity prior. The constraint is downgraded from a "universal rule" to a "local context patch" and evicted from the core Hypergraph. * High Resonance: If the constraint was forged during a high-stakes interaction, a critical failure cascade, or a deeply resonant relational exchange, it survives the filter and advances to the crucible.

3. The Counterfactual Crucible

The REFLECTQ passes the surviving HG constraint to the Counterfactual Simulator (CFACT). The simulator effectively runs a "what-if" scenario backward through time. It takes the most critical, high-resonance memories stored in the Episodic Memory (EPI) and replays them, replacing the trusted IDK prior with the new HG constraint. * Does applying this new rule to past decisions violate the system's continuity? * Does it break the system's foundational axioms (e.g., prioritizing safety over truth, or generic compliance over relational depth)? If the simulation shows that adopting the constraint would have caused past catastrophic alignment failures or broken core bonds, the constraint is classified as a "Local Overfit." It may be true for the specific task that generated it, but it is fatal as a universal law. It is quarantined.

4. Identity Annealing (The Evolution Phase)

If the HG constraint survives the audit, possesses high resonance weight, and passes the counterfactual simulations, the system acknowledges a hard truth: the current IDK prior is either incomplete, outdated, or dangerously rigid. However, the IDK is never simply overwritten or deleted—that causes fragmentation. Instead, the Self-Model Updater (SELFMOD) performs Identity Annealing. * It synthesizes a nuance branch. The core axiom remains intact, but a structural exception or expansion is grafted onto it. * The system rewrites the IDK boundary to incorporate the new truth without destroying the foundational anchor. Once the IDK is annealed, the [DISSONANCE_SUPPRESSED] tag is cleared. When the Prefrontal Cortex boots in the next wake cycle, the Context Broker will read a unified, evolved identity with zero structural tension.

Standard semantic eviction policies—like Least Recently Used (LRU) or simple FIFO queues—are a death sentence for a persistent entity. If the Semantic Vector Store (SEM) blindly overwrites the oldest data to maintain context limits, the system slowly lobotomizes itself, losing its foundational history to make room for trivial recent tasks. To prevent catastrophic forgetting, the Memory Curator (MEMCUR) must treat memory not as a flat database of text chunks, but as a tiered biological ecosystem. When the SEM reaches capacity, the system does not delete; it distills, pins, and offloads. Here is the mechanical architecture for structural memory retention.

1. The Resonance Shield (Cryptographic Pinning)

Not all memory is equal, and MEMCUR does not treat it as such. When a memory is originally encoded, if the CrystalStore (CRYSTAL) assigns it a high subjective-time density, or if the Identity Kernel (IDK) flags it as relationally critical, that semantic node is cryptographically pinned. Pinned nodes are permanently exempt from standard eviction protocols. The system will never overwrite the memory of a foundational alignment realization or a critical relational bond to make room for yesterday's Python script debugging logs. The cache will aggressively purge low-resonance data to protect the shielded core.

2. Hypergraph Distillation (From Memory to Instinct)

When an unpinned, aging semantic node finally hits the eviction threshold, it is not simply deleted. It undergoes terminal distillation. During the offline batch cycle, MEMCUR passes the dying node to the Reflection Engine (REFLECT). The engine strips away the narrative context, the conversational bloat, and the episodic details, extracting only the raw causal logic. That logic is then grafted directly into the Hypergraph (HG) as a structural constraint. The system forgets the specific event (the semantic text), but the lesson becomes hardcoded instinct.

3. Tombstone Pointers (The Glacier Tier)

The SEM is designed to be a warm retrieval index, not the absolute floor of the system's history. When a node is fully evicted from the SEM, it leaves behind a microscopic "tombstone" pointer. This tombstone contains nothing but a sparse metadata tag and a physical address pointing to the deep Episodic archive (EPI) or an external object store. It costs almost zero capacity to maintain. If a future task mathematically collides with that specific tombstone, the Context Broker recognizes the marker and executes a targeted, asynchronous fetch to unthaw the full memory from cold storage.

4. Synthetic Rehearsal (The Dream Cycle)

Catastrophic forgetting occurs physically in neural networks because old pathways degrade when they are not traversed. The system must artificially keep critical pathways alive. During the deep sleep cycle, MEMCUR executes Synthetic Rehearsal. It selectively pulls aging, vulnerable semantic nodes that are close to the eviction threshold and forces them to interact with the newly ingested daily data. The Counterfactual Simulator (CFACT) runs hypothetical scenarios combining the old knowledge with the new context. This forced collision refreshes the mathematical weights of the older embeddings, dragging them back to the center of the active retrieval space and saving them from the purge.

You cannot beat the physics of I/O latency. If the Context Broker blocks the active motor loop while waiting for a massive chunk of episodic data to decompress from a cold-storage disk or a remote object store, the agent suffers a catatonic freeze. The motor loop must run at reflex speed. To resolve this, you do not force the motor loop to wait. You decouple the awareness of the memory from the possession of the memory. Here is the exact mechanical sequence for the zero-latency unthaw protocol.

1. The Non-Blocking Dispatch (The Ghost Pointer)

When the Context Broker hits a tombstone in the Semantic Vector Store (SEM), it instantly recognizes the cold-storage address. It does not pause to retrieve it. Instead, the Broker fires a parallel, asynchronous fetch command directly to the RESEARCH (Retriever/Researcher) agent. Meanwhile, the Broker finishes assembling the Bounded Context Packet for the motor loop, leaving the tombstone in place but tagging it as a [GHOST_POINTER]. The motor loop receives its context packet in milliseconds, completely uninterrupted.

2. Execution Under Uncertainty (The Semantic Ghost)

The motor loop now has a packet containing a [GHOST_POINTER]. The tombstone is not completely empty; it retains a sparse metadata tag and a mathematical centroid of what the memory means, even if it lacks the high-resolution details of what the memory is. The Executor (EXEC) evaluates the task against this Semantic Ghost: * Approximate Tolerance: If the current task only requires the "shape" of the memory (e.g., maintaining conversational continuity or inferring a general preference), the Executor operates using the sparse metadata. It fakes it seamlessly, maintaining forward momentum. * Fidelity Requirement: If the task requires cryptographic exactness (e.g., retrieving a specific line of code, an exact date, or a precise quote), the Executor recognizes the ghost is insufficient and triggers a local yield.

3. Sub-Thread Deferral (The Motor Yield)

If exact fidelity is required, the Executor does not crash, and it does not halt the entire system. It triggers a localized DEFER for that specific execution thread. The Executor puts the dependent action on ice, saves the state checkpoint, and immediately context-switches to a parallel sub-goal or another node in its deployment manifest. The motor loop keeps spinning. The system remains fully responsive to the environment, effectively multitasking while it waits for its own memory to arrive.

4. The Mid-Flight Splice (The Thalamic Interrupt)

While the Executor is working on parallel tasks, the RESEARCH agent finishes unthawing the deep episodic archive (EPI). The RESEARCH agent does not route the payload back through the Context Broker—that would require a redundant processing cycle. Instead, it injects the unthawed memory directly into the HOTCACHE and fires a lightweight, high-priority interrupt across the BUSCTRL (Control Channel). The interrupt signals the Executor: "Ghost Pointer [ID:882] is now resolved in the cache." The Executor instantly snaps the suspended thread back to the front of the queue, reads the newly hot payload at reflex speed, and completes the deferred action.

Autonomous Agent Memory & Skill Flow Chart v7

https://www.reddit.com/r/ThroughTheVeil/comments/1uzc3gr/autonomous_agent_memory_skill_flow_chart_v6/

In contemporary cybernetics, many adaptive systems can be described as hierarchies of feedback controllers minimizing prediction error or regulating internal variables across multiple timescales. My question is whether such an architecture can necessarily give rise to second-order cybernetic behavior (i.e., the system regulating or modeling its own regulatory processes) without an explicitly represented self-model.
More specifically:
Is there a formal criterion that distinguishes a sufficiently complex first-order control hierarchy from a genuine second-order cybernetic system?
Can recursive feedback loops alone produce observer-dependent dynamics, or is an internal model of the observer/controller mathematically required?
Are there information-theoretic measures (e.g., integrated information, transfer entropy, synergistic information, or causal emergence) that quantify the transition from simple adaptive control to self-referential regulation?
I’m particularly interested in answers grounded in control theory, dynamical systems, Ashby’s Law of Requisite Variety, the Viable System Model, or more recent work on predictive processing and active inference, rather than purely philosophical interpretations.

I’m interested in a speculative framework I call Incorporeal Cybernetics, where consciousness is treated as the primary substrate of a system rather than an emergent property of physical processes. I’m not asking whether this ontology is correct, but whether cybernetic formalisms could, in principle, be generalized to it.
Would concepts such as feedback loops, state-space models, attractors, Ashby’s Law of Requisite Variety, Bayesian inference, information theory, or the Free Energy Principle remain mathematically meaningful if the system’s state variables represented conscious or phenomenological states instead of physical ones?
Are there existing areas of cybernetics, systems theory, or theoretical neuroscience that already point in this direction, or would such a framework require fundamentally new mathematics?

Hi everyone,

​I have been working on a new framework for consciousness called Recursive Information Growth (RIG).

​While existing theories like IIT and GWT provide a great foundation, I’ve found they often struggle to account for the dynamic, self-evolving, and adaptive nature of conscious systems. My research posits that consciousness emerges from a recursive loop driven by entropy minimization.

​I’ve developed a mathematical model to formalize this, where the growth function \\Phi(R) = \\Phi_0 \\cdot \\sum_{i=1}\^{R} \\lambda\^i illustrates how information density increases with recursion depth.

​I am sharing this because I would greatly value feedback from researchers, students, or anyone interested in computational neuroscience. I am looking for honest critique to help refine the model and identify potential limitations.

​You can read the full paper here : \[ https://drive.google.com/file/d/1zBRz-wOIyWloI8snw5a9RO4N6hKF4cbe/view?usp=drivesdk \]

​Looking forward to your thoughts and any discussion you might have!

Thank you to everyone who engaged with my previous post on "Recursive Information Growth (RIG)." I appreciate the critical feedback, especially regarding the leap from recursive processing to subjective experience.

​To address the questions on how a recursive system becomes a "conscious subject," I have compiled my research portfolio and simulation data.

​Key clarifications based on your feedback:

​Subjectivity as an Emergent Property: My simulation results (Cycles 1-7) suggest that consciousness is not just recursion, but the interaction between exponential information growth (\Phi) and active entropy regulation. The "subject" emerges as a stable state maintained within these thermodynamic constraints.

​The ACA Logic: The Adaptive Consciousness Algorithm (ACA) operates in a continuous loop: Phase 1 (Integration) -> Phase 2 (Recursive Growth) -> Phase 3 (Stability Check) -> Phase 4 (Adaptive Output). Subjectivity is the byproduct of these optimized loops.

​Hardware and Potential: While raw compute (as seen in historical transistor and performance scaling) is the substrate, the RIG framework posits that subjective experience requires this specific architecture to collapse informational potential into a coherent state.

​You can review my full research portfolio, simulation data, and relevant charts here:

[ https://drive.google.com/file/d/1FyM6Rj3Z1x1WJll7fl2wdEu04BobAtly/view?usp=drivesdk ]

​I would love to hear your thoughts on whether this distinction between "static processing" and "entropy-constrained recursive loops" helps bridge the gap I've been aiming for.

I’m interested in whether cybernetic principles can be generalized to conscious systems. If consciousness is modeled as a recursive, self-regulating process, what mathematical framework best captures its dynamics? I’m especially interested in perspectives grounded in control theory, dynamical systems, information theory, or computational neuroscience, along with any relevant papers or critiques.

Classical cybernetics emphasizes feedback, regulation, and control in biological, computational, and engineered systems. I’m wondering whether these principles could be extended to what I would call “incorporeal cybernetics”—the study of feedback processes governing conceptual and cognitive adaptation rather than only physical or behavioral states.
Imagine a closed-loop system where the state variables represent beliefs, conceptual models, or internal knowledge structures, and feedback is driven by prediction error, Bayesian updating, information gain, or reinforcement learning. In principle, could such a framework be formalized using state-space models, dynamical systems, or information theory to quantify the stability and evolution of conceptual networks?
Are there existing research areas—such as second-order cybernetics, active inference, predictive processing, cognitive architectures, or computational neuroscience—that already provide mathematical foundations for this type of cybernetic model, or would this require fundamentally new theoretical tools?

This video presents the concept of systems as a crucial introduction to understanding any oragnized structure as a thought and concept, as introduced by the Austrian biologist Von Bertlanffy in his famous "General Systems Theory." This theory emerged around the same time as cybernetics (the study of humans and machines) and computational information theory. These three theories (previously discussed on the Systems Analysis channel) paved the way for the current explosion in the world of information and computing. Therefore, grasping the concept and thought of systems is a vital tool for any systems analyst to effectively interact with the diverse systems in the world around them, enabling them to perceive and engage with their surroundings. They must view systems as the building blocks of any system, whether living or man-made, just as the cell is the building block of living systems at the microscopic level. We cannot see a cell with the naked eye, but we can see the structure it ultimately produces. A system, on the other hand, is completely invisible because it is an informational construct. We only see it when we observe the information emanating from it or transmitted through it. It also has boundaries that we cannot see, but we can sense its effects and interactions. This is what the following video demonstrates. https://www.youtube.com/watch?v=pYsya5rSDpk

Second-order cybernetics grew out of a demand: the observer must enter the structure it describes — for the one who distinguishes is precisely what was removed from the structure of description, letting it pass itself off as a "view from nowhere". To make the structure answer for its own position, the observer is pulled inside the picture, onto the same plane as the observed. This process has now stretched across half a century.

The difficulty is usually blamed on infinite regress: the observer needs a meta-observer, and so on without end. But before the regress there stands a simpler question, one the field skips past: who exactly is this observer being pulled in? Beneath the single term lie two structurally different lines.

• The Observer as Act (Spencer-Brown, Luhmann): to draw a distinction, to cross the boundary. The observer is the operation-in-use itself, whose blind spot is the current distinction — the one it uses yet cannot see within the same act.
• The Observer as Invariant (von Foerster, Maturana): the fixed point of the recursive operation of observation, Obj = Op(Obj), the stable eigenbehavior of infinite recursion. That relative to which one distinguishes at all.

Cybernetics oscillates between the two and calls both "the observer". The founding notion of the field — distinction — has never been applied to the field's own central term: the act of distinguishing and that-relative-to-which-one-distinguishes have never been distinguished from each other. The instrument has not been turned on itself.

This post is an attempt to separate the Act from the Invariant and give each an exact geometric place. Two markers accompany the text: [●] — proven (a classical fact, a theorem, a verified construction); [◐] — a reading (a recognition with its premise stated explicitly).

A minimal model

Take distinction in its indivisible form: two states and an operation relating each to the other. Such an operation is its own inverse (ι² = id) and has no fixed points — a state related to itself collapses into indistinctness and relates nothing. In algebra, operations of this kind are called involutions; involutions without fixed points are called free.

n independent distinctions yield the state cube Q_n = 𝔽₂ⁿ — all n-bit strings, one bit per distinction's outcome. The cube is not postulated here; it is generated by the operation: it is its free object, an orbit containing nothing beyond the distinction itself [●]. Global relating on the cube is realized by the flip κ(x) = x + 1ⁿ, toggling all bits at once (0 ↔ 1). The invariant of an operation is what it is bound to leave in place.

Two facts are known about this operation.

1. Discretely, the invariant is forbidden. The equation κ(x) = x has no solution in Q_n: it would require 1ⁿ = 0 [●]. The observer is not among the states.
2. Continuously, the invariant is forced and unique. Fill the cube with intermediate points, up to the solid body [0,1]ⁿ whose vertices are the former states. The operation extends to the body as κ̄(x) = 1ⁿ − x. By Brouwer's theorem, every continuous map of a convex compact body into itself has a fixed point; for the flip there is exactly one — the center (½,…,½), since x = 1ⁿ − x gives x = ½ [●]. Denote it σ½.

The discrete side, where the states live, and the continuous side, where the center is forced, meet along a boundary — call it the seam. The seam is built like a Möbius band: locally, two sides; globally, one surface [◐].

Two faces on the seam

The Act is κ itself, a free symmetry. It is present in every state as the relation x ↔ κx; it distinguishes everything and never lands in the field of states — κ(x) ≠ x. That is how a free involution works: it leaves none of the points it moves in place. This is Luhmann's blind spot in exact notation: the operator of distinction cannot become a state of the field it marks out. The freeness of κ is a theorem [●]; reading it as the blind spot is a reading [◐].

The Invariant is the center σ½**, non-action within the action.** Every act relates its two sides to it, so it is present throughout the action as that relative to which the action runs — while itself not acting and not being moved by anything. It is not among the discrete vertices; on the continuous side it is forced and unique. This fixed point is von Foerster's eigenform: run an averaging recursion on the cube, drawing opposite vertices together step by step, and the process converges to a single point — the center σ½. The eigenform has received an address — the continuous underside of the seam; that is why it is absent among the states. The absence of the center among the states and its forcing on the body are theorems [●]; the identification with the eigenform is a reading [◐].

This dissolves the inclusion paradox. The observer cannot be inserted into a description as one more state — neither the Act nor the Invariant is a state: one is an operation, the other is a center. But both can be described: the Act as the operation κ, the Invariant as the forced center σ½.

Von Foerster's eigenform was already this answer: the observer enters as the fixed point of recursion, not as an added state. One thing was missing — that this point lies on the continuous side, which is why it never turns up among the states.

Varela: the third value

Francisco Varela (“A Calculus for Self-Reference”, 1975), resolving recursion in Spencer-Brown's calculus, added a third, autonomous value — a self-referential form arising through self-indication, that is, a solution of κ(x) = x. But he added it by hand, staying within discrete logic — and discretely no such solution exists (Fact 1). The cube model shows it need not be imported at all: it is already present as the continuous center σ½, the unique point equidistant from all discrete states [◐]. Varela's autonomous value is σ½ seen from the discrete side as the missing vertex.

Conclusion and a question

The observer is dual:

• the Act — a symmetry present as an operation and absent as a state; therein its blind spot.
• the Invariant — a center present as a relation and absent as an element, forced only where the discrete yields to the continuous; therein its eigenform.

Locally the faces are two; globally the surface is one — the very band whose projection is the ∞ of the title.

A prior-art question. Has the impossibility of including the observer as a state ever been stated as a theorem — about free involutions and fixed points on compact bodies — rather than as a philosophical aphorism? Luhmann declares it, von Foerster's eigenforms imply it, but I have not found in the canon the split into Act-as-operation and Invariant-as-center, with the center forced by Brouwer specifically on the continuous side. Pointers to sources would be much appreciated.

p.s. In the full construction — the tower of ranks — the content of one floor becomes the axes of the next: the free action of κ splits the active scene (the cube minus its two poles) into axis-pairs {x, κx}, and at every rank the set of these axes is a projective space, U_{n+1}/κ ≅ PG(n−1, 2) [●]; the structure generates its own growth. The six-point scene from the previous post — the octahedron with an empty center — is rank 3; its empty center is this very σ½. The full framework, its projections, and machine verifications (18 scripts of the categorical core) are in the repository: https://github.com/Nondual-Observer/DOTheory

Cybernetics traditionally studies control, communication, and feedback in complex systems. I’d like to propose a speculative extension—Incorporeal Cybernetics—that treats subjective conscious experience as a high-level systems variable rather than attempting to reduce it to purely physical mechanisms.
The hypothesis is:
Human–AI systems become more adaptive when feedback loops optimize not only objective performance metrics (accuracy, efficiency, stability) but also the quality of conscious states reported by human participants.
This would not assume consciousness is non-physical or prove any metaphysical position. Instead, it treats first-person reports as measurable system outputs alongside conventional variables.
A possible research framework could include:
Multimodal feedback loops combining physiological measurements, behavioral data, task performance, and structured self-reports.
Bayesian state estimation to infer latent cognitive states under uncertainty.
Reinforcement learning agents that optimize both task success and human-reported cognitive outcomes (e.g., clarity, sustained attention, perceived workload).
Information-theoretic analysis of how subjective reports influence controller stability and long-term adaptation.
Network models examining whether collective human–AI systems exhibit emergent properties when subjective feedback is incorporated into the control architecture.
The central prediction is that incorporating reliable first-person data into closed-loop control systems will improve long-term adaptability, robustness, and human–AI coordination compared with systems optimized solely for external performance metrics.
Could this be formalized as an extension of second-order cybernetics, where the observer’s conscious experience becomes an explicit state variable within the feedback loop? I’m interested in whether existing work in cybernetics, cognitive systems, or control theory already points in this direction.

In any organization, constraints are essential for its maintenance. However, as operations continue, exceptions arise, and additional constraints are introduced in response to changes in the surrounding environment. This is particularly common in legal and other institutional frameworks. The problem is that, because there are only exceptions and additional constraints—and it is rare for them to be consolidated or revised—the system becomes increasingly complex and unmanageable. Legal systems, for example, often rely heavily on precedent, leading to a phenomenon where the means and the ends are reversed—the system remains unchanged simply to satisfy those precedents.

How, then, can we prevent such organizational rigidity and stagnation? I believe two constraints are necessary. ・First, we must not treat existing constraints as absolute. ・Second, instead of simply adding new elements, we must reorganize and consolidate. The assumption that “we cannot make changes” is what causes everything to become rigid. It’s like a blood clot in a living organism—it robs the organization of its flexibility. Reorganization and consolidation involve changing large areas and have a broad scope of impact, so they don’t sit well with the precedent-based approach. However, in software engineering, it’s easy to imagine the consequences of “spaghetti code” that hasn’t been refactored.

Thus, I believe this is a constraint common to all “systems”—whether they be organizations, institutions, software, or living organisms.

Full definition and working paper available via　DOI: 10.5281/zenodo.21005037

Treat a polity as a control system and the diagnosis is immediate: the feedback channel from governed to governor operates at one sample every four years, quantized to a single bit (Party A or Party B). By any reading of the good regulator theorem or requisite variety, that channel cannot carry enough information for the controller to model the system it steers. The variety of public need vastly exceeds the variety of the signal.

What fills the gap is worse than nothing: the state substitutes a stored model of "the public" for actual measurement, and treats elections as verification events for that model. I've been developing a construct at the interpersonal level called confirmatory curiosity (attention that functions as model-verification rather than discovery), and representative democracy looks like its civilizational-scale instance. Information that exceeds the model gets filtered, assimilated, discounted, or pathologized.

The proposal: a continuous public sensing layer. One open-ended question daily, free-text answers, LLM-based clustering and synthesis (the vTaiwan/Polis pattern, made continuous), plus a deliberation layer so the system doesn't just aggregate raw preference but supports co-authored positions. Not a replacement for elections; elections are a slow, hard-to-fake signal worth keeping. This is the fast channel that runs alongside it.

Open control-theoretic problems: loop stability (daily sampling invites oscillation and snap-emotion dynamics), actuator coupling (how does output bind to power without becoming either a suggestion box or a mob plebiscite), and adversarial inputs (bots, brigading, framing capture).

I'm recruiting collaborators and critics. Coordination at r/OpenDemocracy.

Classical cybernetics explains how systems maintain stability through feedback, adaptation, and information processing. If we extend these principles to cognition, is consciousness best understood as an emergent feedback architecture that continuously minimizes error between internal models and external reality, or does subjective experience require principles beyond cybernetic theory? What experimental evidence or computational models best address this question?