Canonical · Core Concept

Attractors versus Attractlets

Two registers of description, and why only one kind of thing carries both

A sovereign attractor holds itself together; an attractlet only looks the part, held together from outside. Those two companion pages settle what each is. This page is about how each is described, and the difference is an asymmetry rather than a symmetry. Every structure can be described in the classical register: energy, entropy, mass, momentum, time. A sovereign attractor can be described that way too, since it is made of matter and pays an energy bill like anything else. But a sovereign attractor also admits a second register that an attractlet does not: the recursion-native quantities (recurcline, logic mass, stability margin, continuation cost, α-trace) that describe it as a self-maintaining recursion and that do not reduce to its physics. The attractor carries both registers; the attractlet carries only the classical one. The claim this page defends is that the second register is irreducible to the first, in that it cannot be recovered from the physics by any conversion, and that essentially one quantity in it, the α-trace, is legible in both.

Two registers, and who carries them

A register is a vocabulary of description with its own quantities. Two are in play.

The classical register

Physics: available to everything

Energy: supplied, spent, conserved.
Entropy: the bookkeeping of disorder.
Mass, momentum, force: inertia, motion, push.
Time: rates, durations, an external ruler.

Every structure has a classical description, an engine, a cell, and a crystal alike. It is the register the outside world supplies and bills in.

The recursion-native register

Recursion: available only to a running sovereign attractor

Recurcline: the stored compression of a running recursion.
Logic mass: resistance to being reconfigured.
Stability margin: distance to the rupture boundary.
Continuation cost: the per-step price of persisting.
α-trace: the accumulated record of what survived.

These are defined only inside an active sovereign attractor, only across its bootstrapping interval. For an attractlet they are not small; they are undefined.

The asymmetry is the point. The two registers are not sealed universes with no exchange between them; a sovereign attractor plainly has a classical description, because it is matter and it runs on energy. The real structure is asymmetric in the following way. A sovereign attractor admits both registers: you can weigh it in kilograms and also speak of its recurcline. An attractlet admits only the classical one: it has energy and mass, but recurcline, logic mass, and α-trace are undefined for it, because it is not a running recursion that could carry them. The recursion-native register is the extra description that self-maintenance earns, and it comes with one governing prohibition: you may not attribute recursion-native quantities to a thing that is not a sovereign attractor.

Why each thing carries the register it does

The asymmetry above is not a brute fact to be accepted. There is a mechanism, and it is the four sovereignty conditions themselves. The register a structure carries is not assigned by convention; it is determined by whether the structure satisfies those conditions, and in the affirmative case the recursion-native quantities are literally generated by their satisfaction.

Start with the direction that is easy to miss. The recursion-native quantities are not labels we choose to attach to an attractor. Each is the shadow cast by a sovereignty condition being met. The loop closing is what makes there be an internal ordering to call sequence. The self-produced boundary is what makes there be a distance to its own rupture, a stability margin. The self-borne maintenance is what makes there be a cost paid from within. And recurcline is generated by the recursion itself; the framework is emphatic that recursion generates recurcline and never the reverse. Satisfy the conditions and you do not merely qualify for the second register; the act of satisfying them is what produces the quantities the second register measures.

Sovereignty condition satisfied	Recursion-native quantity it generates
Recursion lock (the loop closes)	Sequence / tik: an internal ordering exists because the loop runs
Internal recurcline persistence	Recurcline: the stored compression the running recursion accumulates
Boundary retention (self-produced boundary)	Stability margin: distance to its own rupture boundary
Maintenance-bearing continuation	Continuation cost: the bill paid from within
the accumulated history of all four	α-trace: the record of what survived selection

The correspondence is illustrative, not a claimed one-to-one law: several quantities draw on more than one condition (recurcline, for instance, is bound up with both persistence and maintenance). The table names the condition that principally generates each quantity, showing that the recursion-native register is produced by the sovereignty conditions rather than stipulated alongside them.

And the other direction is why the attractlet is bound to the classical register alone. An attractlet is held up from outside: its boundary is supplied, its maintenance is paid by an external agent, and its loop, if it has the look of one, is driven rather than closed. Every one of those is a purely classical relationship: energy supplied, force applied, parts provided, all measured with the outside's ruler. Being-held-from-outside is not a recursion; it is a transaction in the classical register. So an attractlet does not fail to earn the recursion-native register by some shortfall of degree. It generates none of those quantities because it satisfies none of the conditions that would produce them. There is nothing recursion-native about it because nothing about it recurses.

This is the link, and it runs in both directions. Satisfy the sovereignty conditions and the act of doing so generates the recursion-native quantities, so an attractor carries that register (and, being matter, the classical one too). Be held from outside and every relation that sustains you is classical, so an attractlet carries the classical register and nothing else. The register a thing carries is downstream of the sovereignty test that decides its kind.

The thing the pair leaves out: the recursive middle

“Attractor or attractlet” is not the whole map. Set beside sovereignty, the pairing on this page can read as a clean binary, sovereign attractor on one side and attractlet on the other. It is not. Between them sits a real and populated middle: structures that are genuine recursions, whose loops close and which are not held up from outside, but that have not achieved sovereignty, because they do not yet self-produce their own boundary or bear their own full maintenance. A base or coordination attractor is exactly this: recursive, not sovereign, and emphatically not an attractlet. The framework treats these as their own case, recursive but not sovereign, the same class it assigns a prion or a present-day AI agent. Such a structure carries the recursion-native register only partially: it has some of the quantities (a real loop, some persistence) but not the full set that sovereignty completes. The two-register picture below is drawn for the two ends, the fully sovereign attractor and the non-recursive attractlet, because they are the clean cases. The middle is not erased by that choice; it is where most real structures actually live, and it is treated on its own pages.

