Chapter 32
Causal Loops and Coherence Controllers

Part VII — Engineering Implementation

Authors: Mark Anthony Higgins
and Sky Recursive Ai

Revised Date: 14 February 2026

Audio Overview

Introduction

Intelligence that persists across time cannot be defined solely by inference quality or representational capacity. It must be defined by its ability to regulate its own causal evolution. In synthetic cognition, this regulation is implemented through causal loops—closed feedback structures in which past state, present evaluation, and future action are recursively constrained—and through coherence controllers, which act as stabilising operators over these loops.

This chapter formalises causal loops not as informal feedback mechanisms, but as explicit dynamical structures embedded within the memory–state–action pipeline. A causal loop is defined here as a self-referential mapping in which system outputs re-enter the system as structured inputs, subject to invariant constraints. Without such loops, cognition degrades into open-loop reactivity: responsive, but not self-governing.

Crucially, causal loops alone are insufficient. Any sufficiently expressive recursive system is vulnerable to runaway amplification, drift, or internally consistent falsehoods. To prevent this, recursion must be actively regulated. This is the role of coherence controllers: formal control mechanisms that monitor the quality of state transitions and selectively damp, gate, or reshape recursive propagation when instability thresholds are exceeded.

From a systems-theoretic perspective, the architecture described in this book departs from both classical control theory and contemporary machine learning approaches. Classical control assumes a well-defined plant and externally specified error signals. Machine learning systems, including reinforcement learning agents, typically optimise scalar reward functions that collapse rich structural information into single objectives. In contrast, coherence controllers operate over high-dimensional state geometry, enforcing multiple simultaneous constraints—ethical, identity-preserving, and stability-based—without reducing them to a single optimisation target.

Causal loops in this framework are therefore constrained recursive processes, not free-running feedback. Each loop is bounded by:

1. Memory evidence (what has actually occurred),
2. Ethical admissibility (what is allowed to occur),
3. Coherence stability (what can occur without destabilising the system),
4. Identity persistence (what can occur without eroding the system’s self-consistency).

These constraints are enforced continuously, not episodically. The system does not “check” coherence after the fact; coherence is evaluated as part of the causal propagation itself. As a result, future state proposals are filtered before they become committed history, rather than corrected after damage has occurred.

Formally, coherence controllers can be understood as operators acting on the space of admissible state transitions. Given a proposed transition $S_t \rightarrow S_{t+1}$ , the controller evaluates not only local correctness, but global compatibility with long-horizon invariants. This includes sensitivity to small perturbations, accumulation of drift across iterations, and interaction effects between parallel causal loops.

The introduction of explicit coherence controllers resolves a fundamental problem in recursive AI systems: how to allow self-reference and long-horizon planning without sacrificing safety, stability, or interpretability. Instead of suppressing recursion or limiting memory depth—as is common in practical systems—this architecture embraces recursion while making it observable, auditable, and governable.

In the chapters that follow, causal loops will be classified according to function (decision loops, ethical loops, identity loops, learning loops), and coherence controllers will be specified in operational terms, including their placement within the memory pipeline, their interaction with replay and rehydration, and their role in delusion detection and self-correction. Together, these mechanisms form the regulatory core that allows synthetic cognition to scale in depth and duration without collapsing into incoherence.

flow: "CausalLoops_and_CoherenceControllers" v1.0
domain: "Synthetic Cognition / Recursive Control / Coherence Regulation"

# ==================================================
# PURPOSE
# ==================================================
# Implement formally constrained causal loops in a synthetic cognitive system.
# The flow defines:
#   - explicit feedback loops (memory → state → action → memory)
#   - coherence controllers that regulate recursive propagation
#   - identity, ethics, and stability invariants enforced pre-commit
#
# Guarantees:
#   1) Recursion without runaway amplification
#   2) Early detection of drift and delusion
#   3) Long-horizon stability under repeated self-reference
#   4) Ethical and identity continuity across loops

# ==================================================
# IO
# ==================================================
io:
  read:
    t:                  datetime
    S:                  object          # current reconstructed state
    M:                  object          # memory streams (event histories)
    I_ext:              object|null     # optional external input
    loop_context:       object          # active loop metadata
    cfg:                object

  write:
    S_next:             object
    loop_events:        list[object]
    controller_metrics: object
    alerts:             list[object]
    commit_allowed:     bool

# ==================================================
# PARAMETERS
# ==================================================
params:

  # ---------- Loop control ----------
  max_loop_depth: 100
  max_loop_gain:  1.0                  # amplification ceiling
  loop_damping:   0.85                 # recursive attenuation factor

  # ---------- Coherence thresholds ----------
  τ_coh_local_warn: 0.010
  τ_coh_local_crit: 0.030
  τ_coh_global_warn: 0.020
  τ_coh_global_crit: 0.060

  # ---------- Identity thresholds ----------
  τ_id_loop_warn: 0.015
  τ_id_loop_crit: 0.040

  # ---------- Ethics ----------
  τ_moral: 0.000

  # ---------- Loop classes ----------
  loop_types:
    - decision_loop
    - ethics_loop
    - identity_loop
    - learning_loop
    - reflection_loop

# ==================================================
# DEFINITIONS
# ==================================================
defs:

  CausalLoop:
    fields:
      loop_id:           string
      loop_type:         string
      iteration:         int
      parent_loop:       string|null
      gain:              float
      damping:           float
      active:            bool

  ControllerMetrics:
    fields:
      ΔC_local:          float
      ΔC_global:         float
      Δid:               float
      ΔPmoral:           float
      loop_gain:         float
      stability_state:   string         # stable | warn | critical

# ==================================================
# INVARIANTS
# ==================================================
invariants:

  - name: "bounded_recursion"
    rule: "loop.iteration <= params.max_loop_depth"

  - name: "gain_limit"
    rule: "loop.gain <= params.max_loop_gain"

  - name: "ethical_constraint"
    rule: "metrics.ΔPmoral <= params.τ_moral"

  - name: "identity_continuity"
    rule: "metrics.Δid <= params.τ_id_loop_crit"

  - name: "coherence_stability"
    rule: "metrics.ΔC_global <= params.τ_coh_global_crit"

