What a Self-Sustaining System Must Be Given

"Some systems keep themselves going," begins Self-Carried Closure. "A cell resynthesizes its enzymes with enzymes," it goes on, and a compiler compiles its own next version, and a maintenance team repairs its own tools. Such systems are often called self-sustaining, and the word suggests they need nothing but themselves. The paper's next sentence corrects that: "They do need something else: the first enzymes, the first compiler binary, the first set of tools."

That is the shape of the old puzzle of the chicken and the egg. The paper does not say which came first. It says, exactly, why a circle like this cannot start itself, what it must be given instead, and how long the gift has to last.

Every rule needs someone to run it

The paper builds a small model. It has capabilities, which are "anything the system can have or lack at a given moment: an operation, an interface, a repair routine, a clock service, a constructor", and rules that produce them. Its one unusual feature is that "every rule names the capability that executes it". A rule that builds a component needs its inputs and a builder, and the builder must itself be one of the system's capabilities, or come from an outside source named in advance. "Nothing is executed by an unnamed agent." In the compiler example, the rule that builds the next compiler is run by a compiler.

That gives two ways to read the same rules. Read as logic, a rule fires whenever its inputs are present: the inputs imply the output. Read as events, a rule fires only when its inputs and its executor are present.

The simplest example is a handshake. There are two capabilities, a and b. The rule that makes a needs no inputs, but b must run it. The rule that makes b needs no inputs, but a must run it. Read as logic, both rules need nothing, so both a and b follow from nothing at all. This is how, in the paper's words, a circle of rules can "look self-originating". Read as events, nothing happens. Neither rule can fire until its executor is already there.

The paper proves that this holds in every system of the model: if every rule needs its executor present, and nothing is supplied from outside, an empty start produces nothing, ever. Stated like that it sounds obvious, and the proof is short. The point is the contrast with the logical reading, where the same rules seem to produce everything from nothing. Give the handshake a starting capability, a seed, say b, and it builds a in one step.

The seed has to last

Real capabilities wear out, so the model gives each one a lifetime: once built, it is present for a set number of rounds unless it is rebuilt. Suppose there is no outside help and no limit on how many rules can fire in a round, and every rule that can fire does. The question is whether a and b can be kept going, in the paper's sense: present together at every round from some point on.

Let a last one round. If the seed b also lasts one round, the paper describes what happens: "at round 0 only b is present and it builds a; at round 1 only a is present, since b has expired, and it builds b; and so on." Each keeps rebuilding the other just after the other has gone, so the system ticks on but the pair is never whole. "The two are never present together, and no other choice of firings does better." The paper also checks the case where the system may choose which rules fire, or fire none: the two still never share a round.

If b lasts two rounds instead, both are present at round 1, each rebuilds the other, and the pair keeps going forever. The image at the top shows both cases.

The general version is a guarantee. Building everything the handshake's seed can lead to takes one round. Add one more, and a seed that lasts two rounds is enough. In general, with no limit on firings, a seed whose members each last as long as the build takes, plus one round, keeps going anything the seed can keep going at all. In the handshake, with a lasting one round, that is exactly what is needed: a seed one round shorter fails. But it is a guarantee, not a requirement. If a lasts two rounds instead of one, a seed b that lasts a single round already works. The exact least lifetime has no general formula yet; the paper lists it as an open problem, though for any particular system the question can be settled by computation.

The paper's own interpretation, which it marks as going beyond the theorems: "A self-sustaining system is therefore always a system that was given something." What is given can come from outside, too. The paper also treats systems fed by a steady outside supply, which can be sustained with no seed at all; what it calls self-carried is the stricter case where the seed is given once, at the start, and nothing afterwards.

Four ways to support yourself and still fail

A set of capabilities supports itself, in the paper's sense, if every member can be produced by a rule whose inputs lie in the set. That sounds like enough to keep it going. The paper gives four ways it is not, which it calls independent because each lacks a different ingredient:

• No executor. Two capabilities build each other, but both rules are run by a third that nothing produces. Started from one of the two, the system never produces the other.
• No start. The set supports itself, but the system begins with nothing, so nothing is ever present.
• A seed that expires too early. The handshake with every lifetime one round: the two alternate and are never present together.
• Too little capacity. This one needs a closer look.

