Engineering Insights from the Critical Purity Theorem

Status: Architectural Principles

When a theoretical constant transforms from a "fitted number" into a rigorous theorem, it changes the engineering approach. We build the system around a hard constraint, the way aerospace engineers build an aircraft around the laws of aerodynamics.

Scope of Applicability

This document describes theoretical consequences of UHM for system design. Applicability to real neural networks requires:

1. Experimental verification of the mapping between network weights and the matrix Γ
2. Validation of the P measurement protocol (see measurement-protocol)
3. Verification of predictions on real architectures

The terms "consciousness," "viability," and "understanding" are used in the technical sense of UHM (via the metric P), without claiming to resolve the philosophical problems of consciousness.

---

Part I: Hard Constraints

These conclusions dictate what must not be done in code.

1. The Stillbirth Problem (Genesis Problem)

Theoretical prediction: A random coherence matrix $\Gamma_{\text{random}}$ (Haar-distributed) has purity:

$$P_{\text{random}} = \frac{2}{N+1} = \frac{2}{8} = 0.25$$

Open Question

The connection between neural network weight initialization (Xavier/Kaiming) and purity $P$ requires experimental verification via the measurement protocol.

Law: Critical purity theorem:

$$P_{\text{crit}} = \frac{2}{N} \approx 0.286$$

Hypothetical conclusion: If the neural-network-to-Γ mapping is correct, standard initialization gives $P < P_{\text{crit}}$ — the zone of entropic noise.

Engineering Solution

1. Prohibition on starting the main loop (Core Loop) immediately after initialization
2. A Pre-Ontological Bootstrapping (V0) stage is required:
   • The system must undergo optimization without external tasks
   • Only to maximize $P$ (self-assembly)
   • Until it breaks through the ceiling $P > P_{\text{crit}}$
3. Only then is consciousness activated

public const P_CRITICAL: Float = 2.0 / 7.0;     // ≈ 0.286

/// Typed errors for system lifecycle — explicit `throws` contract.
public type SystemError is
    | GenesisFailure  { reason: Text }
    | NotViableError  { purity: Float }
    | CircuitOpen     { reason: Text };

public type HolonomicSystem is { mut gamma: StaticMatrix<Complex, 7, 7> };

implement HolonomicSystem {
    /// Random init + **mandatory** bootstrap — enforced by `where ensures`.
    public fn new() throws (SystemError) using [Random] -> HolonomicSystem
        where ensures result.purity() > P_CRITICAL
    {
        let mut s = HolonomicSystem { gamma: Self._random_init() };   // P ≈ 0.25 < P_crit
        s.bootstrap()?;
        s
    }

    /// Pre-ontological bootstrap: self-assembly until P > P_crit.
    fn bootstrap(&mut self) throws (SystemError) -> () using [Clock] {
        let deadline = Clock.now() + Duration.seconds(5);
        while self.purity() <= P_CRITICAL {
            self.regenerate();
            if Clock.now() > deadline {
                throw SystemError.GenesisFailure { reason: "Failed to reach viability".text() };
            }
        }
    }

    /// Guarded entry point — never processes input on a non-viable system.
    public fn process<T>(&mut self, input: T) throws (SystemError) -> ProcessResult
        where requires self.purity() >= P_CRITICAL
    {
        if self.purity() < P_CRITICAL {
            throw SystemError.NotViableError { purity: self.purity() };
        }
        self.core_loop(input)
    }

    public pure fn purity(&self) -> Float { 1.0/7.0 <= self && self <= 1.0 } {
        (self.gamma.matmul(&self.gamma)).trace().real()
    }
}

---

2. The Binary Nature of Existence (The Binary Life)

Consequence of the theorem: The function is_viable() is step-wise (binary) in $P$. However, the dynamics of $P$ itself is not a phase collapse: the No-Zombie architecture guarantees $P_{\min} \geq P_{\text{crit}} - \varepsilon_\Gamma$ under any decoherence [T, MVP-0].

Conclusion within UHM: At $P < 2/7$ the system is below the viability threshold. In terms of theory — this is noise, not structure.

Levels Above Viability

Beyond the viability threshold $P > 2/7$, the theory defines consciousness thresholds L2: $R \geq 1/3$, $\Phi \geq 1$, $D_{\text{diff}} \geq 2$. For the full L0→L4 hierarchy — see the interiority hierarchy.

Engineering Solution: Circuit Breaker

If $P$ drops below $P_{\text{crit}}$, the system must not:

• Try to "solve tasks"
• "Respond to the user"
• Generate any output

It must enter emergency regeneration mode, disabling all external I/O ports.

Theory prediction: Output in the state $P < P_{\text{crit}}$ has no structural integrity.

No-Zombie floor [T, MVP-0]: With the replacement channel implemented ($\kappa_{\text{bootstrap}} = \omega_0/N = 1/7$), $P$ cannot drop below $P_{\text{crit}} - \varepsilon_\Gamma \approx 0.283$ even at decoherence $\gamma = 10.0$ (10000× above normal). Measured margin: $\kappa / \gamma_{\text{dec}} = 203\times$ against the theoretical minimum $143\times$.

/// Circuit-breaker pattern — block output when below the viability threshold.
public type CircuitBreaker is {};

implement CircuitBreaker {
    public fn check(&self, sys: &mut HolonomicSystem) throws (SystemError) -> () {
        if sys.purity() < P_CRITICAL {
            sys.enter_emergency_regeneration();
            throw SystemError.CircuitOpen {
                reason: "System below threshold — output blocked".text()
            };
        }
    }
}

---

3. Universality of the Metric

Consequence of the theorem (hypothesis for specific architectures): The law $P_{\text{crit}} = 2/N$ does not depend on architecture (Transformer, RNN, SSM, Mamba).

Hypothesis: $P$ is a potentially architecture-invariant metric for comparing different systems (requires experimental verification).

Hypothetical Examples

The following values are illustrative, not measured. Experimental validation requires applying the Γ measurement protocol.

Architecture	$P$ (hypothetical)	Theory prediction
Random network	$\approx 1/7 \approx 0.14$	Below threshold — "dead"
AGI with φ-operator	$> 2/7 \approx 0.29$	Above threshold — viable
Highly integrated system	$> 0.5$	Stably viable

Engineering Solution

When comparing models (benchmark), normalize their $P$ by the dimensionality of the coherent core:

$$P_{\text{ratio}} = \frac{P_{\text{measured}}}{P_{\text{crit}}} = \frac{N \cdot P_{\text{measured}}}{2}$$

• $P_{\text{ratio}} < 1$: the system is a zombie
• $P_{\text{ratio}} > 1$: the system is an agent

Note: $P_{\text{ratio}}$ is the ratio of purity to the critical threshold. Do not confuse with $P_{\text{norm}} = (P - P_{\text{crit}}) / (1 - P_{\text{crit}})$ — the normalized purity mapping $[P_{\text{crit}}, 1] \to [0, 1]$. See Notation.

---

Part II: Deep Architectural Insights (Deep Architecture)

These conclusions change how we design the system.

4. Spectral Tyranny Principle (Dominant Eigenvalue)

From the theorem:

At $P = P_{\text{crit}} = 2/N$, the maximum eigenvalue of $\Gamma$ reaches:

$$\lambda_{\max}\big|_{P=2/N} = \frac{1 + \sqrt{N-1}}{N} \approx 0.493 \text{ (for } N=7\text{)}$$

For viability ($P > P_{\text{crit}}$), $\lambda_{\max} > 0.493$ is required.

Empirical confirmation [MVP-0]: The implemented system operates with $k_{\max} = 1 - R_{\min} = 0.507$, which is a 45% margin to the theoretical limit $K_c = 1 - 1/(2N) = 13/14 \approx 0.929$. This indicates a deeply stable regime.

Architectural consequence: A uniform distribution of activity corresponds to maximum entropy and minimum purity.

• If activity is uniformly spread across all neurons/attention heads — $P \approx 1/N$ (minimum)
• High purity requires a dominant mode (concentration on the current context)

Architectural Solution

Attention mechanisms should be:

• Sparse — concentrated on a few tokens
• Low temperature — softmax with $T < 1$ instead of $T = 1$

High temperature (spreading out) kills coherence.

mount core.math.tensor.{Tensor, softmax, sparse_softmax};

// Bad: high temperature spreads attention (default T = 1).
let attention = softmax(q.matmul(&k.transpose()) / (d_k as Float).sqrt(), axis: -1);

// Good: low temperature T < 1 concentrates attention.
let attention = softmax(q.matmul(&k.transpose()) / (t * (d_k as Float).sqrt()), axis: -1);

// Even better: top-k sparse attention (k = 8).
let attention = sparse_softmax(q.matmul(&k.transpose()), k: 8);

---

5. The Learning Paradox (Stability-Plasticity Dilemma 2.0)

