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: layers couple through present boundary throughput, not through shared recursive history. A lower layer’s present output can carry great structure across the join, and the higher layer can respond to it in detail, but the history that generated that structure, and the layer’s stored recursive activity, are private and never enter what the higher layer depends on. The higher layer depends on the bare fact that the layer below still holds together; what it consumes is the throughput that fact makes available. 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 in dependency, a higher layer depends on a lower one, never the reverse. One caution about arrows, because two point in opposite directions and readers routinely cross them. Dependency runs down: the upper layer B depends on the lower layer A (write B ⇒ A). Throughput flows up: A’s present output supplies B (write A → B). “Downward-only” and “no upward dependency” are claims about the first arrow, the dependency graph, and say nothing against the second. There is real upward influence; there is no upward dependency. Keeping those two arrows distinct is what keeps the rest of this page from sounding paradoxical. (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 present throughput?

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. But be careful not to mislabel the channel. Basin movement is not how the layers couple, it is the higher layer’s response to being coupled. The chain runs: the lower layer’s present output crosses as throughput; the higher layer meets or misses its own maintenance on that throughput; its own recurcline rises or falls; and that is what deforms its basin and shifts its stability margin. So the channel is throughput, the private state is history, and the basin shift is the response, three different things the older phrasing ran together.

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.

Notice that this description keeps reaching for one thing the canon does not name with a single symbol: the admissible transformation at the boundary between two recursion depths, the map that takes the lower layer’s present state to the throughput the upper layer consumes. The framework already supplies its parts, and this page is assembling them, not adding a construct: Φ-COUPLE (§3.3) pays for the maintenance-and-inflow relation; the ATTRACTLET conduit clause (§7.4) licenses a non-recursive join to “channel, gate, shape, or convert” recursive activity into throughput; and SOV-OPA (§5.3) fixes what such a join may not carry, the lower layer’s α, Rc, and transaction history never enter the upper layer’s dependency closure. Whether that assembly deserves a dedicated cross-depth interface construct of its own, or is already fully paid for by Φ-COUPLE and the conduit clause together, is a live question for the kernel’s own amendment process, not a claim made here, and nothing on this page turns on the answer.

The four-way sort

Four quantities, kept deliberately apart, because the older three-way version collapsed the channel and the response into one row, which is the error this page is correcting.

Stacked sovereigns do not share α-trace, the framework names α-trace and recurcline as exactly the content that cannot cross recursion depth. They couple through present throughput: the join converts the lower layer’s present output into supply the upper layer consumes, while the layer above depends only on the fact that the layer below still holds together. Basin movement is not that channel, it is the upper layer’s response to it. Recurcline is what is at stake, not what crosses: each layer’s recurcline is private, and the throughput carries the lower layer’s present structure without carrying the history that produced it.

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.