Partial-Level Ladders — Reconstruction From the Capability Test

Question: the corpus carries two partial-level ladder sets that use the same rung labels for different definitions. Which is right?

Answer: neither, and the question was malformed. Both are one-dimensional projections of a multi-dimensional space — both source notes say so in their own text — and the third artifact, data/domains/entity-system.v1.json, is a hybrid that carries one lineage's rung labels over the other lineage's scoring, plus scoring errors of its own. This note derives the ladders from a stated test instead of adjudicating between them.

Part 1 — What the evidence says about the three existing artifacts

1.1 Both source notes already say the ladder is a projection

This is not a new claim and it is not contested between the lineages. Lineage B's own source note, primitive-combinatorics.md:

"The partial levels defined above are one axis, but each primitive also has depth dimensions… The partial E levels (E0-E3) are really positions in this 3D space."

And the identity exploration reached the same conclusion from the other side: "A ladder that cannot hold a coherent position is a one-dimensional projection of a two-dimensional space."

So the ladders were never the object. The dimension sets are the object; a ladder is a route through them. Two teams picked different routes and then compared rung numbers. Nothing in either lineage is wrong about the space. What is missing from both is the projection rule — a stated answer to "why is this rung a rung?"

1.2 ⛔ The "source of record" carries A's labels over B's scoring

data/domains/entity-system.v1.json declares Lineage A's rung definitions. The 66 manifestations scored against it do not behave like Lineage A. Measured:

Cassandra, etcd, Kafka, Kubernetes and Datomic are not checksum systems. They are systems with assigned identifiers — partition keys, etcd keys, offsets, UIDs, entity IDs. That is Lineage B's I1 ("assigned identity (UUID)"), scored under Lineage A's label. And the rung that should be crowded under A's definition — cryptographic hash over a non-canonical encoding, which is most of the content-addressed world — holds exactly one system.

The inversion is the evidence. A 20-to-1 split in the wrong direction is not a scoring drift; it is a different definition in use.

The same pattern runs through the other primitives. gRPC, Postgres, Docker and HTTP all score P1, which is B's client/server and not A's peer identity: public key, content-addressed peer ID — gRPC has no peer ID. Postgres and gRPC score E3, which is B's external schemas (DDL, protobuf) and not A's self-describing types.

1.3 And the data carries scoring errors under either reading

1.4 ⛔ And one stated reason for declaring the JSON canonical is not true

The reconciliation proposal argued the JSON should be authoritative partly because "it already carries per-level provenance back to the analysis, so declaring the JSON authoritative does not orphan the prose."

Measured across 995 partial-level records in 26 domain files, the union of every key present is {description, emergent, level, name, phase_transition}. There is no provenance field anywhere. The JSON does not point back at the reasoning, which is precisely why nobody could see that its labels and its scores had come apart.

1.5 What does hold

One reason for the JSON survives, and it is the strongest of the three: it is machine-readable, so conformance can be checked rather than asserted. That argues for the format, not for the current contents.

Part 2 — The projection rule

A ladder is a chain in the partial order of implementations. For rung numbers to mean anything across systems, it must satisfy:

• C1 — cumulative. A system at rung N satisfies every rung below N.
• C2 — one story per rung. Each step adds one thing. A rung that advances two independent properties at once cannot place a system that has one and not the other.
• C3 — total on real systems. Every coherent real configuration lands somewhere. A configuration that is off-ladder falsifies the projection.
• C4 — the top is what the specification says. Full X is the entity system's X, read from the spec, not an extrapolation.
• C5 — discriminating. A rung no real system occupies is decoration.

And the rule that decides where a rung goes:

⭐ A rung exists if and only if crossing it unlocks a capability that cannot be expressed below it.

This is not invented for this note — it is what Paper 6's Phase Transitions and Thresholds section already does for the three transitions it names. Generalizing it is the whole reconstruction. It also makes the ladder derivable rather than asserted: given the dimension set, the rungs follow.

Part 3 — The six ladders, derived

Notation: A = a rung Lineage A had, B = Lineage B had it, A+B = both, new = neither, recovered by the capability test.

Entity (E) — 5 rungs

A's E1 ("untyped blob") duplicates E0; B's E1 ("hardcoded tags") is the real rung. A's E3 ("self-describing types") is B's Full E. The genuinely new rung is E3: a {type, data} envelope or a CBOR tag is intrinsic without the type being a retrievable entity, and that is a different capability from Full E.

Identity (I) — 4 rungs ⭐ and this is the one that matters

Three corrections fall out, and each was a defect in one lineage:

1. B's "assigned identity (UUID)" is not a rung above nothing — it is the same rung as location-addressing. A UUID is not a weak derivation; it is not a derivation. Putting it above I0 made B's ladder non-monotone, violating C1. Folding both mechanisms into I0 fixes it and keeps B's placement value, because the 20 real systems B was serving still land somewhere sensible.
2. A's I2 ("cryptographic hash, not over canonical encoding") buys no capability its I1 does not. Strength without canonicality gives you a better corruption detector, not structural identity. It fails C5 — and the data agrees: one system out of 66.
3. The rung both lineages lack is the important one. A content hash over a canonical encoding using a non-cryptographic function is derived, canonical, authority-free and forgeable. It was off-ladder in both. It is now I2, and it is where a single-machine entity core sits.