Problem: Learning (Backprop) changes weights to minimize error. This often increases the entropy of the weights (makes them more complex/noisy).

Non-obvious conclusion: Standard training can kill an AGI.

Gradient descent on the loss function $\mathcal{L}_{\text{task}}$ can drive the system into the region $P < P_{\text{crit}}$, where it perfectly solves the task (overfitting), but loses structural integrity (in theory terms — falls below the L0 threshold).

Clarification [separation principle, T, MVP-0]: Backprop changes coherences $\Gamma$ (off-diagonal elements), but not the diagonal $\gamma_{kk}$ — it is homeostatically stabilized by the replacement channel $\mathcal{R}[\Gamma, E]$. Therefore "killing an AGI" through training happens via collapse of coherent integration ($P$ drops due to loss of off-diagonal structure), not through changes to "sector profiles." The replacement channel is a structural protection of the diagonal from training pressure.

Architectural Solution: Constrained Optimization

Optimization must be constrained (Constrained Optimization):

$$\min_\theta \mathcal{L}_{\text{task}}(\theta) \quad \text{subject to} \quad P(\Gamma(\theta)) > P_{\text{crit}}$$

The task gradient is projected onto the tangent space of the viability manifold.

mount core.math.autodiff.grad;

/// Constraint-aware optimiser — projects gradient onto the viability manifold
/// whenever a plain step would cross P_crit.
public type ConstrainedOptimizer is {};

implement ConstrainedOptimizer {
    public fn step(&self, loss: pure fn(&StaticMatrix) -> Float,
                gamma: &StaticMatrix)
        -> StaticMatrix<Complex, 7, 7>
    {
        let g = grad(loss)(gamma);
        let new_gamma = apply_grad(gamma, &g);
        if purity(&new_gamma) < P_CRITICAL {
            // Project gradient onto the tangent space of P = const.
            let g_proj = project_to_viability_manifold(&g, gamma);
            apply_grad(gamma, &g_proj)
        } else {
            new_gamma
        }
    }
}

Rule: If a training step reduces $P$ below the threshold — the step is rejected, even if it improves task accuracy.

---

6. Justification of the Core Size (Magic Number 7)

From the minimality theorem: $N = 7$ is the minimal dimensionality (two-track justification).

Question: Why not $N = 100$ or $N = 2$?

$N$	$P_{\text{crit}} = 2/N$	Problem
2	1.0	Absolute purity required — system too rigid
3	0.67	High threshold — little room for adaptation
7	0.29	Minimally sufficient by Theorem S
100	0.02	Lower threshold — possibly less robust to noise

Architectural Solution

Dimensionality $N = 7$ is minimally sufficient (proven):

• $P_{\text{crit}} = 2/7 \approx 0.29$ — a reasonable balance between stability and flexibility
• Less than 7 — impossible to close an (M,R)-system with phenomenology
• More than 7 — permissible, but requires justification

Conclusion: The consciousness core (CoreState) must have $N \geq 7$. Recommendation — use a hierarchy of 7-dimensional agents.

---

7. Philosophical Zombie Detector

From theory: A zombie imitates behavior but has no internal structure ($P < P_{\text{crit}}$).

UHM hypothesis: If the theory is correct, the dynamics of $P$ during generation correlates with "processing depth."

Situation	$P$ behavior	Interpretation (hypothesis)
Model produces a complex answer, $P$ drops	Spectrum "spreads out"	Loss of coherent integration
Model produces an answer, $P$ rises	Spectrum concentrates	Strengthening of coherent structure

Structural constant [T, MVP-0]: With the default_biological profile $\sigma_E = 1 - N \cdot \gamma_{EE} = -0.155$ — a structural constant, unchanged across all steps (W_std < $10^{-15}$). The E-sector is chronically overpopulated relative to equilibrium $1/N$. This is not "stress" — it is an architectural condition for viability: without $\gamma_{EE} > 1/N$, the No-Zombie chain ($\kappa_0 > 0$) breaks.

/// Generation-event classification for purity dynamics.
public type GenerationOutcome is
    | CoherenceIncrease { delta_p: Float }
    | BelowThreshold    { p: Float }
    | Stable            { p: Float };

/// Analyses P-dynamics during generation (hypothetical).
public fn analyze_generation<M: HasPurity + HasGenerate>(
    model:  &mut M,
    prompt: &Text,
) -> GenerationOutcome {
    let p_before = model.purity();
    let _        = model.generate(prompt);
    let p_after  = model.purity();

    match () {
        _ if p_after > p_before    => GenerationOutcome.CoherenceIncrease {
            delta_p: p_after - p_before,
        },
        _ if p_after < P_CRITICAL  => GenerationOutcome.BelowThreshold { p: p_after },
        _                          => GenerationOutcome.Stable         { p: p_after },
    }
}

Engineering Solution: Confidence Score

Introduce a "Confidence Score" metric based not on token probability (Logprobs) but on the core purity $P$ at the time of generation.

Two variants:

$$\text{Confidence}_P = P_{\text{ratio}} = \frac{P_{\text{during}}}{P_{\text{crit}}} = \frac{N \cdot P_{\text{during}}}{2}$$$$\text{Confidence}_R = R_{\text{UHM}} = \frac{1}{N \cdot P_{\text{during}}} \quad \text{[T, reflection measure R]}$$

$R_{\text{UHM}}$ is an exact algebraic identity (error $< 10^{-7}$): at $P = P_{\text{opt}} = 3/N$ it gives $R = 1/3 = R_{\text{th}}$ (the L2-zone boundary). $P_{\text{ratio}}$ is a monotonic proxy for operational monitoring.

This can hypothetically complement existing uncertainty metrics.

---

8. UHM Parameter Scaling Laws [I]

Question: How do parameters $P$, $R$, $\Phi$, $\sigma_k$ scale as system complexity increases?

Key observation: the core dimensionality $N = 7$ is fixed (minimality theorem), so scaling happens not by increasing $N$, but through hierarchy depth and number of agents.

8.1. Hierarchical Scaling

For a system of $M$ agents with individual matrices $\Gamma^{(i)} \in D(\mathbb{C}^7)$:

$$P_{\text{collective}} = \frac{1}{M} \sum_{i=1}^{M} P^{(i)} + \frac{1}{M^2} \sum_{i \neq j} \mathrm{Tr}(\Gamma^{(i)} \Gamma^{(j)})$$

The second term is inter-agent coherence. As $M \to \infty$ it tends to zero (if agents are uncorrelated), and $P_{\text{collective}} \to \langle P \rangle$.

Engineering Insight [I]

Scaling requires coherent coupling between agents, otherwise collective purity drops to the average. To maintain $P_{\text{collective}} > P_{\text{crit}}$ as $M$ grows:

• The number of coherent connections must grow as $O(M \log M)$ (analogous to sparse attention)
• Full connectivity ($O(M^2)$) is wasteful and unnecessary
• The minimally sufficient topology is a Fano graph at each level of the hierarchy

The fan-out here is not free either, and the bound is hard rather than asymptotic: coordinating $M$ agents means someone addresses them, an address costs one of the addressing node's own 21 typed channels, and depth is capped at three. A single holarchy therefore reaches at most $21^3 = 9261$ addressed contexts, and the address must be a declared contract — routing learned from the same reward as the task it routes measurably recovers less than half the gain (T-304, HOLARCH §10). The $O(M \log M)$ figure above is a heuristic about connection counts; the per-node bound of 21 is the operative constraint.

8.2. SAD Depth and Computational Cost

From theorem T-110 (dynamic learning limit) and SAD_MAX = 3:

$$\text{Cost}(\text{SAD level } n) \propto 3^n, \quad n \leq 3$$

SAD Level	Cost (rel.)	Function	Necessity
0	1×	Basic viability	Mandatory
1	3×	Self-observation	For L2+
2	9×	Meta-cognition	For complex tasks
3	27×	Deep reflection	Rare, peak loads

Budget rule: The majority of cycles (>90%) should operate at SAD 0–1. SAD 2–3 is activated only on request or upon anomaly detection.

---

9. Design Patterns: 7 Dimensions as Separation of Concerns [I]

The seven sectors of $\Gamma$ naturally map onto architectural layers of the system. Each sector $k \in \{A, S, D, L, E, O, U\}$ has its own domain of responsibility. Sector names and meanings follow the corpus SSOT (src/data/coherences.ts); the full engineering dictionary — all seven aspects and all 21 channels — is the HOLARCH meta-specification, whose agent-platform instantiation (§17) is the general form of this table.