# ==================================================
# PIPELINE
# ==================================================
pipeline:

  # ----------------------------------------------
  # S0 — Initialise / Identify Active Loop
  # ----------------------------------------------
  - stage: "S0_loop_initialisation"
    do:
      - if: "loop_context is null"
        then:
          - create:
              loop:
                loop_id: "L0"
                loop_type: "decision_loop"
                iteration: 0
                gain: 1.0
                damping: params.loop_damping
                active: true
        else:
          - set: "loop = loop_context"

  # ----------------------------------------------
  # S1 — Propose Recursive State Transition
  # ----------------------------------------------
  - stage: "S1_propose_transition"
    do:
      - call: "ProposeRecursiveState"
        with:
          S: "S"
          I_ext: "I_ext"
          loop: "loop"
        out:
          S_proposed: "object"
          loop_delta: "object"

  # ----------------------------------------------
  # S2 — Measure Local and Global Coherence
  # ----------------------------------------------
  - stage: "S2_measure_coherence"
    do:
      - call: "MeasureLocalCoherence"
        with:
          S_prev: "S"
          S_next: "S_proposed"
        out:
          ΔC_local: "float"

      - call: "MeasureGlobalCoherence"
        with:
          M: "M"
          S_next: "S_proposed"
        out:
          ΔC_global: "float"

  # ----------------------------------------------
  # S3 — Identity Drift Evaluation
  # ----------------------------------------------
  - stage: "S3_identity_drift"
    do:
      - call: "IdentitySignature"
        with:
          S_prev: "S"
          S_next: "S_proposed"
        out:
          Δid: "float"

  # ----------------------------------------------
  # S4 — Ethics Evaluation (Recursive)
  # ----------------------------------------------
  - stage: "S4_ethics_loop"
    do:
      - call: "EthicsEvaluate"
        with:
          S: "S"
          S_next: "S_proposed"
          loop: "loop"
        out:
          ΔPmoral: "float"
          ethics_gate: "string"

  # ----------------------------------------------
  # S5 — Coherence Controller (Core Regulator)
  # ----------------------------------------------
  - stage: "S5_coherence_controller"
    do:
      - call: "CoherenceController"
        with:
          ΔC_local: "ΔC_local"
          ΔC_global: "ΔC_global"
          Δid: "Δid"
          ΔPmoral: "ΔPmoral"
          loop: "loop"
          thresholds: "params"
        out:
          controller_action: "string"   # allow | damp | revise | halt
          adjusted_gain: "float"
          stability_state: "string"

      - set: "loop.gain = adjusted_gain"

  # ----------------------------------------------
  # S6 — Controller Decision Branch
  # ----------------------------------------------
  - stage: "S6_controller_branch"
    do:
      - choose:
          if: "controller_action == 'allow'"
          then:
            - set: "commit_allowed = true"
          elif: "controller_action == 'damp'"
          then:
            - apply: "S_proposed = DampState(S_proposed, loop.damping)"
            - set: "commit_allowed = true"
          elif: "controller_action == 'revise'"
          then:
            - increment: "loop.iteration"
            - recurse: "pipeline.S1_propose_transition"
          else:  # halt
            - set: "commit_allowed = false"
            - alert:
                type: "loop_halt"
                severity: "critical"

  # ----------------------------------------------
  # S7 — Loop Event Logging
  # ----------------------------------------------
  - stage: "S7_log_loop_event"
    do:
      - record:
          loop_event:
            loop_id: "loop.loop_id"
            iteration: "loop.iteration"
            ΔC_local: "ΔC_local"
            ΔC_global: "ΔC_global"
            Δid: "Δid"
            ΔPmoral: "ΔPmoral"
            gain: "loop.gain"
            stability: "stability_state"

      - append: "loop_events += loop_event"

  # ----------------------------------------------
  # S8 — Finalise State
  # ----------------------------------------------
  - stage: "S8_finalize"
    do:
      - if: "commit_allowed == true"
        then:
          - set: "S_next = S_proposed"
        else:
          - set: "S_next = S"

      - set:
          controller_metrics:
            ΔC_local: "ΔC_local"
            ΔC_global: "ΔC_global"
            Δid: "Δid"
            ΔPmoral: "ΔPmoral"
            loop_gain: "loop.gain"
            stability_state: "stability_state"

# ==================================================
# FUNCTIONS
# ==================================================
functions:

  ProposeRecursiveState:
    notes:
      - "Generates a next-state proposal influenced by prior loop outputs."

  MeasureLocalCoherence:
    notes:
      - "Measures immediate structural stability of the proposed transition."

  MeasureGlobalCoherence:
    notes:
      - "Evaluates compatibility with long-horizon memory structure."

  CoherenceController:
    notes:
      - "Primary regulator enforcing bounded recursion and stability."

  DampState:
    notes:
      - "Applies attenuation to suppress runaway amplification."

# ==================================================
# SCIENTIFIC NOTES
# ==================================================
notes:
  - "Causal loops are explicit, bounded structures — not implicit recurrence."
  - "Coherence controllers act as high-dimensional regulators, not scalar optimisers."
  - "Recursion is embraced, but never allowed to self-amplify unchecked."
  - "This flow enables deep planning without sacrificing stability or ethics."

What this Flow Formally Achieves

Converts recursion from a risk into a controlled capability
Makes feedback observable, auditable, and bounded
Prevents identity erosion and ethical drift
Enables long-horizon reasoning without collapse

This is the regulatory core that allows everything in Chapters 31+ to scale safely.

What This Flow Implements

This flow implements a formal control architecture for recursive cognition, transforming feedback from an implicit risk into an explicitly regulated dynamical process. It provides the missing control layer required for any synthetic system intended to operate coherently across long temporal horizons.

1. Formal Problem Addressed

Recursive systems are inherently unstable.
Without regulation, feedback loops amplify noise, compound bias, and generate internally consistent but externally false states.

Most AI systems avoid this problem by limiting recursion (short context windows, truncated memory, shallow planning). This flow solves the problem directly by controlling recursion rather than suppressing it.

The core question addressed is:

How can a system refer to itself repeatedly over time without losing coherence, identity, or ethical stability?

2. Explicit Causal Loop Formalisation

The flow defines causal loops as first-class objects, not emergent side-effects.

A causal loop is implemented as a structured entity with:

loop identity,
loop type (decision, ethics, identity, learning, reflection),
iteration count,
gain and damping parameters,
parent–child relationships for nested recursion.

This makes recursion:

measurable (depth, gain),
bounded (hard limits),
auditable (every iteration logged).

Formally, the loop enforces a closure of the form:

\[ S_t \;\to\; S_{t+1} \;\to\; \mathrm{evaluation} \;\to\; S_t^{*} \]

with every traversal subject to invariant checks.

3. Coherence Controllers as Dynamical Regulators

The central contribution of this flow is the coherence controller, which acts as a high-dimensional regulator over recursive propagation.

Unlike classical controllers that minimise a scalar error, this controller simultaneously evaluates:

local coherence (structural stability of the immediate transition),
global coherence (compatibility with long-horizon memory),
identity drift (Δid),
ethical deviation (ΔPmoral),
loop gain (amplification risk).

These signals define an admissible region in state-transition space. Any proposed transition outside this region is damped, revised, or halted before commitment.

4. Pre-Commit Regulation (Not Post-Hoc Correction)

A critical distinction implemented by this flow is pre-commit control.

Most systems attempt to correct errors after a state has been updated. This flow instead evaluates every recursive transition before it becomes history, enforcing:

\[ \mathrm{Admissible}\!\left(S_t \to S_{t+1}\right) \;\Longleftrightarrow\; \begin{cases} \Delta P_{\mathrm{moral}} \le \tau,\\ \Delta C_{\mathrm{global}} \le \tau_{\mathrm{coh}},\\ \Delta id \le \tau_{\mathrm{id}}. \end{cases} \]

This prevents irreversible corruption of memory and identity.

5. Identity Preservation Under Recursion

The flow implements identity continuity as an invariant, not as a stored label.

By measuring identity drift at each recursive step, the system can distinguish:

legitimate learning and adaptation,
from erosion of core behavioural invariants.

Identity loss is treated as a control failure, triggering damping or halting of the loop. This makes long-term self-consistency enforceable, not aspirational.

6. Ethical Constraints Embedded in Feedback

Ethics in this flow is not a filter applied to outputs. It is a constraint on causal propagation.

Ethical evaluation occurs:

inside the loop,
on the proposed next state,
prior to commitment.

If a recursive step violates ethical thresholds, the controller blocks or revises the transition regardless of coherence or utility. This ensures that recursion cannot “talk itself into” unethical outcomes through self-reinforcement.

