Invariance-Gated Dendrites (IGD)

There are two kinds of intelligence.

One kind thinks, speaks, improvises, associates, dreams. It generates… and it forgets. It is powerful, but it is not automatically trustworthy, because it has no hard boundary between “I considered this” and “this is true”.

The other kind builds structure. It commits. It creates a durable map of relationships that future reasoning depends on. That map becomes the world, because once you rely on it, it starts steering everything.

Most modern frontier models blur those two modes. They generate a thought, then treat the thought like a fact, then treat the fact like a foundation… and that is how systems accumulate invisible errors, drift, and self-poisoning.

Invariance-Gated Dendrites (IGD) is the architectural rule that splits thinking from committing.

It says:

1. You may compute in any dimensionality you like.
2. You may propose any relationship you like.
3. You may only grow a dendrite into Stan when the relationship is proven invariant under specified tests.

In short… free imagination, gated permanence.

1. Core intuition

A dendrite is a commitment. It is the moment a system decides that a relationship is real enough to become part of the durable structure it will use tomorrow.

If you allow dendrites to form from mere activation or persuasive language, you get a graph full of “seems true” artifacts… which is the graph version of hallucination.

IGD prevents that by requiring a candidate relationship to be invariant.

“Invariant” here does not mean philosophically absolute. It means something practical and testable:

• The relationship persists across multiple views of the same underlying situation.
• The relationship survives compression, reparameterization, and alternate reasoning paths.
• The relationship fails when it should fail (targeted falsifiers break it).
• The relationship does not conflict with the existing committed structure beyond tolerance.
• The relationship is worth storing (it improves prediction, coherence, or compression).

Only then does it become a dendrite.

2. Definitions

2.1 Field

The Field is the ephemeral working state of thought.

It is not a sentence. It is a tensor… a structured activation space that can hold hypotheses, representations, and intermediate constructs without claiming permanence.

Call it:

X \in \mathbb{R}^{d_1 \times d_2 \times \dots \times d_k}

The exact axes are an implementation choice. Typical axes include:

• entities or tokens
• features
• roles
• time / sequence
• context partitions
• uncertainty channels

The Field is allowed to be messy. That is the point.

2.2 Operator stack

An Operator stack is a sequence of transformations applied to the Field. Operators can:

• increase dimensionality (expand, factorize, introduce latent axes)
• decrease dimensionality (compress, project, pool, enforce low-rank structure)
• reframe dimensionality (rotate basis, reparameterize, normalize)

Write the stack as:

\Omega_i = (\phi^{(i)}_1, \phi^{(i)}_2, \dots, \phi^{(i)}_m)

Multiple stacks are used to create multiple “views” of the same situation.

2.3 Candidate relation (proto-edge)

A candidate relation is a proposed edge, not yet committed:

\hat{e} = (u, r, v, w, \pi)

Where:

• u, v: endpoints (existing Stan nodes or provisional proto-nodes)
• r: relation type (typed, not free text)
• w: confidence score (scalar or vector by test class)
• \pi: provenance bundle (which operators, which evidence slices, which tests)

2.4 Stan

Stan is the durable structure store… the committed graph of meaning-bearing relationships.

Nodes represent stable denota or concepts.

Edges represent verified relationships with types, weights, and provenance.

Stan is allowed to grow, but it must not become polluted.

2.5 Dendrite

A dendrite is the act of committing structure into Stan.

A dendrite may commit:

• a single edge
• a micro-subgraph (a small motif)
• a typed invariant bundle (a relation plus its constraints)

But it always represents a transition from ephemeral to durable.

3. The IGD principle

3.1 The separation

IGD insists on a strict separation between:

• Thinking mode: free exploration in the Field
• Commit mode: gated insertion into Stan

Thinking mode is allowed to be wrong.

Commit mode is not.

3.2 The gate

The gate is a decision procedure:

\text{IGD\_COMMIT}(\hat{e}, X, S) \rightarrow \{ \text{commit}, \text{quarantine}, \text{discard} \}

The system can be generous in what it proposes… but strict in what it keeps.

4. Invariance, precisely

“Invariance” is defined by a test suite, not vibes.

IGD uses two sets:

• Transformation set T: operations that should not change the truth of the relation
• Falsifier set F: operations that should break the relation if it is spurious or overbroad

4.1 Transformation invariance

A candidate relation should survive under transformations such as:

• alternate operator stacks (different \Omega_i)
• compression / projection
• basis change
• time pooling or slight reordering
• representation swaps that preserve meaning

Formally… if t \in T,

\text{score}(\hat{e} \mid X) \approx \text{score}(\hat{e} \mid t(X))

Within tolerance.

4.2 Falsifier sensitivity

A candidate relation should fail under falsifiers such as:

• targeted counterfactual edits
• removing the purported cause
• adversarial “opposite claim” probes
• decoy correlations
• negative sampling where the relation should not hold

If f \in F,

\text{score}(\hat{e} \mid f(X)) \ll \text{score}(\hat{e} \mid X)

This is what prevents “everything relates to everything”.

4.3 Compression stability as the spine

Compression stability is the most important invariance test because it guards against high-dimensional mirages.

If a relation exists only in a bloated representation and disappears when you compress, it is not a stable structural truth… it is scaffolding.

So IGD treats “survives compression” as a central requirement.

5. The commit criteria

A practical IGD gate uses five pillars.

5.1 Multi-view agreement

Run multiple trajectories \Omega_1 \dots \Omega_n. Each produces a score for the candidate edge.

Aggregate robustly:

w = \text{median}_i \; w_i

Require sufficient agreement:

\frac{\#\{i : w_i \ge \tau\}}{n} \ge \tau_{\text{view}}

This guards against one weird reasoning path.

5.2 Compression stability

Compress the Field to \tilde{X} (projection, low-rank, pooling).

Require:

|w(X) - w(\tilde{X})| \le \epsilon_{\text{comp}}

Or stronger… the commit decision must be identical under compression.

5.3 Falsifier pass

Run falsifiers. Require that the edge is not “cheaply true”.

A simple rule:

• robustness tests do not break it
• targeted falsifiers do break it

5.4 Non-contradiction with Stan

Compute the contradiction cost of inserting \hat{e} into Stan:

C(\hat{e} \mid S)

If C exceeds tolerance… do not commit. Place into quarantine, or require reconciliation.

This stops graph rot.

5.5 Value test

Even if something is true, it might not be worth storing.

IGD requires that a committed dendrite yields value such as:

• improved prediction
• reduced description length (MDL gain)
• improved coherence of downstream reasoning
• reduced uncertainty where it matters

This prevents Stan from becoming a junk drawer.

6. Three-tier dendrites

Not all relations should be held with the same rigidity. IGD makes this explicit.

6.1 Hard dendrites

These are structural or logical invariants. Example:

• “If A then B” under specified conditions
• “A excludes B”
• “A implies constraint C”

Hard dendrites demand strict invariance and near-zero contradiction tolerance.

6.2 Soft dendrites

These are probabilistic tendencies. Example:

• “A usually co-occurs with B in domain D”
• “A increases likelihood of B”

Soft dendrites must be typed as soft. They must never masquerade as law.

6.3 Conditional dendrites

These attach explicit scope and preconditions. Example:

• “In domain D, under posture P, when condition K holds… A relates to B.”

Conditional dendrites are the bridge between reality and abstraction. They keep Stan honest.

7. The “dimensional breathing” engine

IGD pairs naturally with a layered matrix architecture because invariance is easiest to test when you can systematically expand and compress representation.

7.1 Expand

Expanding increases separability… it lets the system find structure that was entangled.

Mechanisms:

• higher-rank factorization
• introducing latent axes
• attention over roles
• multi-head relation proposal spaces

7.2 Compress

Compressing tests whether discovered structure is real.

Mechanisms:

• low-rank projection
• pooling and summarization
• basis normalization
• pruning weak channels

7.3 Breathing loop

The system alternates:

1. expand to discover candidate relations
2. compress to test survival
3. propose edges from what survived
4. run invariance tests across multiple breathing trajectories
5. commit only what holds

This is thinking that refuses to confuse scaffolding with structure.

8. Parameterisation compared to frontier models

A frontier model centralizes capability in weights.

IGD distributes capability across:

• oracle weights (moderate)
• operator stacks (lightweight or even fixed)
• the invariance gate (mostly tests, not weights)
• Stan (explicit stored structure)

So the proper comparison is not “how many parameters”… it is “where does the world-model live”.

8.1 Frontier

• world-model mostly in weights
• structure mostly implicit
• drift and hallucination accumulate invisibly

8.2 IGD

• world-model increasingly in Stan
• weights propose, tests verify, graph stores
• drift is visible because structure is explicit and typed
• self-poisoning is constrained because commits are gated

IGD scales by growing verified structure, not just by inflating weights.

9. Failure modes and how IGD contains them

9.1 Hallucinated relations

Containment: fail compression, fail multi-view agreement, fail falsifiers.

9.2 Overgeneralisation

Containment: falsifiers, conditional dendrites, scoped relations.

9.3 Contradiction cascades

Containment: contradiction cost check, quarantine, reconciliation protocols.

9.4 Graph bloat

Containment: value test, redundancy merging, edge retirement.

9.5 Adversarial poisoning

Containment: provenance requirements, invariance tests, non-contradiction, and domain gating.

IGD does not claim perfection… it claims structural hygiene.

10. Quarantine and reconciliation

A mature IGD system does not treat non-commit as failure. It treats it as epistemic honesty.

If an edge is:

• promising but contradictory
• strong in one domain but unclear in another
• sensitive to one compression path

…then it goes to quarantine.

Quarantine is not Stan. It is a holding pen for edges that require:

• more evidence
• tighter scope
• explicit conditions
• disambiguation of node identity

Reconciliation is the discipline of turning “almost” into “yes, but precisely”… or discarding it cleanly.

11. Implementation skeleton

A minimal IGD pipeline looks like this:

1. Build Field X from inputs and current Stan context

2. Run trajectories \Omega_1 \dots \Omega_n to produce multi-view Fields

3. Propose candidate edges \hat{e} from each view

4. Aggregate candidates and compute robust scores

5. Run invariance suite:

   • transformation invariance

   • compression stability

   • falsifier sensitivity

7. Check contradiction cost against Stan

8. Run value test

9. Decide: commit, quarantine, discard

10. If commit… write dendrite into Stan with provenance

This is small enough to ship… and strict enough to matter.

12. Why IGD changes the game

Frontier models are incredible improvisers. They are not disciplined builders of durable truth.

IGD is a discipline.

It does not reduce intelligence… it refines it. It allows a system to be wildly creative in the Field, while remaining conservative about what becomes part of its long-term structure.

That is how you get an architecture that can:

• learn without poisoning itself
• improve without drifting
• grow without becoming incoherent
• stay corrigible because its commitments are explicit
• stay auditable because its invariants are testable

IGD is not “a better prompt”. It is not “a safety layer taped on later”.

It is a fundamental split between:

• what you may imagine
• what you may write into the world

And that split… done properly… is the beginning of a thinking architecture that can be trusted to keep building.