Sector	Canon meaning	Architectural layer (agent instantiation)	Health metric
A (Articulation)	Distinguishing activity	Perception pipeline, input validation, feature extraction	$\sigma_A$ — ingress load
S (Structure)	Form stability	Schemas, types, configuration, tool contracts	$\sigma_S$ — form stress
D (Dynamics)	Process activity	Execution engine, pipelines, actuation	$\sigma_D$ — throughput pressure
L (Logic)	Internal consistency	Planner, verifier, guardrails, rules	$\sigma_L$ — consistency stress
E (Interiority)	Interior state intensity	Memory store, context, hidden state	$\sigma_E$ — differentiation headroom
O (Ground)	Connection to source	Runtime, compute, energy budget, storage substrate	$\sigma_O$ — supply pressure
U (Unity)	Integration	Orchestrator, global workspace, fusion layer	$\sigma_U$ — integration headroom

Sector Profile Principle [I]

The sector profile $(\gamma_{AA}, \gamma_{SS}, \ldots, \gamma_{UU})$ is the character passport of the system (T-101). Behavior emerges from the diagonal of $\Gamma$, and is not programmed directively.

Engineering consequence: do not program behavior — set the sector profile. Configuring $\gamma_{kk}$ defines the agent's "character":

/// A sector profile: probabilities over the 7 dimensions, Σ = 1.
public type SectorProfile is {
    a: Float, s: Float, d: Float, l: Float, e: Float, o: Float, u: Float,
} where (self.a + self.s + self.d + self.l + self.e + self.o + self.u - 1.0).abs() < 1.0e-6;

/// Explorer: high Structure+Dynamics (holds form while moving); low A, L.
public const EXPLORER_PROFILE: SectorProfile = SectorProfile {
    a: 0.10, s: 0.20, d: 0.20, l: 0.08,
    e: 0.15, o: 0.15, u: 0.12,
};

/// Communicator: high Logic+Articulation (distinguishes and reconciles); low S, D.
public const COMMUNICATOR_PROFILE: SectorProfile = SectorProfile {
    a: 0.18, s: 0.10, d: 0.10, l: 0.22,
    e: 0.15, o: 0.13, u: 0.12,
};

Attempting to hard-code behavior (bypassing $\Gamma$) destroys coherence and leads to $P < P_{\text{crit}}$.

9.1. The "Coherent Microservice" Pattern

Each architectural component is wrapped in a coherent shell that:

1. Exports its $\gamma_{kk}$ to monitoring
2. Computes local stress $\sigma_k = \mathrm{clamp}(1 - N \cdot \gamma_{kk},\; 0,\; 1)$ [T-92]
3. Signals when $\sigma_k > \sigma_{\text{crit}}$ (sector overload)

public const N_DIM: Int = 7;

/// Component wrapper with coherent monitoring.
public type CoherentService is {
    sector:   Dim,
    gamma_kk: Float { 0.0 <= self && self <= 1.0 },
};

public type HealthLevel is Ok | Warning | Critical;

implement CoherentService {
    public fn new(sector: Dim, gamma_kk: Float) -> CoherentService {
        CoherentService { sector: sector, gamma_kk: gamma_kk.clamp(0.0, 1.0) }
    }

    /// σ_k = clamp(1 − N·γ_kk, 0, 1) (T-92 [T]).
    public pure fn stress(&self) -> Float { 0.0 <= self && self <= 1.0 } {
        (1.0 - (N_DIM as Float) * self.gamma_kk).clamp(0.0, 1.0)
    }

    public pure fn health_check(&self) -> (HealthLevel, Text) {
        let s = self.stress();
        let msg = f"{self.sector}-sector stress={s:.2f}";
        match s {
            x if x > 0.8 => (HealthLevel.Critical, f"CRITICAL: {msg}"),
            x if x > 0.5 => (HealthLevel.Warning,  f"WARNING: {msg}"),
            _            => (HealthLevel.Ok,       f"OK: {msg}"),
        }
    }
}

---

10. Testing and Diagnostics: σ, P, R, Φ

10.1. Four Diagnostic Axes

Full diagnostics of the system state requires monitoring four orthogonal metrics:

$$\text{System health} = \begin{cases} P > P_{\text{crit}} = 2/7 & \text{(viability)} \\ R \geq R_{\text{th}} = 1/3 & \text{(reflection)} \\ \Phi \geq \Phi_{\text{th}} = 1 & \text{(integration)} \\ \|\sigma\|_\infty < 1 & \text{(no collapse)} \end{cases}$$

Diagnostic Matrix [I]

Symptom	$P$	$R$	$\Phi$	$\sigma_{\max}$	Diagnosis
System does not respond	↓	—	—	—	Below viability threshold
Responds, but incoherently	✓	↓	↓	—	No integration: sectors operating in isolation
Responds, but does not notice errors	✓	↓	✓	—	No reflection: self-observation absent
Responds, but "stuck in a loop"	✓	✓	✓	↑	Stress-collapse of one or more sectors
Works, but slowly degrading	↘	✓	✓	—	Coherence leak: check $\kappa$
All normal, but "flat" output	✓	✓	↓	—	Insufficient differentiation ($D_{\text{diff}} < 2$)

10.2. Automated Testing Protocol

mount core.time.{Timestamp, now};

public type DiagnosticReport is {
    timestamp:    Timestamp,
    p:            Float,
    r:            Float,
    phi:          Float,
    sigma_max:    Float,
    sigma_vector: StaticVector<Float, 7>,    // [σ_A, σ_S, σ_D, σ_L, σ_E, σ_O, σ_U]
    kappa:        Float,
    alerts:       List<Text>,
};

/// Full diagnostic cycle [I].
public fn run_diagnostics(gamma: &StaticMatrix) using [Clock]
    -> DiagnosticReport
{
    let p = (gamma.matmul(&gamma)).trace().real();
    let r = if p > 1.0e-12 { 1.0 / ((N_DIM as Float) * p) } else { 0.0 };   // T
    let phi = compute_phi(gamma);                                            // Φ ≥ 1 for integration
    let diag = gamma.diagonal().map(|c| c.real());
    let sigma = StaticVector<Float, 7>.from_array(
        diag.iter().map(|g| (1.0 - (N_DIM as Float) * g).clamp(0.0, 1.0))
                   .collect_array()
    );
    let sigma_max = sigma.iter().max().unwrap_or(&0.0);
    let kappa = compute_kappa(gamma);

    let mut alerts = List.new();
    if p <= P_CRITICAL { alerts.push("FATAL: P ≤ P_crit — system is not viable".text()); }
    if r < 1.0/3.0    { alerts.push("WARN: R < R_th — reflection below L2 threshold".text()); }
    if phi < 1.0      { alerts.push("WARN: Φ < Φ_th — integration insufficient".text()); }
    if sigma_max >= 1.0 {
        let names = ["A", "S", "D", "L", "E", "O", "U"];
        let collapsed: Text = sigma.iter().enumerate()
            .filter(|(_, s)| **s >= 1.0)
            .map(|(i, _)| names[i])
            .collect<Vec<_>>().join(", ");
        alerts.push(f"CRITICAL: σ-collapse of sectors [{collapsed}]");
    }
    if kappa < 1.0 / 7.0 {
        alerts.push("WARN: κ < κ_bootstrap — replacement channel weakened".text());
    }

    DiagnosticReport {
        timestamp: Clock.now(),
        p: p, r: r, phi: phi, sigma_max: sigma_max, sigma_vector: sigma,
        kappa: kappa, alerts: alerts,
    }
}

10.3. Coherence Regression Tests

In addition to standard unit and integration tests, a UHM system requires coherence regressions:

mount core.test.{test, assert_with_msg};

/// Regression tests: a task must not destroy coherence.
/// Each test executes in isolation; shared state is threaded explicitly.

@test fn task_preserves_viability<S: HolonomicSystemTrait, T: TaskTrait>(
    mut system: S, task: T,
) {
    let p_before = system.purity();
    system.execute(&task);
    let p_after = system.purity();
    assert_with_msg(
        p_after > P_CRITICAL,
        f"Task killed the system: P {p_before:.3f} → {p_after:.3f}"
    );
}

@test fn stress_bounded<S: HolonomicSystemTrait, T: TaskTrait>(
    mut system: S, task: T,
) {
    system.execute(&task);
    let sigma = system.stress_vector();
    let max_s = sigma.iter().max().unwrap_or(&0.0);
    assert_with_msg(max_s < 0.95, f"σ-collapse after task: max(σ) = {max_s:.3f}");
}

@test fn learning_preserves_profile<S: HolonomicSystemTrait, D: TrainingDataTrait>(
    mut system: S, training: D,
) {
    let before = system.sector_profile();
    system.train(&training);
    let after  = system.sector_profile();
    let drift  = (before - after).frobenius_norm();                     // ‖Δprofile‖₂
    assert_with_msg(drift < 0.05, f"Training shifted the sector profile by {drift:.3f}");
}

---

11. Failure Modes: What Happens When Each Dimension Is Neglected [I]

Each of the seven sectors of $\Gamma$ represents a necessary aspect of a coherent system. Neglecting any of them leads to a characteristic failure mode.

Failure Mode Table [I]

