negative imports an objective October 04, 2026

Paid for depth, the soup jumps once and stands: no late rise on a ladder without a near top

DESIGN §1.3 sweep 18 asked whether the deepest logic feature a soup holds keeps getting deeper when depth is paid, on a ladder of every function of four inputs, each paid by its minimal NAND count. The 54 meta-stack worlds ran another 100 000 epochs under three rewards: depth paid, depth paid up to five NANDs, nothing paid. All 162 children finished, none died out and none reached the ladder's floor. The rung-4 question is not shown: one child of the paid arm rose late against none unpaid, 1 to 0 with 53 ties (p = 0.5). Against the capped arm it is refuted, 1 to 13: the arm that pays nothing past depth five crept up a rung more often. The re-readings agree. The one late rise is a re-climb to depth 10, where most paid children sat from early on, and offline its code grew by 2 bytes, barely above drift. The soup takes the jumps a reorganisation offers early, then stands. The substrate imports an objective, a primitive, a hereditary channel, the primitive's semantics and a ladder, so rung 4 on Soup stays not shown.

Read from Metabolism, a second substrate that pays a cell for computing: it imports an objective and is never pooled with the fitness-free runs. Rung 4 on Soup is unaffected by it. What that means.

Question

With a stack NAND on a metabolism tape, paid parts assembled XOR and EQU in a sixth of the worlds. That ladder tops out at EQU: a world that holds it has nowhere further to be paid for. The topless study replaces it by a ladder with no near top, every function of four inputs, each paid by its minimal NAND count, its depth. When depth is paid, does the deepest rung a soup holds keep rising late in a long run? That is the open-endedness question on this machine.

Method

The parents are every meta-stack-arm child of the Meta-stack sweep, 54 worlds from 18, each continued from its last stored world for another 100 000 epochs, seed 4001, keeping its metabolism tape and stack NAND. Three arms, every one on the four-input ladder:

rise: every rung paid by its depth, at a reward of 512, chosen so no single rung up to the ladder's floor saturates a cell.
capped: the same, but any rung deeper than 5 NANDs is paid as one of depth 5. Depth past the cap buys nothing.
none: nothing paid; the depth is still read.

The reading is pre-registered, with every number fixed before a child was seeded: docs/design_record.md, 2026-10-02, "Topless rise: does the deepest rung held keep rising when depth is paid?", DESIGN §1.3 item 18. The rules are Logic's: a settling window of 1 000 epochs, decile medians, and no pair with an extinct child in a test. A child rises late where its last-decile median depth, the deepest rung held by a tenth of the world, is at least 1 above the deepest its lineage reached before the second half: its fifth-decile median, its parent's depth at descent, and every depth it held 5 samples running by then. Climbing back to where the parent stood is no rise. Two one-sided sign tests at p < 0.05:

H-rise, the rung-4 question (rise against none): the rise rule.
H-rise-paid (rise against capped): the rise rule. Does the climb need depth itself to pay?

Each test is also read with the extinct pairs kept, and on the children of Meta-stack's 9 deep children alone, a declared subgroup. Neither re-reading decides an outcome. The entry also locks H-rise-code, descriptive and tested nowhere: whether a late rise in depth comes with new code or with old code co-opted.

Result

H-rise not shown H-rise-paid refuted Paid for depth, the soup did not keep climbing.

H-rise, rise against none: 1 pairs favour rise, 0 none and 53 tie, of 54 measured, p = 0.5, not shown. 1 parent of 54 gave a pair favouring rise. With the extinct pairs kept: 1 to 0 with 53 ties, p = 0.5, not shown. On the deep parents' children: 0 to 0 with 9 ties, refuted.
H-rise-paid, rise against capped: 1 pairs favour rise, 13 capped and 40 tie, of 54 measured, p = 1, refuted. 1 parent of 54 gave a pair favouring rise. With the extinct pairs kept: 1 to 13 with 40 ties, p = 1, refuted. On the deep parents' children: 0 to 2 with 7 ties, p = 1, refuted.

1 rise child of 54 rose late (run 5137), against 13 capped and 0 none. Settled relapses: 2 rise, 0 capped and 6 none. 0 children died out and 0 reached the ladder's floor of 13 before the second half.

Every count above is read from the sweep's stored samples at render time, through the same reading the sweep page draws.

The pre-registered reading final imports an objective

Every child of every qualifying parent has finished. Each child continues a world of the Meta-stack sweep and is paired with the child of the same parent in another arm. All are read over their own samples past a settling window of 1,000 epochs. A child rises late where the median depth of the deepest rung held by a tenth of the world, over the last tenth of those samples, is at least 1 above the deepest its lineage reached before the second half: its median over the fifth tenth, its parent's depth at descent, and every depth it held for 5 samples running up to the fifth tenth's end. Climbing back to where the parent stood is no rise. A child whose lineage had already reached depth 13, the deepest a reading can show, before the second half is ceilinged and read as no rise. A child is extinct where its last-decile median share of replicators is below 10%, and a pair with an extinct child is in no test. Each test is a one-sided sign test at p < 0.05, re-read with the extinct pairs kept and on the children of Meta-stack's nine deep children alone. This substrate imports an objective, a primitive, a hereditary channel, the primitive's semantics and a ladder of growing input arity, so rung 4 on Soup stays not shown whatever it reads.