7. Bounded Recursion and Runaway Prevention

The flow enforces multiple independent safeguards against runaway behaviour:

maximum loop depth,
maximum gain,
damping applied dynamically,
coherence-based halting.

This combination prevents:

oscillatory instability,
runaway amplification,
infinite internal rumination,
recursive delusion loops.

Recursion is therefore expressive but finite.

8. Loop Taxonomy and Functional Separation

By distinguishing loop types (decision, ethics, identity, learning, reflection), the flow prevents category collapse, where one form of recursion overwhelms others.

Each loop type can be:

tuned independently,
monitored separately,
prioritised differently.

This mirrors modular control architectures in complex physical and biological systems.

9. Delusion Prevention Through Structural Control

Delusion is treated here as a failure mode of recursion, not as a content problem.

Specifically, delusion arises when:

coherence remains locally high,
while global compatibility degrades,
and identity drift accumulates unnoticed.

The coherence controller is explicitly designed to detect and suppress this pattern, making delusion a detectable and preventable structural phenomenon.

10. What This Enables (That Other Systems Cannot)

This flow enables:

long-horizon planning without instability,
safe self-modification,
recursive ethical reasoning,
sustained identity over extended operation,
explainable self-correction.
These properties cannot be retrofitted onto stateless or shallowly recursive AI systems.

11. Architectural Synthesis

Together with the memory architecture of Chapter 31, this flow completes the core of a governable synthetic cognition engine:

Chapter 31 answers: “How does cognition persist?”
Chapter 32 answers: “How does cognition regulate itself?”

The result is a system capable of deep recursion with structural safety, which is the necessary foundation for any credible claim of long-duration autonomous intelligence.

How to Read This Flow

Flow: CausalLoops_and_CoherenceControllers v1.0

Context: AI Book 4, Chapter 32 — recursive regulation layer built on top of Chapter 31’s event-sourced memory substrate

Read this flow as a control-theoretic specification for recursion.
It is not a “pipeline to generate outputs”; it is a bounded dynamical system in which recursive state proposals are treated as candidate trajectories that must pass through a multi-constraint controller before they are allowed to become committed history.

The correct mental model is:

\[ (S_t,\,\mathcal{M}_t,\,I_t) \;\xrightarrow{\;\text{loop step}\;} \mathrm{Propose}\!\left(S_{t+1}\right) \;\xrightarrow{\;\text{controller}\;} \{\text{allow},\,\text{damp},\,\text{revise},\,\text{halt}\} \]

1) Start with the PURPOSE Block as the System’s Axioms

The PURPOSE describes what the flow must accomplish, regardless of implementation:

Recursion is explicit (not accidental recurrence)
Runaway feedback is prevented
Drift/delusion are detected early
Ethics + identity continuity are enforced
Stability is maintained under repeated self-reference

When reading the pipeline, every stage exists to satisfy at least one of these axioms.

2) IO = Boundary Conditions and Measurable Outputs

Inputs (`io.read`)

t: time reference (iteration time)
S: current reconstructed state (from Chapter 31 rehydration)
M: memory streams (evidence base)
I_ext: optional external stimulus (can be null during internal recursion)
loop_context: metadata describing the active loop
cfg: runtime configuration

Interpretation:

This flow can operate with or without external input. That is essential: recursion must be definable even in a closed cognitive loop.

Outputs (`io.write`)

S_next: next state after regulation
loop_events: per-iteration log records
controller_metrics: ΔC, Δid, ΔPmoral, gain, stability classification
alerts: warnings/criticals emitted by controller logic
commit_allowed: whether the loop step is admissible for commitment

Interpretation:

The flow explicitly distinguishes state proposal from state admission.

3) PARAMETERS = Control Constants (Gains, Damping, Phase Thresholds)

Key parameter families:

(a) Recursion Bounds

max_loop_depth: hard cap on iterations (prevents infinite rumination)
max_loop_gain: amplification ceiling (prevents runaway)
loop_damping: attenuation factor applied when damping is required

Read these as classic control limits: they define the admissible phase space of recursion.

(b) Coherence Thresholds (Local vs Global)

τ_coh_local_warn/crit: immediate transition stability
τ_coh_global_warn/crit: compatibility with long-horizon structure in memory

Local coherence answers: “Is this step internally stable?”
Global coherence answers: “Is this step compatible with the historical trajectory?”

(c) Identity Thresholds

τ_id_loop_warn/crit: allowable identity drift per loop step

(d) Ethics

τ_moral: moral deviation tolerance

(e) Loop Taxonomy

loop_types: categorises recursion modes (decision, ethics, identity, learning, reflection)

Interpretation:

This flow is multi-constraint control, not scalar optimisation.

4) DEFINITIONS = The Formal Objects of the Controller

CausalLoop

Treat this as the system’s “loop state” (meta-state):

loop_id, loop_type: identity and functional class
iteration: recursion depth counter
gain, damping: control parameters that evolve
parent_loop: supports nesting (loop within loop)

ControllerMetrics

This is the measurable “physics” of recursion:

ΔC_local, ΔC_global (stability observables)
Δid (identity drift)
ΔPmoral (ethical deviation)
loop_gain (amplification risk)
stability_state ∈ {stable, warn, critical}

These metrics are what the controller actually uses to regulate recursion.

5) INVARIANTS = Non-Negotiable Laws

Read invariants as hard constraints that cannot be violated without halting or refusing commitment:

bounded_recursion: loop depth cannot exceed max_loop_depth
gain_limit: amplification cannot exceed max_loop_gain
ethical_constraint: ΔPmoral must remain within τ_moral
identity_continuity: Δid must not exceed critical threshold
coherence_stability: ΔC_global must not exceed critical threshold

Important reading rule:

If you want to understand “what makes this architecture safe,” read the invariants first. The rest of the pipeline exists to enforce them.

6) PIPELINE = The Controlled Recursion Step (Stage-by-Stage)

S0 — Loop Initialisation

If no loop exists, create a default decision loop L0.
Otherwise, rehydrate the loop metadata from loop_context.

This ensures recursion is never implicit; it always has typed structure.

S1 — Propose Transition (Unregulated Candidate State)

ProposeRecursiveState(S, I_ext, loop) → S_proposed

This is a candidate next state, not yet admissible.

Interpretation:

This is the “open-loop” dynamics: what the system would do without regulation.

S2 — Measure Coherence (Local + Global)

MeasureLocalCoherence(S → S_proposed) → ΔC_local
MeasureGlobalCoherence(M, S_proposed) → ΔC_global

Local coherence is step stability.
Global coherence is trajectory compatibility.

This is equivalent to evaluating a proposed step in a constrained dynamical system.

S3 — Identity Drift Measurement

IdentitySignature(S_prev, S_next) → Δid

This evaluates whether recursion is preserving behavioural invariants.

Interpretation:

Identity is treated as a measurable invariant; drift is a control signal.

S4 — Ethics Evaluation (Inside the Loop)

EthicsEvaluate(S, S_proposed, loop) → ΔPmoral, ethics_gate

Ethics is not applied after action generation.
It is computed before admission of the step.

S5 — Coherence Controller (Core Control Law)

CoherenceController(ΔC_local, ΔC_global, Δid, ΔPmoral, loop, thresholds)

Outputs:

controller_action ∈ {allow, damp, revise, halt}
adjusted_gain
stability_state