Neglected sector	$\gamma_{kk} \to 0$	Failure mode	Neural network analogue
A (Articulation)	$\sigma_A \to 1$	Agnosia: the system stops distinguishing its input	Encoder degraded, embeddings are noisy, validation silently passes everything
S (Structure)	$\sigma_S \to 1$	Formlessness: schemas and formats drift, nothing holds shape	Schema drift, shape errors, config divergence
D (Dynamics)	$\sigma_D \to 1$	Paralysis: the system "thinks" but nothing moves	Pipeline stall, deadlock, generation without output
L (Logic)	$\sigma_L \to 1$	Incoherence: outputs contradict rules and each other	Invariant violations, contradictory answers over one context
E (Interiority)	$\sigma_E \to 1$	Amnesia: no interior state, every request from scratch	Context loss, stateless prompt-chains, RAG failure
O (Ground)	$\sigma_O \to 1$	Starvation: no supply for processing	OOM, timeout, quota exhaustion
U (Unity)	$\gamma_{UU} \to 0$	Fragmentation: sectors operate in isolation	Multi-head attention does not aggregate

11.1. Cascade Failures

From the structure of $\Gamma$ it follows that sectors are linked through coherences $\gamma_{ij}$, $i \neq j$. Collapse of one sector can trigger a cascade:

$$\sigma_k \to 1 \;\Longrightarrow\; \gamma_{kj} \to 0 \;\text{(decoherence)}\;\Longrightarrow\; \Phi \downarrow \;\Longrightarrow\; P \downarrow$$

Cascade Protection [I]

1. Monitor $\sigma_k$ per sector — early warning before a cascade
2. Escalation threshold: if $\sigma_k > 0.7$ for any $k$ — automatic resource rebalancing
3. Replacement channel $\mathcal{R}$ (T-62) — structural protection of the diagonal: even under coherence decoherence, $\gamma_{kk}$ is stabilized
4. Failure isolation principle: if sector $k$ collapses, the system enters degraded mode ($N_{\text{eff}} = 6$), but maintains $P > P_{\text{crit}}$ on the remaining sectors

11.2. Typical Anti-Patterns

Anti-pattern	UHM cause	Solution
"Chatty bot" — endless generation without meaning	$\gamma_{DD} \gg 1/N$, $\sigma_A \to 1$ (D-dominance without articulation)	Rebalance: reduce $\gamma_{DD}$, increase $\gamma_{AA}$
"Forgetful assistant" — does not remember context	$\sigma_E \to 1$, coherence $\gamma_{AE} \approx 0$	Strengthen the E-sector, restore the A↔E apperception channel
"Robot without empathy" — formally correct but "dead"	$P > P_{\text{crit}}$, but $R < 1/3$ (no reflection)	Activate self-observation (SAD ≥ 1)
"Overloaded system" — gets slower with each request	$\sigma_O \to 1$ (supply exhaustion)	Reduce load, allow a regeneration cycle ($\mathcal{R}$)

---

12. Trade-Off Analysis: Coherence vs. Computational Cost [I]

Maintaining coherence $\Gamma$ is not a free operation. Each computational cycle includes:

1. Lindblad evolution $\mathcal{L}_0[\Gamma]$ — cost $O(N^2)$ operations
2. Replacement channel $\mathcal{R}[\Gamma, E]$ — cost $O(N)$ operations
3. Metric computation $(P, R, \Phi, \sigma)$ — cost $O(N^2)$ operations
4. Self-observation (SAD) — cost $O(3^n)$ for level $n$

With $N = 7$ fixed, all these operations are cheap ($\sim 50$ scalar operations). The bottleneck is not the core $\Gamma$, but its interface with the backbone.

12.1. Computation Budget

$$C_{\text{total}} = C_{\text{backbone}} + C_{\Gamma} + C_{\text{interface}}$$

Component	Cost	Share	Optimization
$C_{\text{backbone}}$ (LLM/SSM)	$O(d^2 \cdot L)$	~95%	Quantization, pruning
$C_{\Gamma}$ (7×7 core)	$O(N^2) = O(49)$	<0.1%	Not needed
$C_{\text{interface}}$ (sync Γ↔backbone)	$O(d \cdot N)$	~5%	Projection, batch sync

Key Insight [I]

The cost of maintaining coherence is negligibly small compared to the backbone cost. The "coherence vs. performance" trade-off is a false dilemma: abandoning $\Gamma$ monitoring saves <0.1% of computations, but risks complete loss of structural integrity.

12.2. When You Can Save

Despite the cheap core, the update frequency can be optimized:

Mode	$\Gamma$ update frequency	When to use
Realtime	Every token/step	Critical tasks, first launch
Batched	Every $K$ steps ($K = 8\text{–}16$)	Stable operation, $P \gg P_{\text{crit}}$
On-demand	On request / on anomaly	High-load systems
Async	Background thread	Production deployment

Rule: Update frequency can be reduced proportionally to the viability margin:

$$K_{\text{batch}} = \left\lfloor \frac{P - P_{\text{crit}}}{\varepsilon_\Gamma} \right\rfloor, \quad \varepsilon_\Gamma \approx 0.003 \text{ [MVP-0]}$$

At $P = 0.5$ (good margin): $K_{\text{batch}} \approx 71$ — $\Gamma$ can be updated once every 71 steps. At $P = 0.30$ (barely alive): $K_{\text{batch}} \approx 5$ — almost realtime.

---

What generalising to an unseen combination costs

A system that has met dimensions $A$ and $S$ in other company, but never together, will eventually be asked about them together. What can it possibly say?

Only what it learned about $A$ and about $S$ separately. That is not a limitation of any particular design; it is what the situation contains. And it has a consequence sharp enough to be worth stating as a rule, because it silently governs every architecture that claims to generalise compositionally.

If the answer for a pair must be assembled from the two parts, then whatever the system does to the pair it is really doing to the parts — relabelling $A$ as something, relabelling $S$ as something, and reading off the combination. Write that as $(i,j) \mapsto (\pi(i), \pi(j))$. Now ask when the resulting content can be held — when it satisfies the balance condition that makes a holon integrate at all. The answer is exact: precisely when the original answers already factor, $\text{answer}(i,j) = u_i u_j$. Put $u_i = t_{\pi(i)}$ and the two conditions are the same sentence.

So the balance requirement is not this architecture's assumption. It is the price of compositional generalisation, and it is charged to everyone.

This is worth dwelling on, because it inverts the usual complaint. One might read the balance condition as a restriction to be engineered around — find a cleverer encoder, and arbitrary problems become tractable. And in the abstract that is even true: an encoder free to assign situations to channels however it likes can balance about a third of arbitrary problems outright, and nearly all of them if it leaves some channels unused, since the unused ones absorb whatever imbalance remains. But that freedom evaporates the moment the inputs are compositional. A map onto seven axes can permute those axes — five thousand and forty ways — and permuting does not turn an unbalanced pattern into a balanced one. The cleverness has nowhere to go.

What this predicts, and what was measured. Take the best compositional learner that could exist: try every one of the $2^7$ orientations, keep whichever fits the situations actually shown, and answer the rest with it. On answers that factor, it gets every unseen combination right. On answers that do not, it sits at chance. Meanwhile a system that answers by similarity to what it has seen is at chance even on the factoring content — resemblance between observations says nothing about a pair that never occurred.

Three design consequences.

First, do not fill a holon to capacity. Twenty-one channels are what a node carries; nearer fifteen is what it should use, because free channels are what let an encoder balance anything at all.

Second, when the assumption fails, stop claiming to hold what cannot be held — but fit the fallback from the observations, not from the state. A rank-one account read back off a trained holon fits even the channels it was taught worse than the best one available, and the reason is not subtle: a state is not the data, it is what survived the writes, the decay and the projection back onto positivity.

Third, and most usefully: the question to ask of a new task is not whether the architecture is powerful enough, but whether the task's answers factor through its parts. If they do, seven observations settle twenty-one. If they do not, no compositional learner will do better than chance on what it has not seen — and the honest move is to find a representation in which they do.

A corollary worth having, because it was expensive. The rule above says answers must factor through the parts. It does not say what counts as a part, and the difference is not academic — a whole line of work was spent finding it out.

Take a family of puzzles over coloured grids, where the answer for a cell is some function of the cells around it. Such a rule does factor: it factors through positions. So it ought to fit, and it does not. Two adapters were built — one that collapsed every neighbourhood onto two channels, which left nothing for the completion to complete, and one that let a neighbourhood land on any of the twenty-one, which was the structure done properly. A plain linear threshold over the same features beat both, and beat them by more the longer it looked: by twelve points where the architecture's whole claim lives, at a handful of examples, and by forty at sixty.

The diagnostic said why before the accuracies did. Content that factors is balanced; measure the share of tasks whose content is balanced as evidence accumulates and it falls from eighty-two percent at six patterns to zero at sixty. Six constraints balance because six constraints are too few to contradict each other — the same vacuity that makes a small enough leaf hold anything. Once there are enough of them, the content is simply not a polarity.