That last point is why this ladder is load-bearing beyond bookkeeping: the step from I2 to Full I is exactly adversary-resistance, and it is the step a local system does not have to take. Papers 4 and 5 are about that step. The old ladders could not express it.

Tree (T) — ⛔ not a chain, and this is a real structural finding

Applying the capability test to T produces two independent upper branches:

All four corners are populated — neither, binding-only, composition-only, both (the entity system, IPFS with IPLD + MFS) — which is the independence test passing. Lineage B's own note states the same thing without drawing the conclusion: "Plan 9 achieved dimension 1 and 3 but not 2. Git achieved 1 and 2 but namespace is fixed."

So a linear T ladder is structurally wrong, and that is why A and B diverge most on T: each called a different branch the top. A ranked composition (T3) and self-describing semantics; B ranked hash-binding. Neither is a mistake about the world; both are mis-projections of a branched order.

The data shows the collapse this causes: plan-9, linux-posix, nix and entity-system all score T4. A ladder that cannot separate POSIX from the entity system is not measuring anything.

Proposal: T is scored as a pair (T_bind, T_compose), or a linear ladder is kept with the projection rule stated — "ranks the binding branch; composition is scored separately". Do not pretend it is a chain.

Emit (M) — 6 rungs, and both lineages held a proper subset

A had no non-atomic rung; B had neither triggers nor cross-peer. Straight union.

Execution (X) — 7 rungs

B's X2 is a genuinely useful rung A lacks — it is the one that separates HTTP from RPC, and it is the most populated region of the real landscape. A's X4/X5 are real and B lacks them. Union again.

Peer (P) — 7 rungs, and here one lineage has a rung in the wrong place

⛔ A's P2 ("capability boundary: scoped access") is mislabeled and mis-ranked. Scoped access is "authorization exists," which every multi-user OS has had since the 1960s. The entity system's P is attenuatable capability tokens as content-addressed entities, and that is the top of the ladder, not the second rung. This is the ordering conflict levels.py reports, and it resolves in B's favour on this rung and A's favour on discovery and sync.

Part 4 — Consequences

4.1 Adversary-resistance is Identity's third dimension — verdict: yes

Tested for pairwise independence by populating the off-diagonal corners with real systems, which is the test that decides it:

All three vary independently with real occupants, so R is not a sub-level of U. The fold-it-in alternative fails immediately: verification universality is maxed by a CRC32 — anyone can verify it — while adversary-resistance is zero. Folding would make Full I incoherent.

Three further arguments, strongest last:

1. R accounts for the primitive's dominant cost. SHA-256 against a fast non-cryptographic mixer is essentially the whole per-item cost, the whole audited-dependency surface, and the whole hardware-acceleration argument.
2. R is the only one of the three the specification itself parameterizes. format_code selects the digest on the wire (0x00 SHA-256, 0x01 SHA-384). Derivation scope and verification universality are fixed by the protocol; the digest is a registry. A property the spec makes configurable is not a papers-layer invention.
3. ⭐ It is the definition of the top rung. In the reconstructed ladder, I2 → Full I is adversary-resistance. Without the dimension the ladder cannot distinguish a single-machine core from a distributed peer — the distinction Papers 4 and 5 exist to draw.

So: I has three internal dimensions, and the corpus total moves 19 → 20.

Cost of that change, measured: zero outside the papers. Named search finds no dimension concept in data/ or compute/ — the count is a Paper 6 construct. Paper 3 states no count and refers the analysis back to Paper 6. So the change is Paper 6 plus a cross-reference check, not a recomputation.

4.2 Is Identity therefore a compound primitive? No.

All three dimensions at zero is simply no identity, so none is independently removable in the sense Paper 0's remove-one test requires. One primitive, richer substructure.

4.3 Are the other primitives under-decomposed?

The reconstruction says T is, and structurally rather than by a missing axis: its two upper branches are independent, so its three stated dimensions are not a ranking. That is Paper 3's subject and it is now a specific claim rather than a worry.

4.4 What this does to the figure-vs-table defect

It narrows and relocates it. The figure and the tables are not cleanly "A versus B" — the figure is generated from scores that mostly mean B, carrying A's labels, with real errors on top. The caption clauses currently in Papers 0 and 6 remain correct and remain the right interim statement; the durable fix is the rescore, below.

Part 5 — What has to happen, in order

1. Land the Identity dimension (Paper 6 §Identity, 19 → 20; cross-check Papers 3, 11). Decided by §4.1, papers-only, no recomputation. Self-contained — can land alone.
2. Replace the ladder definitions in data/domains/entity-system.v1.json with Part 3, and add the missing provenance key pointing at this note.
3. Rescore the 66 manifestations against the new definitions. Mechanical but not trivial, and it is where the six known errors in §1.3 get fixed. The figure regenerates from it.
4. Update Paper 0 §Partial Primitives and Paper 6 §Internal Substructure to the Part 3 ladders, and drop the interim caption clauses once figure and tables agree.
5. Decide T's representation — paired score, or linear with the projection rule stated. Do not ship a T ladder that puts POSIX and the entity system on the same rung.
6. Re-baseline tools/corpus/levels.py once 2 and 4 agree; it should then pass on agreement rather than on a pinned divergence.

Steps 2–4 must land together: a rescore against old prose, or new prose against old scores, reproduces the defect in the other direction.