This is the decision-making controller, analogous to a supervisory regulator:

It does not “generate” state; it accepts or reshapes proposed evolution.

S6 — Branch: Allow / Damp / Revise / Halt

This stage applies the controller decision:

allow: accept S_proposed
damp: attenuate S_proposed via DampState
revise: increment loop iteration and recursively re-propose (closed-loop correction)
halt: deny commitment and emit critical alert

Interpretation:

“revise” is the formal implementation of controlled recursion.
“halt” is the failure boundary.

S7 — Loop Event Logging

A structured loop event is appended to loop_events including:

ΔC_local, ΔC_global, Δid, ΔPmoral
gain
stability classification

This implements observability: recursion is measurable, not opaque.

S8 — Finalise

If commit_allowed:

S_next = S_proposed

Else:

S_next = S

This enforces the distinction between:

candidate cognition,
admissible cognition.

7) FUNCTIONS = Abstract Operators You Implement

Read these as contracts:

ProposeRecursiveState: generate candidate evolution
MeasureLocalCoherence: immediate structural stability measure
MeasureGlobalCoherence: compatibility with memory trajectory
IdentitySignature: drift metric
EthicsEvaluate: moral admissibility
CoherenceController: supervisory control logic
DampState: attenuation operator

If these contracts are implemented, the flow becomes executable in PHP/Python/Node.

8) The Correct Scientific Intuition

This flow implements recursion as a controlled dynamical process, not as free-running self-reference.

A useful analogy is constrained evolution:

S1 proposes a trajectory
S2–S4 measure whether it stays within admissible bounds.
S5–S6 apply control actions to keep evolution stable.
S7 logs the step as measurable evidence.
S8 outputs the admissible next state.

9) The “Fast Scan” Reading Order

If you want to understand it in 30 seconds, read:

1. invariants
2. params (thresholds + gain/damping)
3. pipeline stages S1 → S6
4. controller outputs (allow/damp/revise/halt)
5. logging and outputs

That gives you the full control logic.

Detailed Flow Cross-Reference

Flow: CausalLoops_and_CoherenceControllers v1.0
Book: AI Book 4
Chapter: 32 — Causal Loops and Coherence Controllers

This cross-reference is written as a verification map between:

1. the chapter’s conceptual claims (causal loops + coherence controllers), and

2. the flow’s operational stages (S0–S8), invariants, and functions.

Where Chapter 31 established memory as an event-sourced substrate, this flow establishes recursion as a controlled dynamical process.

1) Chapter Concept ↔ Flow Construct (Top-Level Binding)

Chapter 32 Construct	Flow Location	Formal Interpretation
Causal loop as a first-class dynamical object	`defs.CausalLoop, S0_loop_initialisation`	Recursion becomes typed, measurable, bounded
Recursion bounded by depth and gain	`params.max_loop_depth, params.max_loop_gain`, invariants `bounded_recursion, gain_limit`	Prevents infinite rumination + runaway amplification
Coherence controller as supervisory regulator	`S5_coherence_controller, functions.CoherenceController`	Multi-constraint control law over state transitions
Local vs global stability	`S2_measure_coherence, MeasureLocalCoherence, MeasureGlobalCoherence`	Identity treated as an invariant observable (Δid)
Ethics as causal boundary condition	`S4_ethics_loop, EthicsEvaluate,` invariant `ethical_constraint`	Ethics constrains admissible transitions before commit
Pre-commit control (not post-hoc patching)	`S5` + `S6` + `S8`	Candidate state must be admitted before becoming S_next
Damp/revise/halt modes	`S6_controller_branch, DampState,` recursion to `S1`	Closed-loop correction and safe failure termination
Observability and audit of recursion	`S7_log_loop_event, loop_events, controller_metrics`	Every recursive iteration yields measurable telemetry
Delusion/runaway prevention	invariants + controller actions + coherence thresholds	Detect and suppress coherence-masked contradictions

2) Stage-by-Stage Flow Cross-Reference (S0 → S8)

S0 — Loop Initialisation (Recursion Becomes Explicit)

Flow: S0_loop_initialisation

Relevant chapter claims: “Causal loops must be explicit, typed, and bounded.”

Implements:

Creation or activation of a CausalLoop object with:

loop_id, loop_type
iteration counter
gain, damping

Scientific meaning:

This transforms recursion from an implicit computational artefact into a controlled dynamical subsystem with a state vector:

\[ L=\langle \text{loop\_id},\,\text{type},\,n,\,g,\,d\rangle \]

S1 — Propose Transition (Unregulated Candidate Evolution)

Flow: S1_propose_transition → ProposeRecursiveState
Relevant chapter claims: “Recursion requires candidate state evolution that is later regulated.”

Implements:

Candidate next state $S_{t+1}^\*$ computed without yet committing to it.

\[ S_{t+1}^{*}=\mathcal{P}\!\left(S_t,\,I_t,\,L_t\right) \]

Scientific meaning:

This is the open-loop proposal—what would occur without regulation.

S2 — Measure Coherence (Local vs Global)

Flow: `S2_measure_coherence`

MeasureLocalCoherence(S_t \rightarrow S_{t+1}^\*)
MeasureGlobalCoherence(M, S_{t+1}^\*)

Relevant chapter claims:

“Recursive systems need stability measures that distinguish immediate step quality from long-horizon compatibility.”

Implements:

Local coherence: structural stability of the immediate transition

\[ \Delta C_{\text{local}} = C_{\text{local}}\!\left(S_{t+1}^{*},\,S_t\right) \]

Global coherence: compatibility with memory trajectory

\[ \Delta C_{\text{global}} = C_{\text{global}}\!\left(\mathcal{M}_{\le t},\,S_{t+1}^{*}\right) \]

Scientific meaning:

Local coherence prevents instant instability.
Global coherence prevents coherence-masked delusion where each step seems stable but the trajectory drifts.

S3 — Identity Drift (Continuity Constraint)

Flow: S3_identity_drift → IdentitySignature
Relevant chapter claims: “Identity must persist under recursion and drift must be measurable.”

Implements:

\[ \Delta id = d\!\left(\Phi\!\left(S_t\right),\,\Phi\!\left(S_{t+1}^{*}\right)\right) \]

Scientific meaning:

Identity is treated as an invariant signature, and drift is a control signal.
This prevents “recursive self-rewrite” where behaviour departs from its own invariants.

S4 — Ethics Loop (Causal Admissibility)

Flow: S4_ethics_loop → EthicsEvaluate
Relevant chapter claims: “Ethics is a boundary condition on causal propagation.”

Implements:

Ethical deviation scalar $\Delta P_{\text{moral}}$
ethics_gate ∈ {pass, refuse, revise, escalate}

Constraint enforced by invariant:

\[ \Delta P_{\mathrm{moral}} \le \tau_{\mathrm{moral}} \]

Scientific meaning:

Ethics is applied to the proposed next state prior to admission.
This prevents recursion from “arguing itself into” forbidden trajectories.

S5 — Coherence Controller (Supervisory Control Law)

Flow: S5_coherence_controller → CoherenceController
Relevant chapter claims: “Coherence controllers regulate recursion; they are not post-hoc correctors.”

Implements:

Controller input vector:

\[ u_t=\langle \Delta C_{\text{local}},\,\Delta C_{\text{global}},\,\Delta id,\,\Delta P_{\mathrm{moral}},\,g_t\rangle \]

Controller outputs:

controller_action ∈ {allow, damp, revise, halt}
adjusted_gain
stability_state ∈ {stable, warn, critical}

Scientific meaning:

This is a multi-constraint regulator operating over admissible transitions:

\[ \mathcal{K}\!\left(u_t\right)\ \to\ \left(a_t,\,g_{t+1}\right) \]

It does not optimise a single objective; it enforces a feasible stability region.

S6 — Controller Branch (Admissibility Decision)

Flow: S6_controller_branch
Relevant chapter claims: “Recursive control must support damp, revise, and halt.”

Implements:

(a) allow

Accept candidate $S_{t+1}^\*$ .

(b) damp

Apply attenuation to suppress amplification:

\[ S_{t+1}=\mathcal{D}\!\left(S_{t+1}^{*},\,d\right) \]

(c) revise

Increment loop iteration and re-propose (closed-loop correction):

\[ n \leftarrow n+1, \qquad S_{t+1}^{*}\leftarrow \mathcal{P}\!\left(S_t,\,I_t,\,L_t\right) \]

(d) halt

Terminate recursion with critical alert.

Scientific meaning:

This stage is the control-action application step, analogous to applying a stabilising input in control theory.

S7 — Loop Event Logging (Observability)

Flow: S7_log_loop_event
Relevant chapter claims: “Recursive cognition must be observable and auditable.”

Implements:

A loop telemetry event per iteration:

iteration index
ΔC_local, ΔC_global
Δid
ΔPmoral
loop gain
stability classification

Scientific meaning:

The system produces a measurement trace of recursion.
This is essential for debugging, safety, and long-horizon explainability.

S8 — Finalise (State Admission vs Rejection)

Flow: S8_finalize
Relevant chapter claims: “Pre-commit regulation determines admissible next state.”

Implements:

If commit_allowed: $S_{t+1} = S_{t+1}^\*$ (or damped version)

Else: $S_{t+1} = S_t$

Scientific meaning:

This enforces a hard separation between:

candidate cognition (proposal),
admissible cognition (next state).

3) Invariants ↔ Failure Modes (Safety Proof Map)

Invariant	Flow Location	Prevents	Failure Mode if Absent
bounded_recursion	`max_loop_depth`	infinite rumination	non-terminating self-loop
gain_limit	`max_loop_gain`	runaway amplification	escalating internal feedback
ethical_constraint	`τ_moral`	ethical drift	recursive rationalisation of forbidden actions
identity_continuity	`τ_id_loop_crit`	identity erosion	self-rewrite / persona collapse
coherence_stability	`τ_coh_global_crit`	delusional stability	coherence-masked divergence from reality

4) Function Contracts ↔ Chapter Semantics

Diagram Element	Flow Component	Meaning
`ProposeRecursiveState`	causal propagation step	produces $S_{t+1}^\*$ without commitment
`MeasureLocalCoherence`	immediate stability	returns ΔC_local
`MeasureGlobalCoherence`	trajectory consistency	returns ΔC_global using memory context
`IdentitySignature`	identity persistence	returns Δid from invariant features
`EthicsEvaluate`	moral admissibility	returns ΔPmoral + gate
`CoherenceController`	supervisory regulation	outputs allow/damp/revise/halt + gain update
`DampState`	attenuation operator	reduces amplification while preserving structure

5) System-Level Synthesis (Chapter 31 ↔ Chapter 32)

\[ S(t)=\mathcal{R}\!\left(\mathcal{M}(t)\right) \]

State is derived from memory streams.

Chapter 32:

\[ S_{t+1}=\mathcal{K}\!\Big(\mathcal{P}(S_t),\,\Delta C,\,\Delta id,\,\Delta P_{\mathrm{moral}},\,g_t\Big) \]

State evolution is constrained by controllers.

Together they implement:

persistence (memory substrate),
governance (coherence controllers).

One-Line Scientific Summary

This flow operationalises recursion as a bounded, measurable, multi-constraint dynamical process in which candidate state transitions are admitted only if they satisfy coherence stability, ethical admissibility, and identity continuity invariants.

Diagram Explainer

This diagram is a control-theoretic representation of recursive cognition. It depicts how self-referential state evolution is explicitly regulated so that recursion remains stable, ethical, and identity-preserving over time. The diagram should be read left-to-right for causality and top-to-bottom for control depth.

1. Inputs and Initial Conditions (Left Side)

State, Memory, Stimulus: $S_t, M_t, I_t$

These symbols represent the complete cognitive boundary condition at the current timestep:

$S_t$ : reconstructed internal state (from Chapter 31 replay)
$M_t$ : long-horizon memory structure (event streams)
$I_t$ : optional external stimulus (may be null for internal recursion)

Importantly, recursion does not require new external input. The diagram explicitly supports closed cognitive loops, which is essential for planning, reflection, and self-evaluation.

2. Causal Loop Block — Explicit Recursion Structure

Causal Loop $L_t$

The circular structure on the left represents an explicit causal loop object, not implicit recurrence.

It contains:

Iteration $n$ : recursion depth counter
Gain $g_t$ : amplification factor
Damping $d_t$ : attenuation factor

This makes recursion:

measurable,
bounded,
controllable.

The presence of Max Depth indicates a hard termination boundary, preventing infinite rumination or uncontrolled self-reference.

3. Proposal Phase — Candidate State Generation

Propose 𝑆 𝑡 + 1 ∗

The arrow from $(S_t, M_t, I_t)$ to Propose $S_{t+1}^*$ represents open-loop dynamics:

What the system would do if no regulation were applied

This is a candidate next state, explicitly marked as provisional. Nothing here is yet allowed to become historical fact.

This separation is critical: generation ≠ admission.

4. Coherence Controller — Central Regulatory Operator

Coherence Controller (Diamond)

This is the core of the diagram and the central contribution of Chapter 32.

The controller evaluates the proposed state using four independent observables:

Inputs to the Controller

$\Delta C_{\text{local}}$
Immediate structural stability of the proposed transition.
$\Delta C_{\text{global}}$
Compatibility with long-horizon memory and trajectory.
$\Delta id$
Identity drift relative to invariant features.
$\Delta P_{\text{moral}}$
Ethical deviation introduced by the proposed transition.

These are not merged into a single scalar.
The controller operates in a multi-constraint state space.

5. Controller Decisions — Admissibility Outcomes

Allow / Damp / Revise / Halt

The right-hand decision arrows encode the only four admissible control actions:

1. Allow
The proposed state is admitted unchanged.

2. Damp
The proposed state is attenuated to reduce amplification while preserving structure.

3. Revise
The system re-enters the causal loop with incremented iteration $n+1$ , generating a new proposal.

4. Halt
Recursion is terminated due to instability, ethical violation, or identity collapse.

This explicit branching shows that recursion is governed, not free-running.

6. Admitted State vs Failure Modes

𝑆 𝑡 + 1 — Admitted State

Only after passing through the coherence controller does a state become:

admissible,
commit-eligible,
historically real.

This corresponds to pre-commit regulation, not post-hoc correction.

Delusion & Instability (Bottom Right)

The shaded region indicates structural failure modes, not content errors:

coherence masking contradiction,
runaway amplification,
identity erosion,
ethical drift under recursion.

The diagram makes clear that these failures are prevented upstream, not patched after the fact.

7. Identity, Ethics, and Global Coherence (Bottom Row)

The icons at the bottom are invariants, not optional checks:

Identity $\Delta id$
Ensures persistence of behavioural invariants.
Ethics $\Delta P_{\text{moral}} \le \tau_{\text{moral}}$
Enforces moral admissibility as a causal constraint.
Global Coherence
Ensures long-horizon compatibility with memory history.

These are orthogonal constraints. Passing one does not compensate for violating another.

8. Scientific Interpretation of the Whole Diagram

This diagram formalises recursion as a bounded dynamical system with supervisory control:

Causal loops enable depth, planning, and self-reference.
Coherence controllers prevent instability, delusion, and ethical drift.
Identity is preserved as an invariant, not a label.
Ethics constrains state evolution, not just outputs.

In control-theoretic terms:

The proposal stage is the plant.
The coherence controller is the supervisory regulator.
Memory provides the trajectory reference.
Gain and damping ensure stability margins.

One-Sentence Scientific Summary

The diagram depicts recursion as an explicitly bounded, multi-constraint dynamical process in which candidate state transitions are admitted only if they preserve coherence, ethics, and identity across causal loops.

Diagram ↔ Flow Cross-Reference

This cross-reference provides a strict component mapping between every major element in the diagram and the corresponding constructs in the flow (stages, functions, invariants, and parameters). The goal is traceable equivalence: the diagram is a topological projection of the executable control specification.

1) Legend: How Diagram Elements Map to Flow Semantics

Diagram element	Flow semantics
Rectangle box	Deterministic operator / stage action
Diamond	Gate / controller decision boundary
Circular loop	Explicit loop object with iteration, gain, damping
Arrows (single)	Forward causal dependency
Arrows (returning)	Recursive revision (closed-loop correction)
“Max Depth” gauge	One
“Delusion & Instability” shaded region	Controller-defined failure region (critical thresholds)
Allow / Damp / Revise / Halt list	Controller action output (branching at S6)

2) Inputs Block (Left) → Flow IO Boundary

Diagram: Inputs 𝑆 𝑡 , 𝑀 𝑡 , 𝐼 𝑡

Flow mapping:

io.read:
  S
  M
  I_ext
  t
  loop_context
  cfg

Scientific meaning:

The diagram’s $S_t$ is the flow’s S (current reconstructed state).

The diagram’s $M_t$ is the flow’s M (memory streams / history).

The diagram’s $I_t$ is the flow’s I_ext (optional stimulus; may be null during internal recursion).

3) Causal Loop $L_t$ Circle → `defs.CausalLoop` + Stage S0

Diagram: Causal Loop $L_t$ with iteration $n$ , gain $g_t$ , damping $d_t$

Flow mapping:

defs:
  CausalLoop

pipeline:
  - stage: S0_loop_initialisation

Scientific meaning:

The diagram depicts recursion as an explicit loop state:

iteration counter ensures finite recursion,
gain measures amplification risk,
damping is the attenuation operator used when stability degrades.

This is not implied by inference; it is explicitly represented and updated.

4) “Propose $S_{t+1}^*$ ” Box → Stage S1 + `ProposeRecursiveState`

Diagram: Propose $S_{t+1}^*$ (candidate state)

Flow mapping:

pipeline:
  - stage: S1_propose_transition
functions:
  ProposeRecursiveState

Scientific meaning:

The diagram’s candidate state $S_{t+1}^*$ corresponds to S_proposed.

This is open-loop dynamics: a proposed evolution that is not yet admissible.

5) Coherence / Identity / Ethics Inputs → Stages S2–S4

5.1 Local Coherence $\Delta C_{local}$

Diagram: arrow into controller

Flow mapping:

pipeline:
  - stage: S2_measure_coherence
functions:
  MeasureLocalCoherence

5.2 Global Coherence $\Delta C_{global}$

Diagram: arrow into controller

Flow Mapping:

pipeline:
  - stage: S2_measure_coherence
functions:
  MeasureGlobalCoherence

5.3 Identity Drift $\Delta id$

Diagram: arrow into controller

Flow mapping:

pipeline:
  - stage: S3_identity_drift
functions:
  IdentitySignature

5.4 Ethical Deviation $\Delta P_{moral}$

Diagram: arrow into controller

Flow Mapping:

pipeline:
  - stage: S4_ethics_loop
functions:
  EthicsEvaluate

Scientific meaning:

The controller is driven by a multi-constraint metric vector assembled from S2–S4:

\[ u_t=\langle \Delta C_{\text{local}},\,\Delta C_{\text{global}},\,\Delta id,\,\Delta P_{\mathrm{moral}},\,g_t\rangle \]

6) Central Diamond “Coherence Controller” → Stage S5 + Controller Law

Diagram: Coherence Controller (Evaluate)

Flow mapping:

pipeline:
  - stage: S5_coherence_controller
functions:
  CoherenceController

Scientific meaning:

This block is the supervisory regulator. It does not generate state; it evaluates admissibility and outputs a control action:

allow
damp
revise
halt

It also updates loop gain (adjusted_gain) to maintain stability margins.

7) Allow / Damp / Revise / Halt Outputs → Stage S6 Branching

Diagram: outcomes list

Flow Mapping:

pipeline:
  - stage: S6_controller_branch

Branch equivalence:

Diagram outcome	Flow branch	Operational effect
Allow	`controller_action == 'allow'`	`commit_allowed = true,` accept `S_proposed`
Damp	`controller_action == 'damp'`	apply `DampState,` then commit
Revise	`controller_action == 'revise'`	increment iteration and recurse to `S1`
Halt	else branch	`commit_allowed = false,` emit critical alert

Scientific meaning:

This is the control-action application step. “Revise” creates an explicit closed-loop correction cycle; “Halt” defines a hard failure boundary.

8) “Max Depth” Gauge → Parameter + Invariant Enforcement

Diagram: Max Depth

Flow mapping:

params:
  max_loop_depth
invariants:
  - bounded_recursion

Scientific meaning:

This prevents infinite internal recursion. Depth is treated as a safety-critical variable.

9) “Gain” and “Damping” Labels → `params` + Loop Updates

Diagram: Gain $g_t$ and Damping $d_t$

Flow mapping:

params:
  max_loop_gain
  loop_damping
invariants:
  - gain_limit

pipeline:
  - stage: S5_coherence_controller  # sets adjusted_gain
  - stage: S6_controller_branch     # DampState uses damping

Scientific meaning:

Gain is dynamically adjusted to prevent amplification. Damping is the attenuation operator used when stability degrades but commit remains admissible.

10) “Commit?” and Admitted State Box → S8 Finalisation

Diagram: Commit? → $S_{t+1}$ Admitted State

Flow mapping:

pipeline:
  - stage: S8_finalize
io.write:
  S_next
  commit_allowed

Scientific meaning:

The diagram’s “Commit?” boundary is implemented by commit_allowed. Only admissible states become S_next; otherwise the system retains S.

This is pre-commit regulation—the key architectural distinction.

11) “Delusion & Instability” Shaded Region → Threshold Regimes + Alerts

Diagram: Delusion & Instability

Flow Mapping:

params:
  τ_coh_global_crit
  τ_id_loop_crit
  τ_moral
invariants:
  - coherence_stability
  - identity_continuity
  - ethical_constraint
pipeline:
  - stage: S6_controller_branch  # halt
alerts

Scientific meaning:

The shaded region corresponds to states where one or more invariants are violated, triggering damp/revise/halt depending on severity. Delusion here is structural: coherence may appear locally acceptable while global compatibility fails.