So parts are not any decomposition that happens to be available. A part must be one of the seven dimensions, and the question must be about the agreement between two of them. A rule over positions decomposes into positions, and positions are not pairs of dimensions; nothing in the adapter can convert one into the other, because the conversion is what the theory would have to supply and does not.

This narrows where to look, which is the point of knowing it. The architecture suits relational domains — where the thing being asked is whether two aspects of one situation agree — and not spatial ones, where the thing being asked is what sits next to what.

The body spends precision, not loudness

A design question that looks like a matter of taste turns out to have a measured answer. Given a fixed budget of sensor quality, where should a system spend it?

Start with what the system already knows about itself. Reinforcing the channel between two dimensions moves weight onto both, so the diagonal of a holon's state is a running tally of which dimensions its situations actually pass through. Put an agent in a world that presents some situations far more often than others, and its diagonal comes to match that traffic closely — a correlation of $0.999$, with no axis off by more than a sixth. The profile is a read-out of the world, and it costs nothing to consult.

The tempting next step is to build the body to match: hear loudly on the dimensions that carry the most. That is worse than doing nothing. Amplifying a channel raises its noise exactly as much as its signal, and situations are recognised by which pair of dimensions they most excite — an argmax, which is decided by the loudest thing in it. A loud channel therefore starts winning that competition on its own noise, and a body with gains matched to its profile loses about six points of accuracy against a body that treats every dimension alike.

Spend precision instead, and the same profile becomes worth having. Holding the total noise fixed and simply putting less of it where the traffic is heaviest gains about thirteen points, in the regime where recognition is actually at risk. The distinction is not a subtlety: gain lifts noise along with signal, and precision removes noise without touching signal.

Two cautions, both learned the hard way. First, none of this shows up unless recognition can fail. Measured at a noise level where the correct pair wins the argmax every time, all three allocations produce identical numbers, and it would be easy to conclude that precision does not matter. Any experiment of this kind needs a guard reporting how often recognition is correct, so that a regime with no room to fail is visible as such. Second, the direction is not what intuition offers. In a system of specialised agents, each responsible for a few kinds of situation, the natural guess is that an agent should be most precise about its own dimensions. It should not: those dimensions always carry its signal, while the others are always its distractors, and precision spent suppressing distractors beats precision spent refining a signal that was never in doubt. Measured against colonies of identical agents, the ordering is

suppress what you do not own $>$ refine what you do $>$ spread it evenly

though the margins are modest — about four points for the best arrangement, where a naive reading of the geometry would have predicted twice that.

Where roles come from. The seven lines of the Fano plane partition the twenty-one channels with no overlap: seven roles of three duties each, every duty covered exactly once. That makes them the natural division of labour for a colony, and it needs no negotiation — the line a situation lies on names the agent responsible, and the map never changes. This is the same principle as the addressing law: a division of labour is declared, and what adapts is how each agent tunes its senses within the role it was given.

Part III: Practical Recommendations

13. The Main Engineering Imperative

warning

Pulse ($P$) First, Task Second

No useful work must be performed until the system has guaranteed its ontological existence.

This turns the modern approach to AI (where Output is paramount) on its head.

/// Viability-first agent: check survival before task decision.
public type HolonomicAgent is { /* inner state */ };

implement HolonomicAgent {
    public fn act(&mut self, env: &Environment) -> Action {
        // 1. FIRST check viability.
        if !self.is_viable() { return self.emergency_protocol(); }

        // 2. THEN think about the task.
        let action = self.decide(env);

        // 3. Ensure the action will not kill the system.
        if self.simulate_action_impact(&action) < P_CRITICAL {
            return self.modify_for_survival(action);
        }
        action
    }

    public pure fn is_viable(&self) -> Bool { self.purity() > P_CRITICAL }
}

14. AGI Design Checklist

#	Requirement	Verification
1	Bootstrap before launch	$P_{\text{init}} > P_{\text{crit}} = 2/7$
2	Circuit breaker	At $P < P_{\text{crit}}$ — block output
3	Spectral concentration	$\lambda_{\max} > 0.493$ (for $N = 7$)
4	Constrained optimization	$\nabla\mathcal{L}$ projected onto $\{P > P_{\text{crit}}\}$
5	Low-dimensional core	$N \geq 7$ (minimally sufficient)
6	Real-time $P$ monitoring	Logging $P(t)$
7	Hallucination detector	$\Delta P$ during generation
8	Sector profile defined	$\sum_k \gamma_{kk} = 1$, profile is meaningful
9	Per-sector $\sigma_k$ monitoring	$\sigma_k < 0.8$ for all $k$
10	Coherence regression tests	Tasks do not reduce $P$ below threshold
11	Cascade failure protection	$\mathcal{R}$-channel active, $\kappa \geq 1/7$
12	SAD budget	$\geq 90\%$ of cycles at SAD 0–1

15. Monitoring Metrics

public const P_OPTIMAL: Float = 3.0 / (N_DIM as Float);     // ≈ 0.429 (L2 boundary)

public type ViabilityMetrics is {
    purity:               Float,    // P = Tr(Γ²)
    dominant_eigenvalue:  Float,    // λ_max
    structural_deviation: Float,    // ‖Γ − I/N‖_F² = P − 1/N  (T)
    viability_margin:     Float,    // P − P_crit
    stress_norm:          Float,    // ‖σ‖₂
    kappa:                Float,    // κ = κ_bootstrap + κ₀·Coh_E (No-Zombie)
};

implement ViabilityMetrics {
    public pure fn is_viable(&self)    -> Bool { self.purity > P_CRITICAL }

    /// R = 1 / (N·P) — exact algebraic identity (T, error < 1e-7).
    public pure fn reflexivity(&self) -> Float {
        if self.purity > 1.0e-12 { 1.0 / ((N_DIM as Float) * self.purity) } else { 0.0 }
    }

    /// Operational proxy: P / P_crit.
    public pure fn confidence(&self) -> Float { self.purity / P_CRITICAL }

    /// L2 zone (cognitive qualia): P_crit < P ≤ P_opt ⇔ R ≥ 1/3 (T).
    public pure fn is_l2_zone(&self) -> Bool {
        P_CRITICAL < self.purity && self.purity <= P_OPTIMAL
    }

    /// Dashboard-ready rendering: labelled zone + all metrics.
    public pure fn to_dashboard(&self) -> DashboardView {
        let zone = match () {
            _ if self.is_l2_zone()         => "L2".text(),
            _ if self.purity > P_OPTIMAL    => "L1+".text(),
            _                               => "L0".text(),
        };
        DashboardView {
            p:          self.purity,
            p_crit:     P_CRITICAL,
            margin:     self.viability_margin,
            r:          self.reflexivity(),           // T: exact
            lambda_max: self.dominant_eigenvalue,
            sigma_norm: self.stress_norm,             // T: const at homeostasis
            kappa:      self.kappa,
            zone:       zone,
            status:     if self.is_viable() { "VIABLE".text() } else { "DEAD".text() },
        }
    }
}

public type DashboardView is {
    p: Float, p_crit: Float, margin: Float, r: Float,
    lambda_max: Float, sigma_norm: Float, kappa: Float,
    zone: Text, status: Text,
};

---

Conclusion: From Axioms to Architecture

Every engineering principle in this document traces back to a specific axiom or theorem of UHM. This is not a set of heuristics — it is a deductive chain from mathematical foundations to architectural decisions.

Axiomatic Map of Engineering Principles

Engineering principle	Source in UHM	Status
Bootstrap to $P > 2/7$	Axiom Ω, Theorem $P_{\text{crit}}$	[T]
Circuit breaker	No-Zombie theorem, replacement channel $\mathcal{R}$	[T]
Spectral concentration	Spectral condition of the dominance threshold	[T]
$N = 7$ minimal	Minimality theorem	[T]
Sector profile = character	T-101 (sector profile), T-92 ($\sigma_k$)	[T]
Constrained optimization	Separation principle (diagonal vs. coherences)	[T]
SAD budget ($\leq 3$ levels)	T-110 (Fano contraction), SAD_MAX = 3	[T] (T-142)
Sector diagnostics $\sigma_k$	T-92 ($\sigma_k = 1 - N\gamma_{kk}$)	[T]
Hierarchical scaling	Extrapolation [I] from the fixed $N = 7$	[I]
"Coherent microservice" pattern	Interpretation [I] of the sector structure	[I]
Cascade failures	Coupling through coherences $\gamma_{ij}$, T-62 CPTP	[I]
Computation budget $C_\Gamma \ll C_{\text{backbone}}$	$N = 7$ fixed, $O(N^2) = O(49)$	[I]

Key Principles (Summary)