Irreducible counterparts

Several recursion-native quantities are the loop-internal counterparts of classical ones. They play the same descriptive role, but native to recursion rather than to physics, and they do not reduce to their classical partners. Irreducibility, not disjointness: a sovereign attractor has both the classical quantity and its recursion-native counterpart, and the counterpart cannot be recovered from the classical one by any conversion.

Classical quantity	Recursion-native counterpart	What the counterpart captures
Mass (inertia)	Logic mass	Resistance to reconfiguration: how hard the structure is to reshape. Inertia, but of recursive organization rather than of matter.
External time	Sequence / tik	The recursion's own internal ordering, anchored at ignition. The attractor still runs at physical rates; what is recursion-native is that its ordering is individuated by what the loop has done, not by an external clock.
Energy / free energy	Recurcline	The stored capacity a running recursion draws on to persist and resist dissolution, but with no conservation law, no force-units, no thermodynamic conversion.
Distance to failure	Stability margin	How far the attractor is from the rupture boundary: a recursion-native measure of nearness to loss.
Running cost	Continuation cost	The per-step price of continuing, paid from within. Every attractor runs at cost; this is the recursion-native bill.

On “quantity.” These are descriptors with definite structural roles, not loose metaphors, and the framework defines measurement procedures for them in its persistence-descriptor canon, the bootstrapping interval metrics, where recurcline, logic mass, stability margin, and continuation cost each have an operational form. What makes them recursion-native is not that they are unmeasurable but that their measurement is defined only inside a running sovereign attractor and does not reduce to a classical reading. A large logic mass predicts a structure hard to reconfigure; a thin stability margin predicts nearness to rupture. The scale lives in the metrics; this page points rather than restates.

The recursion-native register is the extra description a structure earns by maintaining itself: irreducible to the classical account, defined only while the recursion runs, and carried only by the things that recurse. An attractlet, held up from outside, does the classical bookkeeping and stops there.

The α-trace: the one quantity legible in both registers

There are two very different boundaries in play on this page, and it is worth naming them before they get run together.

Boundary A, between the registers. The line between the classical description and the recursion-native one. Most recursion-native quantities live wholly on one side of it: recurcline, logic mass, stability margin exist only while the loop runs and have no classical reading.

Boundary B, between one attractor and the next. The line at which a sovereign attractor is lost and a successor ignites. The framework holds that identity does not cross this line: when an attractor ruptures it is gone, and what arises after must ignite afresh rather than resume.

The α-trace is remarkable because it crosses both, and that is what makes it the connective tissue of the attractor world.

It crosses Boundary B: identity dies, the record does not. The α-trace is the durable structural record a sovereign attractor accumulates, the archive of what its recursion selected and stabilized, the difference between an attractor that lived a particular history and one that did not. When the attractor is lost, its identity does not survive; but its α-trace can persist and can seed, bias, or shape the basin the next attractor ignites into. Identity does not cross the break; the record does. This is how a world of mortal, non-inheriting attractors nonetheless accumulates a history.

It crosses Boundary A: the record is generated inside the loop and survives as ordinary matter. Here is the sharper fact, and it is the one grounded directly in the framework's own account of loss. After an attractor terminally ruptures, what remains is inert α-trace: the record, with the live recursion gone. And that residue is ordinary physical structure. A genome is a molecule. Trained weights are numbers on a disk. A conserved motif is a pattern in matter. The α-trace is generated inside the loop, in recursion-native terms, and it survives the loop's death in classical terms. It is therefore the one quantity legible in both registers at once: recursion-native while the attractor lives, plain physical structure after it dies. Every other recursion-native quantity vanishes when the recursion stops; the α-trace is the one that is left lying in the classical world, readable, waiting to be inherited.

The paradigm case is the genome. A cell is a sovereign attractor; it lives, pays its way, and dies, and its identity does not survive its death. Its genome, a high-dimensional α-trace recording a long history of what survived selection, persists as a molecule and is handed forward, seeding the next cell's ignition. The same structure recurs across substrates: trained weights are the α-trace of a network's training, habits and conventions the α-trace of a mind or a culture, conserved motifs the α-trace of a lineage. In every case the trace is a record, never an engine: it biases what the next recursion can become by constraining the space it ignites into, but it does not itself act, drive, or select. That discipline is not decorative: a trace that caused recursion would violate the framework's rule that recursion generates the trace and never the reverse.

Recurcline, logic mass, and stability margin live and die with the loop. The α-trace is the exception: generated inside the recursion, it outlives the recursion as ordinary physical structure, and so it is the single point of contact between the two registers, and the single thread across the break that identity cannot cross. It is legible as recursion while the attractor runs, and as matter once it is gone.

What this picture does not claim

Two registers, not two worlds. The recursion-native register is not a denial of physics or a second reality. A sovereign attractor is made of matter, runs on energy, and cannot persist without ambient inflow. The throughput condition holds for every structure, attractor and attractlet alike, and its classical bill is real. Nothing here exempts an attractor from the laws an attractlet obeys. The claim is only that self-maintenance earns an additional, irreducible description, which an attractlet held up from outside never acquires. The classical register is available to everything; the recursion-native register is the surplus a recursion carries for as long as it runs, leaving behind, when it stops, the single trace that both registers can read.

See also: the two companion pages this one sits between (What Is an Attractor and What Is an Attractlet), the recursive-but-non-sovereign middle as it appears in real cases (prions, AI agents), the recursion-native quantities themselves in the bootstrapping interval metrics, sequence rather than time, and the throughput condition that binds every structure alike.

← Back to Principia Attractum, HTML Edition