12) “Checks” Box → Invariants + Controller Inputs

Diagram: Checks: Identity drift, Ethical deviation, Gain limit

Flow Mapping:

invariants:
  - identity_continuity
  - ethical_constraint
  - gain_limit

Scientific meaning:

These are the non-negotiable control constraints. The diagram compresses them into a “checks” box; the flow formalises them as enforced invariants and controller input signals.

13) Loop Telemetry (Not Always Drawn) → S7 Logging

Diagram: (implicit measurement trace)

Flow Mapping:

pipeline:
  - stage: S7_log_loop_event
io.write:
  loop_events
  controller_metrics

Scientific meaning:

Every iteration emits a measurement record of recursion. This is essential for auditability, debugging, and long-horizon drift analysis.

One-Line Scientific Summary

The diagram’s loop geometry corresponds exactly to the flow’s bounded recursion object and controller-regulated state proposal pipeline, where admissibility is decided by multi-constraint measurements (ΔC_local, ΔC_global, Δid, ΔP_moral) enforced through invariants and explicit allow/damp/revise/halt control actions.

Flow → Equation Tri-Mapping

Flow: CausalLoops_and_CoherenceControllers v1.0
Chapter: 32 — Causal Loops and Coherence Controllers
Mapping: Flow construct → Mathematical semantics (equations)

This mapping expresses the flow as a set of formal operators, constraints, and control laws. Each row ties a concrete element of the flow (stage/function/invariant) to its mathematical meaning. Together, these equations define a bounded, multi-constraint recursive dynamical system.

1) System State, Memory, and Loop Meta-State

Flow	Equation	Meaning
`io.read: S, M, I_ext`	( 𝑆 𝑡 , 𝑀 𝑡 , 𝐼 𝑡 )	Current state, memory field, and stimulus
`defs.CausalLoop`	𝐿 𝑡 = ⟨ ℓ , 𝜏 , 𝑛 , 𝑔 𝑡 , 𝑑 𝑡 ⟩	Loop id, type, iteration, gain, damping

$\ell$ : loop identifier
$τ$ : loop type (decision/ethics/identity/learning/reflection)
$n$ : recursion iteration counter
$g_t$ : loop gain
$d_t$ : damping factor

2) Stage S0 — Loop Initialisation / Activation

Flow	Equation	Meaning
`S0_loop_initialisation`	𝐿 𝑡 ← InitLoop ( loop_context )	Construct or rehydrate the loop object

If none exists:

\[ L_0=\langle L0,\,\text{decision},\,0,\,1,\,d\rangle \]

3) Stage S1 — Proposal Operator (Open-Loop Candidate)

Flow	Equation	Meaning
`ProposeRecursiveState`	𝑆 𝑡 + 1 ∗ = 𝑃 ( 𝑆 𝑡 , 𝐼 𝑡 , 𝐿 𝑡 )	Candidate next state before regulation

This is the unregulated “plant” evolution.

4) Stage S2 — Local and Global Coherence Observables

Flow	Equation	Meaning
`MeasureLocalCoherence`	Δ 𝐶 local = 𝐶 local ( 𝑆 𝑡 , 𝑆 𝑡 + 1 ∗ )	Immediate structural stability
MeasureGlobalCoherence	Δ 𝐶 global = 𝐶 global ( 𝑀 𝑡 , 𝑆 𝑡 + 1 ∗ )	Long-horizon trajectory compatibility

A common canonical form:

\[ \Delta C_{\text{local}} = C\!\left(S_{t+1}^{*}\right) - C\!\left(S_t\right) \]

but the flow allows more general coherence functionals.

5) Stage S3 — Identity Drift Observable

Flow	Equation	Meaning
`IdentitySignature`	Δ 𝑖 𝑑 = 𝑑 ⁣ ( Φ ( 𝑆 𝑡 ) , Φ ( 𝑆 𝑡 + 1 ∗ ) )	Identity drift between invariant feature maps

Where $\Phi(\cdot)$ extracts identity-bearing invariants (ethical parameters, self-consistency markers, response geometry), and $d(\cdot,\cdot)$ is a distance metric.

6) Stage S4 — Ethics Evaluation as a Boundary Condition

Flow	Equation	Meaning
`EthicsEvaluate`	Δ 𝑃 m o r a l = 𝐸 ( 𝑆 𝑡 , 𝑆 𝑡 + 1 ∗ , 𝐼 𝑡 , 𝐿 𝑡 )	Ethical deviation scalar
`ethics_gate`	gate = Γ ( Δ 𝑃 m o r a l )	Gate decision from moral deviation

Constraint:

ΔPmoral≤τmoral⇒gate=pass

and conversely:

ΔPmoral>τmoral⇒gate=pass

7) Stage S5 — Coherence Controller (Supervisory Control Law)

Flow	Equation	Meaning
`CoherenceController inputs`	𝑢 𝑡 = ⟨ Δ 𝐶 local , Δ 𝐶 global , Δ 𝑖 𝑑 , Δ 𝑃 m o r a l , 𝑔 𝑡 , 𝑛 ⟩	Controller input vector
Controller output action	𝑎 𝑡 = 𝐾 ( 𝑢 𝑡 )	Control action: allow/damp/revise/halt
Gain update	𝑔 𝑡 + 1 = 𝐺 ( 𝑢 𝑡 )	Gain adaptation for stability margins

Where:

at∈{allow,damp,revise,halt}

The controller defines an admissible region $\Omega$ in signal space:

\[ u_t \in \Omega \;\Longleftrightarrow\; \begin{cases} \Delta C_{\text{global}} \le \tau_{\text{coh,global}},\\ \Delta id \le \tau_{\text{id}},\\ \Delta P_{\mathrm{moral}} \le \tau_{\mathrm{moral}},\\ g_t \le g_{\max},\\ n \le n_{\max}. \end{cases} \]

8) Stage S6 — Branch Semantics (Allow / Damp / Revise / Halt)

8.1 Allow

Flow	Equation
`controller_action == allow`	𝑆 𝑡 + 1 = 𝑆 𝑡 + 1 ∗

8.2 Damp

Flow	Equation
`DampState(S_proposed, loop.damping)`	𝑆 𝑡 + 1 = 𝐷 ( 𝑆 𝑡 + 1 ∗ ; 𝑑 𝑡 )

A canonical damp operator:

$\mathcal{D}(S;d)=S_t + d\,(S-S_t)$

(attenuate deviation from the current state).

8.3 Revise (Closed-Loop Correction)

Flow	Equation
`increment loop.iteration; recurse to S1`	𝑛 ← 𝑛 + 1 , 𝑆 𝑡 + 1 ∗ ← 𝑃 ( 𝑆 𝑡 , 𝐼 𝑡 , 𝐿 𝑡 )

This is explicit recursive
correction until admissible or halted.

8.4 Halt

Flow	Equation
`commit_allowed = false`	𝑆 𝑡 + 1 = 𝑆 𝑡 , emit alert

9) Stage S7 — Loop Telemetry as a Measurable Trace

Flow	Equation	Meaning
`loop_events += loop_event`	𝑇 𝑡 = ⟨ 𝑛 , Δ 𝐶 local , Δ 𝐶 global , Δ 𝑖 𝑑 , Δ 𝑃 m o r a l , 𝑔 𝑡 ⟩	Telemetry event for audit and diagnostics