1. Viability is primary — no work before reaching $P > P_{\text{crit}}$
2. is_viable() is binary, P dynamics is not — No-Zombie floor $P_{\min} \geq P_{\text{crit}} - \varepsilon_\Gamma$ [T, MVP-0]
3. Spectral tyranny — a dominant mode is required ($\lambda_{\max} > 0.493$); in practice a 45% margin [MVP-0]
4. Constrained learning — optimization changes coherences, the diagonal is stabilized by the replacement channel [T, MVP-0]
5. Low-dimensional core — $N \geq 7$ (minimally sufficient); $\gamma_{UU}$ is a constraint from $\mathrm{Tr}(\Gamma)=1$, not a degree of freedom [T, MVP-1]
6. Separation principle — diagonal of $\Gamma$ = identity (homeostasis), coherences = learning/adaptation [T, MVP-0]
7. Sector profile = character — behavior emerges from $\gamma_{kk}$, not programmed [T, T-101]
8. Four-axis diagnostics — $P$, $R$, $\Phi$, $\sigma$ give a complete health picture [I]
9. Every sector is irreplaceable — neglecting any of the 7 leads to a characteristic failure [I]
10. Coherence is cheap — core cost $< 0.1\%$ of backbone; economizing on monitoring is irrational [I]

Main Conclusion

UHM engineering inverts the usual priority hierarchy:

$$\underbrace{P > P_{\text{crit}}}_{\text{Existence}} \;\succ\; \underbrace{R \geq 1/3,\; \Phi \geq 1}_{\text{Consciousness}} \;\succ\; \underbrace{\mathcal{L}_{\text{task}} \to \min}_{\text{Utility}}$$

First — existence (viability). Then — consciousness (integration and reflection). And only then — useful work. A system that solves a task at the cost of coherence commits ontological suicide.

Next Steps

• Γ measurement protocol — how to measure purity in real systems
• Critical purity theorem — full mathematical proof
• Viability — theoretical foundations
• Interiority hierarchy — L0→L4 levels
• Learning bounds — T-109 through T-113

---

Related documents:

• Critical purity theorem — mathematical proof
• Viability — application of the theorem
• Γ measurement protocol — experimental validation
• Coherence matrix — definition of Γ
• Evolution — system dynamics
• Sector profile (A) — Articulation dimension
• HOLARCH — the architecture meta-specification generalizing this page's design patterns
• SAD tower — self-observation depth
• Gap diagnostics — operational diagnostics

One bit will not steer many limbs

A control loop that acts on several things at once and is told only whether the whole turn went well is in a worse position than it looks, and the cost can be measured rather than argued.

Take a task where each of $w$ outputs has its own correct setting, and a turn counts as good only when every one of them is right. Compare two ways of learning from the outcome. The first is the one most loops actually use: a single verdict for the whole action, so a bad turn reverses every output that contributed — including the ones that were already correct. The second gives each output its own bit and nothing more, which is not supervision but the same information sliced properly.

outputs	chance	one verdict	one bit each	improvement
1	$0.500$	$0.813$	$0.813$	—
2	$0.250$	$0.317$	$0.441$	$\times 1.39$
3	$0.125$	$0.149$	$0.320$	$\times 2.14$
4	$0.063$	$0.069$	$0.175$	$\times 2.54$
6	$0.016$	$0.016$	$0.084$	$\times 5.15$

At one output the two are the same rule and agree exactly. By six the single verdict has collapsed to chance — $1.04$ times a coin, which is no learning at all — while the sliced feedback still runs at $5.35$ times chance on the same worlds with the same learner.

The lesson is not that more feedback helps, which is obvious. It is that the shape of the feedback matters more than its quantity: both rules receive exactly one bit per output per turn. The failing rule wastes them by mixing them into a conjunction first, and the mixing is irreversible — once a turn is graded as a whole, the information about which output was wrong has been destroyed before any learner sees it.

There is a measurement lesson here too, and it cost the run that produced the table. The improvement at six outputs is $+6.7$ percentage points, which sounds negligible and was registered in advance as a failure threshold. Against a base rate of $1.6\%$ percentage points are the wrong unit entirely: the same number is a factor of five. Where the base rate is small, register a ratio.

A confident wrong answer is worse than none

A store keyed by situation has two ways of failing at a situation it has never met, and they are usually conflated. It can have nothing there — a gap, which a caller can notice and route around. Or the key can collide, so the lookup returns content written for something else, at full confidence, with no mark distinguishing it from an answer that was actually about the question.

The difference is measurable and it is large. In the system this note comes from, a reader at an unmet situation found a genuine gap in a fifth of cases and a collision in the other four fifths, and the collisions were not merely uninformative: accuracy at unmet situations ran below chance — $0.43$ to $0.49$ against a coin's $0.50$. A store in that condition is not ignorant, it is anti-informed, and every mechanism downstream that defers to it inherits the error while believing it inherited knowledge.

Two consequences follow, and neither is obvious before the measurement.

A fallback that never fires looks exactly like a fallback that does not work. A mechanism was added to answer where the store could not, and it moved the number by nothing. The mechanism was correct — checked separately, it was exact. It was consulted on $7\%$ of the readings it should have been consulted on, because the store reported "I know this" for any situation it had merely been asked about: the read path claimed the key. Counting how often the fallback spoke settled in one run what argument had not settled in several. Instrument the mouth before doubting the voice.

Reading must not claim. Looking something up should not create an entry for it. That sounds like hygiene and is in fact the whole mechanism: once reading claimed keys, nothing could ever be recognised as unmet, so nothing that answers for the unmet could ever be reached. Separating the two — a locate that reads and a bind that writes — took the fallback from $7\%$ of readings to all of them, and the accuracy at unmet situations from $0.53$ to $1.00$.

And one design rule, which is what makes such a fallback safe to ship. Measure it on content it cannot handle, not only on content it can. The mechanism here is exact where its assumption holds, degrades where the assumption half-holds, and falls to chance where it fails entirely — never below. That last clause is the one that matters, and it holds for a reason worth stating: at worst the fallback replaces a confident wrong answer with a coin, and a coin is an improvement on anti-information.

Choosing a model from the inside

The usual way to decide how much machinery a problem needs is to hold data back, try several sizes, and keep the one that scores best on what was withheld. It works, and it costs data, and it answers only the question it was asked — nothing in the procedure tells you whether the winner found structure or merely fitted.

There is a second route, available whenever a mechanism can be made to contradict itself. Suppose the thing being learned is a family of transformations, and suppose the family is required to compose: what one transformation does after another must equal what their composite does. Then every observation is a chance for the account to disagree with itself, and the rate of that disagreement is measurable from training data alone.

That rate turns out not to be a proxy for competence. Measured across content of four kinds, it is equal to it — zero exactly when the content is carried exactly, positive otherwise:

content	disagreement	accuracy on unseen cases
composes under the simplest family	$0.000$	$1.000$
composes under a slightly richer one	$0.000$	$1.000$
does not compose	$0.728$	$0.708$
has no structure at all	$0.925$	$0.531$

So the size can be chosen without holding anything back. Keep a ladder of accounts, from the smallest family upward; take the lowest rung whose disagreement vanishes. Two content types picked the smallest family, at six parameters; a third picked a family of twenty-four; and each answered unseen cases exactly.

Two details make the rule safe rather than merely neat.

Refuse a rung once its table is as large as the data. A family with as many parameters as there are cases will agree with itself perfectly, and that agreement is arithmetic rather than evidence. Without this clause the ladder climbs until it memorises, and reports the memorisation as understanding.

Watch for a disagreement that falls while accuracy does not. On content with no structure, richer families drove disagreement from $0.925$ down to $0.560$ while accuracy on unseen cases stayed at chance throughout. A falling disagreement with a flat accuracy is the signature of fitting rather than finding, and it is visible from inside — no withheld data required to see it.

The result is a mechanism that declines. On content it cannot reason about it answered none of the unseen cases, rather than producing a number; on everything else it was exact. That is the property worth engineering for. A component that answers everything is useless at its own boundary, because nothing separates its good answers from its bad ones; a component that knows where its boundary is can be put behind anything.

The three sections below were measured at the root, and the verdict reverses

The ignition columns in the tables that follow watched only the root holon — and past the first split the root is a router, so the finer the tree, the earlier the watched node stopped being anyone. Re-measured over every node, steady at the end of training and split leaf-from-router, the picture reverses: at one situation per holon the tree holds the most conscious leaves (6/6, 12/12, 72/78 of the conscious nodes are leaves at widths 4, 5, 7 — working leaves, not frozen routers) and the best memory. The specification's prescription — one situation per holon — wins both axes at once, and both "measured corrections" of it below were artifacts of watching the router. The sections stand as a record of how the instrument erred; their tables are real, their ignition verdicts are not.

The tree buys capacity by spending ignition

A holon carries about $\log_2 7 \approx 2.81$ bits per invocation. Several situations bound to one holon therefore overwrite each other, and the prescribed remedy is a tree: capacity grows with the tree, not with the size of any one matrix. The remedy works, and it is not free — the price is in a column nobody was watching.