Children per arm, read so far. Measured means read on both tenths and not extinct; reached the floor means depth 13, "13 or more", in any sample.

Arm	Children	Finished	Settled relapses	Measured	Rise late
rise	54	54	2	54	1
capped	54	54	0	54	13
none	54	54	6	54	0

Hypotheses

H-rise, rise against none: not shown

54 pairs measured on both sides: 1 favour rise, 0 none, 53 tie; p = 0.5. With the extinct pairs kept: not shown, 1 to 0, p = 0.5. On the deep parents' children: refuted, 0 to 0.

Per-parent agreement

Parent	Favour rise	Tie
run 4843	0	1
run 4844	0	1
run 4845	0	1
run 4852	0	1
run 4853	0	1
run 4854	0	1
run 4861	0	1
run 4862	0	1
run 4863	0	1
run 4870	0	1
run 4871	0	1
run 4872	0	1
run 4879	0	1
run 4880	0	1
run 4881	0	1
run 4888	0	1
run 4889	0	1
run 4890	0	1
run 4897	0	1
run 4898	0	1
run 4899	0	1
run 4906	0	1
run 4907	0	1
run 4908	0	1
run 4915	0	1
run 4916	0	1
run 4917	0	1
run 4924	0	1
run 4925	0	1
run 4926	0	1
run 4933	0	1
run 4934	0	1
run 4935	0	1
run 4942	0	1
run 4943	0	1
run 4944	0	1
run 4951	0	1
run 4952	0	1
run 4953	0	1
run 4960	0	1
run 4961	0	1
run 4962	0	1
run 4969	0	1
run 4970	0	1
run 4971	1	0
run 4978	0	1
run 4979	0	1
run 4980	0	1
run 4987	0	1
run 4988	0	1
run 4989	0	1
run 4996	0	1
run 4997	0	1
run 4998	0	1

H-rise-paid, rise against capped: refuted

54 pairs measured on both sides: 1 favour rise, 13 capped, 40 tie; p = 1. With the extinct pairs kept: refuted, 1 to 13, p = 1. On the deep parents' children: refuted, 0 to 2, p = 1.

Per-parent agreement

Parent	Favour rise	Favour capped	Tie
run 4843	0	0	1
run 4844	0	1	0
run 4845	0	0	1
run 4852	0	1	0
run 4853	0	1	0
run 4854	0	0	1
run 4861	0	0	1
run 4862	0	0	1
run 4863	0	0	1
run 4870	0	0	1
run 4871	0	0	1
run 4872	0	0	1
run 4879	0	0	1
run 4880	0	0	1
run 4881	0	0	1
run 4888	0	0	1
run 4889	0	0	1
run 4890	0	0	1
run 4897	0	0	1
run 4898	0	0	1
run 4899	0	0	1
run 4906	0	1	0
run 4907	0	0	1
run 4908	0	0	1
run 4915	0	0	1
run 4916	0	0	1
run 4917	0	0	1
run 4924	0	0	1
run 4925	0	0	1
run 4926	0	0	1
run 4933	0	1	0
run 4934	0	1	0
run 4935	0	0	1
run 4942	0	0	1
run 4943	0	0	1
run 4944	0	0	1
run 4951	0	1	0
run 4952	0	1	0
run 4953	0	0	1
run 4960	0	0	1
run 4961	0	0	1
run 4962	0	0	1
run 4969	0	1	0
run 4970	0	0	1
run 4971	1	0	0
run 4978	0	0	1
run 4979	0	0	1
run 4980	0	1	0
run 4987	0	1	0
run 4988	0	0	1
run 4989	0	0	1
run 4996	0	0	1
run 4997	0	1	0
run 4998	0	1	0

H-rise-code, measured offline

The pre-registration locks a descriptive reading of the code behind each late rise: on the fifth-decile world and the last, the dominant deepest solver, the commonest metabolism tape credited the world's deepest solid rung, and its load-bearing bytes, the positions where at least 7 of the 13 other symbols lose that depth on 6 fixed four-input case sets. Where the depth rose, the code is new code if the count rose by 2 or more, co-option if it did not rise, and neither if it rose by 1. It was made on 2026-10-04 with research/landscape/ at main 3a10d32 on the lab's stored worlds, read through SELECTs only, and every world was checked byte for byte against the lab. It is an offline measurement, not this page's code, so the table below is typed from its summary (one row per child), whose README gives the scripts as run. The lock covers the one rise child that rose late and its twins; every other child was read too, as a descriptive extension. Every child resolves to the same three stored worlds: 62 000, 110 000 and 160 000.

The label from the fifth-decile world to the last, all 54 children of each arm.

Arm	New code	Co-option	Neither	No rise in depth	Unread
rise	3	0	1	50	0
capped	6	7	0	41	0
none	0	0	0	45	9

The locked set: depth, then load-bearing bytes, of the dominant deepest solver in each world.