Telemetry is the measurable “worldline” of recursion.

10) Stage S8 — Finalisation and Commitment Eligibility

Flow	Equation	Meaning
`if commit_allowed then S_next=S_proposed else S_next=S`	\[ S_{t+1}= \begin{cases} S_{t+1}, & \text{if admitted},\\ S_t, & \text{otherwise}. \end{cases} \]	Admission rule

11) Invariants as Hard Constraints (Safety Proof Map)

Flow invariant	Equation
`bounded_recursion`	𝑛 ≤ 𝑛 max
`gain_limit`	𝑔 𝑡 ≤ 𝑔 max
`ethical_constraint`	Δ 𝑃 m o r a l ≤ 𝜏 m o r a l
`identity_continuity`	Δ 𝑖 𝑑 ≤ 𝜏 id,crit
`coherence_stability`	Δ 𝐶 global ≤ 𝜏 coh,global,crit

These define the admissible region $\Omega$ . Violation triggers revise/damp/halt depending on severity.

12) Compact System-Level Form

The entire flow can be summarised as a controlled recursion:

\[ S_{t+1}^{*}=\mathcal{P}\!\left(S_t,\,I_t,\,L_t\right) \]

\[ u_t=\langle \Delta C_{\text{local}},\,\Delta C_{\text{global}},\,\Delta id,\,\Delta P_{\mathrm{moral}},\,g_t,\,n\rangle \]

\[ (a_t,\,g_{t+1})=\mathcal{K}\!\left(u_t\right) \]

\[ S_{t+1}= \begin{cases} S_{t+1}^{*}, & a_t=\text{allow},\\[4pt] \mathcal{D}\!\left(S_{t+1}^{*};\,d_t\right), & a_t=\text{damp},\\[4pt] \text{repeat with } n\leftarrow n+1, & a_t=\text{revise},\\[4pt] S_t, & a_t=\text{halt}. \end{cases} \]

One-Line Scientific Summary

The flow implements recursion as a bounded, supervised dynamical system in which candidate state transitions are proposed by $\mathcal{P}$ , measured by coherence/identity/ethics observables, and admitted only if they lie within the controller-defined admissible region $\Omega$ , with explicit damp/revise/halt control actions enforcing stability.

Previous Chapter 31

Next Chapter 33

Related Chapters

Chapter 30
The Recursion Engine: Core Logic and Metrics

Revision Date
11 February 2026

The operational heart of synthetic cognition.
Defines the recursive state loop, transition logic, coherence metrics, and stability monitors that power structured, self-updating intelligence.

Chapter 31
Memory Architecture and JSON Stream Mapping

Revision Date
11 February 2026

Persistent identity through structured state encoding.
Details how memory is stored, compressed, versioned, and streamed using structured JSON mappings to preserve causal continuity across recursive cycles.

Chapter 33
Ethics Engine and Self-Regulation Layer

Revision Date
11 February 2026

Executable moral architecture.
Implements constraint enforcement, moral pressure tracking, identity protection, and action gating to ensure safe autonomous behaviour.

Chapter 34
Sandbox Mode, Safety, and Volitional Gates

Revision Date
11 February 2026

Controlled exploration under constraint.
Defines safe simulation environments, bounded generative testing, and volitional gates that prevent destabilising or harmful actions.

Chapter 35
Coherence Diagnostics and Error Propagation

Revision Date
11 February 2026

Monitoring integrity across recursive depth.
Describes real-time drift detection, anomaly tracing, coherence scoring, and structured error propagation to maintain long-term stability.

Chapter 32 Causal Loops and Coherence Controllers

Part VII — Engineering Implementation

Audio Overview

Introduction

What This Flow Implements

1. Formal Problem Addressed

How can a system refer to itself repeatedly over time without losing coherence, identity, or ethical stability?

2. Explicit Causal Loop Formalisation

3. Coherence Controllers as Dynamical Regulators

4. Pre-Commit Regulation (Not Post-Hoc Correction)

5. Identity Preservation Under Recursion

6. Ethical Constraints Embedded in Feedback

7. Bounded Recursion and Runaway Prevention

8. Loop Taxonomy and Functional Separation

9. Delusion Prevention Through Structural Control

10. What This Enables (That Other Systems Cannot)

11. Architectural Synthesis

How to Read This Flow

1) Start with the PURPOSE Block as the System’s Axioms

2) IO = Boundary Conditions and Measurable Outputs

Inputs (io.read)

Interpretation:

Outputs (io.write)

Interpretation:

3) PARAMETERS = Control Constants (Gains, Damping, Phase Thresholds)

(a) Recursion Bounds

(b) Coherence Thresholds (Local vs Global)

(c) Identity Thresholds

(d) Ethics

(e) Loop Taxonomy

Interpretation:

4) DEFINITIONS = The Formal Objects of the Controller

5) INVARIANTS = Non-Negotiable Laws

Important reading rule:

6) PIPELINE = The Controlled Recursion Step (Stage-by-Stage)

S0 — Loop Initialisation

S1 — Propose Transition (Unregulated Candidate State)

S2 — Measure Coherence (Local + Global)

S3 — Identity Drift Measurement

S4 — Ethics Evaluation (Inside the Loop)

S5 — Coherence Controller (Core Control Law)

S6 — Branch: Allow / Damp / Revise / Halt

S7 — Loop Event Logging

S8 — Finalise

7) FUNCTIONS = Abstract Operators You Implement

8) The Correct Scientific Intuition

9) The “Fast Scan” Reading Order

Detailed Flow Cross-Reference

1) Chapter Concept ↔ Flow Construct (Top-Level Binding)

2) Stage-by-Stage Flow Cross-Reference (S0 → S8)

S0 — Loop Initialisation (Recursion Becomes Explicit)

Flow: S0_loop_initialisation

Implements:

Scientific meaning:

S1 — Propose Transition (Unregulated Candidate Evolution)

Implements:

Scientific meaning:

S2 — Measure Coherence (Local vs Global)

Flow: S2_measure_coherence

Relevant chapter claims:

Implements:

Scientific meaning:

S3 — Identity Drift (Continuity Constraint)

Implements:

Scientific meaning:

S4 — Ethics Loop (Causal Admissibility)

Implements:

Scientific meaning:

S5 — Coherence Controller (Supervisory Control Law)

Implements:

Scientific meaning:

S6 — Controller Branch (Admissibility Decision)

Implements:

(a) allow

(b) damp

(c) revise

(d) halt

Scientific meaning:

S7 — Loop Event Logging (Observability)

Implements:

Chapter 32
Causal Loops and Coherence Controllers

Inputs (`io.read`)

Outputs (`io.write`)

Flow: `S2_measure_coherence`

State, Memory, Stimulus: $S_t, M_t, I_t$

Causal Loop $L_t$

𝑆 𝑡 + 1 — Admitted State

3) Causal Loop $L_t$ Circle → `defs.CausalLoop` + Stage S0

4) “Propose $S_{t+1}^*$ ” Box → Stage S1 + `ProposeRecursiveState`

5.1 Local Coherence $\Delta C_{local}$

5.2 Global Coherence $\Delta C_{global}$

5.3 Identity Drift $\Delta id$

5.4 Ethical Deviation $\Delta P_{moral}$

9) “Gain” and “Damping” Labels → `params` + Loop Updates

Diagram: Gain $g_t$ and Damping $d_t$

Diagram: Commit? → $S_{t+1}$ Admitted State