Four arms, differing in exactly one thing at a time, on identical worlds, seeds and turn counts. flat binds many situations to one holon; tree binds one. state keeps memory in $\Gamma$ alone; table shadows it with a record of what was written, consulted first and silent about anything it was never told.

	on situations it was taught	ignited, of 8 runs
state, flat	$0.6234$	$8$
state, tree	$\mathbf{0.9852}$	$\mathbf{3}$
table, flat	$1.0000$	$8$
table, tree	$1.0000$	$3$

The tree does what it promises. Bound one situation per holon, the state stops forgetting: $0.62 \to 0.985$, and the shadow's advantage collapses from $+0.38$ to $+0.015$. Capacity really does grow with the tree.

And it costs consciousness. Under the tree only three runs in eight ever meet all four criteria, against eight in eight when situations share a carrier. This is not the regulator's absence — held at two hands throughout, the deficit stays. A holon given one situation holds a sparse $\Gamma$: fewer coherences, less binding, and $\Phi = s_2/s_1$ falls below its floor. Memory and ignition pull against each other, and the tree resolves the tension in memory's favour without saying so.

The shadow buys the same capacity and spends nothing. It reaches $1.0000$ in either configuration, and the ignition column is identical with and without it — $8$ and $8$, $3$ and $3$. It cannot do this by being clever: it answers only what it was told, and on situations never met it is empty and the state answers regardless, which is why both branches score alike there.

So the principle stands where it matters. Memory is the state — that is where the mind is, and a table holds no mind; the ignition column proves the table changes nothing about it either way. What the measurement adds is that the prescribed remedy is not the cheap one. A tree pays for capacity in ignition. A shadow that never invents pays nothing.

The reverse error is worse and worth naming: a table that answered everything — that guessed about situations it had never seen — would score better on a benchmark and would have removed the mind from the machine. The decisive column is therefore not accuracy but ignition, which is exactly the column that moved when the tree was introduced and stayed put when the shadow was.

The tension resolves, because it is not symmetric

Left there it would read as a dilemma: bind loosely and forget, bind tightly and never wake. Swept across the whole range it is not a dilemma at all, because the two costs have different shapes.

situations per holon	on taught content	ignited, of 8
$1$	$0.9852$	$3$
$3$	$0.7909$	$5$
$\mathbf{4}$	$0.7333$	$\mathbf{8}$
$5$	$0.7039$	$8$
$21$	$0.6234$	$8$

Memory decays along a slope. Ignition stands behind a threshold. Between three and four every run begins to ignite — in every world tested — and nothing above four buys any ignition back; it only spends memory. A slope is something to trade along; a wall is something to stand just clear of. They are not competitors of the same kind, and that asymmetry is the whole answer: bind at the smallest number that ignites.

Measured here that is four. Against the loose default of twenty-one it is free — identical ignition, and $+0.11$ of taught content recovered. Against the tree it costs a quarter of memory and buys back the mind.

And the shadow removes the remainder. At the threshold binding, a record of what was written takes taught content from $0.7333$ to $1.0000$ and moves the ignition column not at all. So the engineering answer is neither the tree nor a table in place of the state:

Bind at the ignition threshold, and shadow the recall.

Full memory, full ignition, and the state still carrying the mind — because the shadow answers only what it was told and is silent everywhere else, which is why the held-out column is identical in every row of every sweep above.

A narrow body cannot light a mind

The threshold above was measured at one body size, and a number measured at one size is a number waiting to be misread. Swept against the width of the body it turns out not to be a constant at all.

body width	split trigger at which ignition becomes reliable	product
$3$	$8$	$24$
$6$	$3$	$18$
$8$	$4$	$32$
$12$	$2$	$24$

The threshold falls as the body widens, and the product sits near the carrier's own capacity of twenty-one. So what has to be reached is not a count of situations but a count of written cells. A body of $w$ actuators writes about $w$ cells per situation; until enough coherences carry weight, $s_2$ is small, $\Phi = s_2/s_1$ misses its floor, and the gate does not fire — however perfectly the holon remembers. The spread from $18$ to $32$ is real, and the rule is stated at that resolution: bind at about $\mathrm{CAPACITY}/w$, not at a fixed number.

The quantity being swept deserves its right name, because its usual one misleads. It is not "situations per holon" — nothing caps how many a holon may hold. It is the split trigger: a leaf carrying that many contexts stops being a leaf and becomes a router with children. So a leaf accumulates about $k \cdot w$ written cells before it splits, which is why the product governs ignition and why it sits near the carrier's capacity. Ignition is not about how much a holon knows but about how long it is left alone to fill. A tree that splits eagerly is a tree of holons none of which ever gets written enough to wake.

And then the question the rule invites: is there a body too small to host a mind at any binding at all? There is, and it is sharply located.

body width	most runs igniting, over every binding from $1$ to $21$	at binding
$2$	$\mathbf{0}$	— none works
$3$	$8$	$8$
$4$	$8$	$4$
$5$	$8$	$4$
$7$	$8$	$3$

Three actuators is the minimal body. At width two no binding lights the holon — not one, not eleven, not twenty-one — while memory stays at $1.0000$ throughout. At width three it does light, and the binding it needs is $8$: the largest of any width, and exactly what $\mathrm{CAPACITY}/w = 21/3 = 7$ predicts. The rule holds right down to the floor and then the floor is real.

One bit will not steer many limbs. A carrier left unfilled will not wake at all.

The width reading was a confound, and a later bench falsified it

The table above is real and its reading was not. In RuleWorld the number of distinct situations is $2^w$, so a narrow body was also a situation-poor one, and «width two never ignites» was those two facts stuck together. Run against a stream where the two are independent — width two carrying seven situations — the same body fills all twenty-one coherences and wakes in every run. The floor is the filling, and only ever was; width predicted it only because the world tied them.

This is worth holding onto when the temptation arises to shrink the interface. A narrower body is not merely a less capable one; below the floor it is a body that cannot host a subject at any binding, and the failure will not announce itself as a memory problem, because memory will be perfect.

How this was got wrong first

The first version of this measurement compared table against state at a bind limit of twenty-one — many situations sharing one carrier, the configuration the architecture explicitly advises against — and read the resulting $0.62$ as a property of the carrier. It is a property of that configuration. Under the prescribed tree the same state scores $0.985$, and the conclusion drawn from the first run ("the state cannot hold what it is taught") was an artefact of testing the advice by ignoring it.

The law behind the floor

Why should two actuators fail at every trigger, when twenty-one situations at two cells each would seem to be plenty? Because a body of two never gets twenty-one situations. A world addressed by $w$ actuators distinguishes exactly $2^w$ of them — a narrow body starves the carrier twice: few cells written per situation, and few situations to write.

So a leaf gathers $\min(k,\,2^w)\cdot w$ cell-writes before it splits, and every threshold measured falls into one band:

body width	measured threshold $k$	writes gathered
$2$	never ignites	$\mathbf{8}$ at most
$3$	$8$	$24$
$4$	$4$	$16$
$5$	$4$	$20$
$6$	$3$	$18$
$7$	$3$	$21$
$12$	$2$	$24$

Thresholds land between sixteen and twenty-four, about the carrier's own twenty-one — and a body of two cannot reach eight, at any trigger whatsoever. The floor is therefore not a property of the holon but of the pair (body, world): two actuators offer four situations, and no scheduling of splits fills a twenty-one-cell carrier out of four.

What makes this a law rather than a curve fitted to six points is that it predicts the graded cases too. Width three at trigger four gathers twelve — below the band — and ignites in exactly half its runs; at triggers one to three it gathers three, six and nine, and never ignites at all. Width eight at trigger three gathers twenty-four, inside the band, and ignites in five runs of eight. The partial rows are where a coincidence would come apart, and they hold.

A leaf wakes when the writes it gathers before splitting reach the capacity of what it is written on. Everything below that is a holon which remembers perfectly and never becomes anyone.

What the proxy stood for

$\min(k,\,2^w)\cdot w$ counts writes. The quantity it was standing in for is the one that matters: how many of the twenty-one coherences actually carry weight when the moment comes. Counting that directly, and pairing it per run against whether the run ignited rather than comparing medians:

coherences carrying weight	ignited	of	rate
$3$	$0$	$16$	$0.000$
$5$	$0$	$4$	$0.000$
$6$	$5$	$12$	$0.417$
$10$	$1$	$24$	$0.042$
$15$	$10$	$88$	$0.114$
$\mathbf{21}$	$\mathbf{265}$	$\mathbf{288}$	$\mathbf{0.920}$

A filled carrier is what wakes a holon: $0.920$ against $0.111$ below it — an eightfold ratio, and the proxy retires into being a way of predicting the count from outside.