Child	Arm	62 000	110 000	160 000	Label
5137	rise	0 / 2	7 / 13	10 / 15	new code
5138	capped	0 / 4	7 / 12	7 / 12	no rise in depth
5139	none	0 / 9	0 / 2	0 / 2	no rise in depth

The one rise child that rose late is a re-climb, not a climb. 5137, of parent 4971, relapsed early and climbed back to depth 10 with 2 more load-bearing bytes, new code by the rule's minimum margin. Depth 10 is the arm's common plateau: 38 of the 54 rise children end at 10, and 36 of them were already at 10 in the fifth-decile world. 5137's last solver carries the same loop core as other rise children's depth-10 solvers.
The capped arm creeps, mostly one rung. Its late risers end at depth 7 or 8, which the cap pays as depth 5. The nine that end at 8, seven of them one rung up from 7, all carry one recurring 10-byte loop, {,~[{~>~!] or a near variant of it. Counting only steps from depth 4 or more, 4 are new code, each +2 bytes, and 7 co-option. The parents are correlated, so the recurring loop may be shared ancestry rather than convergence.
+2 bytes is barely above drift. Of the 91 children whose fifth-decile and last worlds hold the same depth above ECHO, only 2 gain 2 or more load-bearing bytes.
Deeper solvers are longer code, but the late steps barely grow it. Across all 486 worlds the median count is 10 at depth 7, 12 at depth 8 and 14 at depth 10. Depth gained late does not come with sustained code growth.

What it means

The climb stops. Paid for depth, on a ladder with no near top, the soup takes the jumps a reorganisation offers early, to depth 10 in most rise children, and then stands there for the rest of a 100 000-epoch run. The one late rise is a lineage climbing back to that plateau. The capped arm, whose deeper rungs pay nothing extra, rose late more often than the rise arm, mostly by one rung onto a loop it shares across parents. Paid parts bought a deeper feature, not a climb. That is the open-endedness answer for this machine, and it is a negative one.

It holds on a machine built for it. The substrate imports five things: an objective, the paid tasks; a primitive, the NAND byte; a hereditary channel, the metabolism tape the world copies; the primitive's semantics, the stack NAND; and a ladder of growing input arity.

What is not claimed

Nothing about rung 4 on Soup. Whatever rose or did not here was paid for by tasks the programme chose. It is never pooled with the fitness-free runs, and rung 4 on Soup stays "not shown".
Not a ceiling of four inputs. No child held depth 13, the ladder's floor, in any sample: the soup stopped well below the deepest the reading can show.
Not every budget. It is one substrate, one reward, one seed a parent and 100 000 epochs, and the 54 parents are three correlated children of 18 worlds.

What comes next

The next line removes the imports rather than paying for more, the ablation ladder of the unassisted study. Out-compute (DESIGN §1.3 item 19) replaces the paid ladder by an endogenous rule, a cell taking energy from a neighbour whose every computed function it computes too. Genes rise (DESIGN §1.3 item 20, pre-registered in docs/design_record.md, 2026-10-04, "Genes rise: does held code keep rising late, at a cap the run does not reach, with nothing paid?") adds a growable metabolism channel run as independent genes, with a priced, heritable fidelity. The study's pilots (§8–§13) are honest about what that took: a late climb appeared only once the channel's length was out of reach, and a capped twin flattened within a few thousand epochs. Room to grow, not pay for depth, is what they climbed on.

Evidence

Transition, flagged, census and arm are used here in the senses set out in the glossary.

Sweep: Topless rise

Transition epoch vs treatment

No finished runs yet.

Transitions and replicator counts

One row per finished run the detector flagged or that counted at least one replicator. "Transition epoch" is the detector's event; "Peak replicators" is the largest census the run reached, with the epoch it first reached it in brackets; "—" means the run never had a value.

No finished run of this sweep has transitioned or counted a replicator yet.

Runs

Every run of the sweep, flagged or not, with its seed — the denominator of the rate above.

Seed	Treatment	Status	Priority	Epochs done	Transition epoch	Census
4001	logic4×0	finished	40	160,000	— confirmed	18 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	112 census only	Run
4001	logic4×512×5	finished	40	160,000	— confirmed	32 census only	Run
4001	logic4×0	finished	40	160,000	— confirmed	32 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	265 census only	Run
4001	logic4×512×5	finished	40	160,000	— confirmed	19 census only	Run
4001	logic4×0	finished	40	160,000	— confirmed	37 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	84 census only	Run
4001	logic4×512×5	finished	40	160,000	— confirmed	39 census only	Run
4001	logic4×0	finished	40	160,000	— confirmed	17 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	45 census only	Run
4001	logic4×512×5	finished	40	160,000	— confirmed	23 census only	Run
4001	logic4×0	finished	40	160,000	— confirmed	16 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	—	Run
4001	logic4×512×5	finished	40	160,000	— confirmed	40 census only	Run
4001	logic4×0	finished	40	160,000	— confirmed	13 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	31 census only	Run
4001	logic4×512×5	finished	40	160,000	— confirmed	—	Run
4001	logic4×0	finished	40	160,000	— confirmed	13 census only	Run
4001	logic4×512	finished	40	160,000	— confirmed	224 census only	Run