# A state that survives another hoist

10 October 2026 · Foray 120 · technical continuation of essay 13

[Open the continuation within essay 13](index.html#open-interface) · [Essay entrance](index.html) · [Complete small case](open-interface-case.json)

## Publication scope

This is supporting method documentation for the “Before resource wiring” view in the existing constructive-state essay, not a separate essay. The earlier standalone URL redirects there, preserving selected example and wiring. The model, independent verification and exported case are unchanged.

## Result and novelty boundary

An abstraction constructed for the one-hoist closed Rotunda system can merge curing states that another resource context distinguishes. That counterexample already belongs to the earlier essay. This experiment instead constructs each work-front abstraction **before resource closure**, checks its interface obligations, and uses those abstract components to generate the composed model.

For the small two-brick, two-course fixture, the fronts have 17 and 19 states. The adequate open refinements keep all 17 and 19. The closed one-hoist system has 219 states and its old quotient has 184 classes; two hoists have 323 reachable states. Generated shortest completion is 17 ticks with one hoist and 12 with two. For the original four-brick default, the open fronts retain all 79 and 81 states, whereas the closed one-hoist system compresses 3,883 states to 3,508 classes. Its completion times remain 34/22 ticks.

Thus the tested stronger replacement guarantee is achieved, but it yields no local state merging in these examples. The closed compression was partly purchased by relying on a resource restriction that masked distinctions. Full local state is a valid result here; this is not evidence that compact interfaces are impossible in other models. A symbolic or factored representation can be compact without merging behaviourally different states.

## Supplied model and exact context family

The unchanged `core.js` supplies labelled bricks, contiguous course growth, lower-course support, placement/curing rules and a shared tick. A front state is its placed masks, curing countdowns and active placement, including its target and remaining duration. The reference remains a supplied finite mechanism, not inference of dynamics from a picture.

The local graph starts at an empty front and permits every legal local command, including a wait tick. The component's readout is `(placed masks, busy, release-at-end, complete, command menu)`. It supplies the pool with an input menu and resource signals, not the hidden countdown itself. In Myers's dependent deterministic convention this gives `r:S→O` and `u:S×_O I→S`: an input is available in the fibre of the exposed output. A locally complete front retains a null/wait command so it can remain composed with an unfinished neighbour. The **global** complete-and-cured goal is terminal and has no command.

Contexts are fixed for an entire run:

1. one shared hoist, with both fronts accessible;
2. two hoists, with both accessible;
3. two hoists with access to B closed, as an impossibility control.

The pool accepts a pair of local commands only when existing reservations plus starts fit capacity. Reservations happen at tick start, local updates advance once, and releases happen at tick end. Released capacity cannot be spent earlier in that same tick. Closure of B restricts commands; it does not change its local work laws. There is no capacity switching during active work, unlimited context search or unspecified notion of “arbitrary rewiring”.

## Construction and preservation argument

Begin with the declared local readout partition. Split any class whose members have different command-labelled successor classes, keeping previous distinctions. Stop when stable. Finiteness ensures termination. The resulting `q` preserves readout, the exact input menu and each successor: `q(u(s,a)) = ū(q(s),a)`.

The new `compose` function generates a graph from the **abstract** local transition tables and their readouts. It does not call the concrete front update. The composed state contains the two abstract front classes and the pool's owner bits. A second route composes the concrete fronts through the old `core.js`.

The proof obligation is elementary and specific. Suppose the two concrete front states map to the two abstract states, with equal owners. Equal readouts imply equal local menus, release flags and local completion. The pool therefore accepts exactly the same joint command and calculates the same next owners. Local update commutation gives the corresponding next front classes. Hence the product projection commutes with every labelled step and preserves the global goal. Induction from the empty state preserves every finite labelled execution. This establishes replacement for these readout-driven resource wirings, conditional on the checked local obligations; it does not invoke a general theorem with unchecked hypotheses.

Reverse breadth-first search on the composed abstract graph selects a command reducing finite distance-to-goal by one. The same command is legal for every concrete representative and lowers its projected distance, so the policy lifts. This proves completion for that policy on the goal-reaching region, not for every legal choice: waiting forever remains possible.

With a fixed observation and command alphabet, the usual finite splitting argument identifies the coarsest stable refinement: any stable refinement must separate every pair split at each round. “Coarsest” here is relative to that particular partition order and semantics, not a universally smallest project state. A separately implemented pair-elimination calculation confirms the partition on the selected finite grids.

## Independent checks and controls

`tests/open-interface-oracle.cjs` uses separate flat brick occupancy, one curing timer per front and explicit target/duration slots. Its menu, tick and reference graph do not call the component update, composition or partition algorithm. It compares each local update and every composed concrete transition, and checks goal and abstract coverage. Its second algorithm begins with readout-equal state pairs and repeatedly removes pairs with incompatible successors; this independently checks the refinement relation.

The exact grid is two bricks, one/two courses, one/two placement ticks and curing pairs `(0,0)`, `(1,2)`, `(2,1)`, `(3,3)`, plus the small witness and original four-brick default: 18 checks, of which the small witness repeats a grid setting as a named regression. Across 54 contexts: 15,008 reachable-state checks, 33,236 transition checks, 17,908 local pair comparisons and 14,704 policy-lift checks. These totals include the deliberate repeated fixture; they are not counts of distinct configurations. The reference is exhaustive inside each selected configuration.

An A/B exchange, including their curing parameters, preserves the reachable state family. Closing B gives no full-completion route. A stronger negative control uses duration one and zero curing: a second hoist enables genuinely new joint starts, while the placed-brick summary already identifies every state. Its original summary remains adequate. Added freedom alone therefore does not force a refinement.

The small JSON export carries concrete states, local open graphs, readouts, original/extended context graphs and named partitions. Its old one-hoist partition is explicitly extended to the two-hoist domain by retaining old classes on shared states and assigning every newly reachable state a fresh singleton. This permits testing surviving old merges without pretending the original summary already covered a larger domain. The witness includes concrete histories. The open mapping and full mapping are included separately.

Reproduce with:

```sh
node tests/open-interface-oracle.cjs
node tests/open-interface-export.cjs --check
node tests/open-interface-browser.cjs http://127.0.0.1:8767/
```

## Sources, interpretation and limits

- David Jaz Myers, [*Double Categories of Open Dynamical Systems*](https://doi.org/10.4204/EPTCS.333.11), 2021, §§1–3: state/readout/update, dependent input bundles and plugging exposed variables into parameters.
- David Jaz Myers, [*Categorical Systems Theory*](https://www.davidjaz.com/Papers/DynamicalBook.pdf), draft 3 September 2023, §3.5: dependent deterministic systems and their input menus. The source supplies the formal vocabulary; our finite abstraction and resource example are additional constructions.
- David I. Spivak, [*Lenses: applications and generalizations*](https://dspivak.net/talks/pdfs/20190000-riverside2019.pdf), 2019: paired readout/update and agent/environment interaction. We use Myers's inputs-above-outputs convention consistently.
- Bob Coecke, Tobias Fritz and Robert W. Spekkens, [*A mathematical theory of resources*](https://doi.org/10.1016/j.ic.2016.02.008), 2016: context for declaring available resource operations. It is not a proof of the toy hoist rules.

The other fixed sources were reconsulted for framing and scope; no additional physical or categorical claim is imported from their titles or an AI-generated companion synthesis. Source-reading coverage is recorded privately. No private source copies or record identifiers are published.

This is neither a new abstraction-refinement theorem nor engineering validation. Physical laws, readout access, precise timers and resource authority are assumed. It leaves open whether the necessary distinctions can be observed economically, whether a weaker question allows useful compression, and whether a richer context family still satisfies the same interface assumptions. The continuous Rotunda essays are unchanged.
