How Stacked Attractors Couple

When one sovereign attractor rests on another, what passes between them — and what cannot?

When one sovereign attractor rests on another as a stack — one riding on the substrate of the other — how do the layers “talk”? The tempting answer is that they share history — that the record one layer keeps (its α-trace) reaches the layer above. The framework’s answer is the opposite, and it is sharp: a layer’s history and its stored recursive activity are private and non-propagating. What crosses between layers is only the bare fact that the layer below is still holding together. The eukaryotic cell is the guiding example throughout — though, as the last section makes plain, it turns out not to be a two-sovereign stack at all, but one sovereign with non-sovereign machinery: the framework’s hardest case, not a clean one.

First, the terms

A stack is vertical sovereignty layering, in which sovereign attractors at lower levels are the substrate for sovereign attractors at higher levels. In the framework’s bootstrapping ladder this is the hierarchical-stack mode: persistence at one level enabling autocatalysis at the next. Crucially, an admissible stack is downward-only — a higher layer depends on a lower one, never the reverse. (A community acting as a single sovereign is a different construct, a colony, whose dependence is lateral and mutual rather than vertical; a colony can itself be stacked, but stacking and colony-formation are not the same move.)

The word “communicate” needs care. The framework has no message-passing primitive. What it has is a strict rule about what one layer can and cannot reach of another — and that rule is the whole answer.

The rule: sovereignty is locally absolute and globally opaque

Higher layers of a stack are structurally walled off from the internals of the layers beneath them. The kernel states this directly:

And the one-line form the kernel pulls forward from its own prior edition:

This is not a limit on what is known. It is a fact about which stacks are admissible at all: a stack in which a higher layer needed to reach into a lower layer’s history would introduce an upward dependency, break the framework’s downward-only dependency direction, and fail to be an admissible stack in the first place. Opacity is what lets a clean stack exist at all.

So — through α-trace, or through basin movement?

This is the question, and the canon answers it by name. The two candidate quantities — a layer’s α-trace (its record of its own past) and its recurcline (its present stored recursive grip on continuation) — are exactly the two the kernel says do not cross:

So α-trace is ruled out as a cross-layer channel, and so is recurcline — not because they are hard to read, but because a higher layer is forbidden to depend on them. What a higher layer is permitted to depend on is stated just as plainly: the fact of the lower layer’s continued admissibility and persistence. That dependence on a lower layer’s ongoing persistence, and the way that persistence shifts, is what we loosely called “basin movement.” It is the right family of answer.

Where recurcline actually sits: the stakes, not the channel

It is tempting to make recurcline the thing that flows between layers. It is not. Recurcline is present only in a sovereign attractor, and only across its own active lifetime; each layer keeps its own. But recurcline is not irrelevant — it is precisely what the coupling raises or lowers. The interface between layers is where recursive activity is converted: the framework allows a non-recursive conduit to

So the causal picture across a stack runs like this: the lower layer’s activity is converted at the interface into the throughput the upper layer consumes; the upper layer meets or misses its own maintenance cost; its own recurcline rises or falls; its basin shifts and its stability margin widens or narrows; and, if the margin is crossed, it is lost. Recurcline is private the whole way through — but a basin shift is the observable shadow of a recurcline change underneath.

The three-way sort

Stacked sovereigns do not share α-trace — the framework names α-trace and recurcline as exactly the content that cannot cross recursion depth. They couple through the downward persistence relation: the layer above depends on the fact that the layer below still holds together. That coupling shows up as basin movement. Recurcline is what is at stake, not what crosses: the join converts the activity it tracks into throughput, while recurcline itself is never shared.

The eukaryote — the case that looks like a two-sovereign stack, and isn’t

Can a nested attractor evolve while it is embedded?

The eukaryote turned out not to be a nested sovereign at all — one sovereign, with non-sovereign machinery inside it. But the genuine case does occur: a lower layer that is itself a sovereign attractor, embedded beneath a higher one. And it raises a sharp worry. If such an attractor is “snapped into” a regime, how can it keep changing — adapting, accumulating history — without violating the very thing that defines it? The worry rests on a misreading of the word regime, and the kernel dissolves it.

“Regime” is an existence status, not a groove. The three regimes — pre-attractor, active, post-loss — are the kernel’s answer to a single question: does the attractor exist as a dynamical structure right now? The kernel says they “exhaust the attractor’s existence status” (§3.10, BAEP). The active regime is defined not as a frozen state but as being alive:

What is discrete is existence — ignited or not, with no “30% attractor” in between. But within the active regime the structure does continuous internal work; one that stopped changing internally would be a crystal, not a recursion. The regime is the fence around the field, not a rail across it.

The kernel does not merely permit internal change — it records it, even under embedding:

Be precise about what this guarantees. Ongoing internal work is required of any active attractor — its α-trace keeps accumulating, its maintenance keeps being paid. Adaptive reorganization on top of that is permitted, through the framework’s adapt/reconfigure transitions, not mandated. Neither is a violation of anything.

And here is why it cannot break opacity, however far the lower attractor evolves: the higher layer never coupled to the lower’s history in the first place. What HIST-COMP hands upward is the lower attractor’s present compressed structure — and the bare fact that it persists. Internal evolution merely updates that present; it changes what the higher layer sees now, and never becomes a dependency on the history that produced it. Evolution is invisible-as-history and visible only as an updated present — so it creates no upward dependency, and opacity stands.

This is the same shape as the persistence distinction: a sovereign attractor persists in the maintained sense — it holds together by doing the work, and would fall apart if it stopped. Doing the work is changing internally. “Following a regime” by holding still is the dead case, not the live one. Evolving within the regime is not a loophole in the framework; it is the framework’s own definition of being alive.