When only one thing can be done at a time

Now limit how many rules fire per round. Take three capabilities that each rebuild themselves, lasting 2, 3 and M rounds, all present at the start, with one rebuild allowed per round. Can all three be kept going?

Never, for any M. The paper's argument fits in three rounds. Some round t must rebuild the third capability. The first lasts only two rounds, so it needs a rebuild in every pair of neighboring rounds; round t is taken, so it must be rebuilt at t − 1 and again at t + 1. That uses up all three rounds from t − 1 to t + 1, and the second capability, which lasts three rounds, needs a rebuild somewhere in every three. There is no room.

What makes this surprising is the arithmetic. Each capability needs a share of the rounds equal to one over its lifetime, and the total, 1/2 + 1/3 + 1/M, is the load on the system, which the paper calls its density. With one rebuild per round, a load above 1 is plainly impossible, and the paper proves that a load no greater than the number of rebuilds per round is necessary. But it is not enough. Once M is 7 or more, the load is below 1, and the three still cannot be kept.

When every capability simply rebuilds itself and one rebuild is allowed per round, the paper shows that the question is exactly a known scheduling problem, pinwheel scheduling: serve one task per day so that each task is served at least once in every stretch of days as long as its lifetime. A theorem by Akitoshi Kawamura, published in 2024 and cited in the paper, says that a load of at most 5/6 can always be scheduled. The family with lifetimes 2, 3 and M shows that no higher threshold works. The paper does not reprove Kawamura's theorem; it is the one step in this part that it cites instead of checking.

Four kinds of nothing

Arguments about origins, the paper notes, "often move between different kinds of nothing: no capabilities at all, no seed, a single undifferentiated point, no evidence." The model keeps them apart. A system can have no capabilities at all. It can have some, but start with none of them. It can have exactly one, a single point with nothing to tell apart. And it can have no evidence: the paper also keeps audit records, in which one capability is permitted to audit another and the audit is accepted when a declared test passes, and a system has no evidence while no audit has been accepted. The act of auditing itself is not modeled. "None of these is a presentation of absolute nothing."

Of the twelve possible implications between pairs of them, exactly two hold in every case: a system with no capabilities has nothing to start from, and no accepted audits. Each of the other ten fails in an explicit example. One more holds under an extra condition. If every auditor must rank above what it audits, a system with a single capability can never have evidence, since nothing can audit itself.

The paper also takes apart a familiar step in arguments about origins: if the empty state is unstable, something stable must exist. The paper gives a one-line counterexample showing that this does not follow as a matter of logic. And in the model the premise is false anyway: read as events, the empty state is perfectly stable, because the rules produce nothing from it. "Nothing is a fixed point of generation, not a source of it." A fixed point is a state the rules leave unchanged. Read as logic, the empty state is a fixed point only when no rule is free of inputs, which is how the handshake looked self-starting on paper.

Another paper in the series, Lawful Theory Interaction, proves a one-event version of the same point in a different setting: an event that needs a capability that only it produces, and that is not available at the start, can never happen.

What it does not say

The model is finite and declared: its capabilities, rules, lifetimes, capacity and outside sources are all given in advance, and self-sufficiency is relative to them. Rules read their inputs without using them up, so nothing in the model runs out of material. And despite the cells in its first sentence, "The paper models no organism or chemistry." It makes no claim about living systems.

Every numbered result is checked in Lean, a proof assistant, with two exceptions the paper names: the step that uses Kawamura's theorem, and the result that deciding in general whether a target can be kept going is computationally hard, which has a written proof only. What the model settles is the narrow, exact core of the chicken and the egg. Once something must be present to run each step, a system that keeps itself going was given something to start it, and how long that something lasts is part of the answer.

Drawn from Six Birds Verified XI: Self-Carried Closure (Tsiokos, 2026, doi:10.5281/zenodo.23097936), with Six Birds Foundations VII: Lawful Theory Interaction (Tsiokos, 2026, version 2, doi:10.5281/zenodo.23187549) for the one-event case. The 5/6 threshold is A. Kawamura, "Proof of the density threshold conjecture for pinwheel scheduling", STOC 2024, as cited there. The chicken and egg framing and the compiler reading of the rules are mine. No new computation is claimed by this essay.