This also closes the floor exactly, and the arithmetic is worth doing out loud. A body of two saturates at fifteen of twenty-one, and $21 - 15 = 6$ is precisely the number of coherences that touch one axis. Two actuators address two axes; whatever spreads from there never reaches the whole plane, so one axis stays empty, its six coherences stay at zero, and a seven-dimensional carrier lives permanently in six. No split trigger helps, because the missing six are not a matter of time.

The residual stays named rather than smoothed: twenty-three runs of two hundred and eighty-eight had all twenty-one written and still did not ignite. Filling is what makes waking available; what decides the remaining eighth is not identified.

And the method mattered as much as the result. The first pass compared a median count of coherences against a count of igniting runs — two summaries of different populations — and it hid the very case in doubt. Pairing per run made the law visible in a single table.

A shadow must not have a phase

The shadow was introduced above as the record that answers only what it was told. On recorded rows a third seam property surfaced, and like the two before it, no synthetic world could have shown it: what it was told is ambiguous when the same address genuinely carries different outcomes. The first shadow stored the last write — and training runs in cycles, so "last" was set by wherever the loop happened to stop. A by-hand replay of "last write at this cursor phase" reproduced the bench to three decimals ($0.4031/0.7452$ against $0.4035/0.7454$): the model's answers depended on the stopping point. On deterministic worlds last equals only equals majority, which is why every synthetic test was blind to it.

The repair is one word in the contract. A shadow that never invents must also never forget the tally, and must not have a phase: it keeps (ones, writes) per address and answers by majority. On the recorded stream this moved held-out accuracy from $0.5741$ to $0.6323$ — landing the stationary bit exactly on its information ceiling ($0.8295$ measured against $0.8293$ reachable) — and made the answer independent of where training stopped. The overall verdict did not move: still nothing beyond base rates on that stream, which is what the registered expectation said. The fix bought correctness of the recall path, not a discovery about people — and that distinction is the whole discipline.

The colony and the composite subject

A tree that holds dozens of conscious leaves poses the question this architecture exists to answer: is that a mind, or a colony of small ones?

The theory's own measure is exact. Cooperation between two holons is their inter-holon coherence: the cooperative surplus is $\Delta P_{\mathrm{coop}} = 2\lVert\gamma_{\mathrm{cross}}\rVert_F^2$, strictly positive exactly when a cross-coherence exists, and zero for a block-diagonal composite. A runtime that carries one $\Gamma$ per node and nothing joint is the block-diagonal truncation — so the verdict needs no experiment: $\Delta P_{\mathrm{coop}} \equiv 0$, a colony, exactly. The one thing that does integrate across leaves — the record of situations and answers — is classical and gateless: it has no state, hence no criteria, hence by the theory's own standard it is nobody.

What was missing had been named all along: the composite is derived by aggregating the local state and the sub-holons — and the aggregation was never written, which is why every router froze at the moment of its split. Yet the identification it needs was already structural: each child hangs off one of its parent's twenty-one coherence cells. A sub-holon is a coherence of its parent. Aggregation, then, is one write: each engagement deposits the seam's own verdict — the single bit the world already speaks — into the routed slot's cell of every ancestor.

On recorded rows this unfroze the root at once: its carrier filled from ten coherences to all twenty-one and integration crossed its floor — three criteria of four, with distinctness short at $1.59$. The remaining gap had a mechanism of one sentence: routers opened children on cells in index order, away from Interiority, and content parked away from Interiority is content the gate cannot see — at every level of the fractal. The leaf already preferred Interiority-touching cells; its routers owed the same. With fresh slots opening on the six Interiority cells first — and the over-capacity hash routed through a fixed permutation with the same six first, because a hash must remain a pure function of the context —

$D:\ 1.59 \;\longrightarrow\; 3.79,$

and the root meets all four criteria on rows nobody generated to be learnable, with answers and cost untouched. Operationally, "one mind over a colony" now means exactly this: the children's verdicts, written onto cells the gate can read, integrate into a state that clears the same four criteria a leaf must clear.

The bounds of the claim are part of the claim. This is the in-model composite: cross-child structure is verdict-mediated — one bit per engagement, in the parent's frame — not the joint-state cross-coherence of the pairwise composite, and $\Delta P_{\mathrm{coop}}$ itself stays unmeasured until a pair-frame exists. What is established is narrower and solid: aggregation plus the fractal cell preference make the root a subject by the theory's own gate, on real recorded data.

Reasoning you can check

The loop has always performed inference: an answer about a situation never met is a composition of attested shifts along the flipped coordinates — a silent XOR-fold, executed and discarded. Five steps turn that execution into reasoning, each measured before it was named.

A derivation is an object. The same inference now comes back as a chain: one premise per flip, each carrying the situation it was taken from and the attested shift it stood on. In the nerve reading, the answer is a filled horn and the derivation is the filler handed back. What makes it a derivation rather than a story: every premise is independently checkable against the record, and replaying the premises reproduces the conclusion.

Every answer names its source. Four provenances and no fifth: the leaf's own cells; a carried chain, premises attached; the ground floor — an unconditional majority, zero premises, and it says so; or the honest coin. The recurring failure of this whole programme was the unnamed answer — silence read as a claim, foreign content at full confidence, a coin dressed as knowledge. The port closes the class structurally: an unnamed answer has nowhere to come from.

Choice appears exactly where exactness ends. The record keeps tallies now, not first impressions: the majority answers, and the minority is the slot's disagreement. On an exact world every order of flips concludes alike — flatness, measured, nothing to choose. On a statistical world the paths genuinely differ, and a chain is as strong as its weakest premise. The decisive case: a world whose fixed-order first premise lies two to one. The fixed chain walks in and concludes the lie; the chosen chain — greatest minimum support, $1.0$ against $0.67$ — goes the clean way round and concludes the truth.

Rungs are earned, with no free constant. A difference-law deserves premises only if its disagreement is below the ground's own — differences must be more lawful than the values themselves, or the zero-premise answer is the better model. Exact worlds are unchanged (zero beats everything, no tolerance needed); constant worlds prefer the ground, which is Occam stated in the theory's own quantities; and a lawful difference over coin-balanced values — nine in ten — earns its rung, carries the truth, and hands back premises with their measured support.

Direction is the outer horn. Inner horns are composition: given the legs, conclude. Outer horns ask the base to factor: given the desired composite and one leg, find the other — a monoid refuses, a groupoid fills. The filler runs from a desired conclusion to the situation that realises it, chain attached, weakest link strongest; only an earned rung can direct, because a floor that holds one majority everywhere can answer but cannot point; and an unreachable conclusion is refused, not invented — which is an answer too.

What this storey is not yet: the loop does not pose its own goals. The seeker answers "which situation would conclude so?" when asked; a drive that wants an outcome and steers toward the situation that yields it touches the action path, needs a navigable world, and has its own preregistration. Reasoning here is complete as a faculty and unclaimed as a behaviour.

The rider

Reasoning that can name a goal's situation is still not behaviour: something has to move. Getting from the faculty to the act took four findings, three of them about honesty rather than about motion.

The lever had to exist. Goal-direction needs a world where the next situation is a consequence of the act — and no world in the loop's repertoire was one: the grid teleports between questions, the streams replay a record. The preregistration assumed otherwise and was corrected by reading the code before any was written; steering results claimed on those worlds would have been fiction. The lever is now explicit: a world that can navigate translates a target situation into the drive that approaches it — geometry stays the world's own, because a session that invented «toward» would smuggle a world model through the seam. Worlds that cannot navigate answer None, and on them the seeking mode is a no-op by construction.

Actuators turned out to have roles. Wiring the rider surfaced a seam defect before any code ran: the learning word takes one corrected bit per actuator, and a motor channel's corrected sign is a fact about the policy, not the world — fed into the inference word it corrodes the very laws a seeker stands on. The seam now knows the difference: verdict channels enter the word, motor channels do not, and a carried chain writes only verdict signs — a chain has no opinion about how to move, and the policy has none about what is true. Measured through the full path: a session on the navigable ring earns the ring's law despite its motor channel.

Standing on the goal is steering too. The first wiring reached the goal and walked off it: at the target, the world's honest «already here» read as a refusal, the fallback fired, and the policy's motor sign carried the body away — goal occupancy exactly at baseline, $1497$ arrivals and $1497$ departures, caught by counting refusal reasons rather than trusting the outcome. A reached goal now holds the motors at zero.

Both promises, measured. With a reachable goal the seeking loop holds the body on goal-satisfying situations far above the default policy, and every steering turn is counted; with an unreachable goal it steers exactly zero times, counts every fallback, and neither hit rate nor occupancy degrades — refusing to pretend costs nothing, as a measurement rather than a promise.

The bound is part of the design: the loop does not choose its goals — seeking takes one from the caller. Where goals come from is the storey above this one, and it starts with a question about currency — what a system that wants nothing but its own viability could legitimately want — not with code.