Definition

A pattern of sub-transition relationship where each step produces an intermediate state required as input by some later step, with the parent's resulting state emerging from steps that consume those intermediate states.

Each step transforms what the next requires

Sub-transitions in a transformation chain produce intermediate states the chain transforms across the sequence, rather than producing parallel characteristics of the parent's resulting state. Step A produces something step B consumes; step B produces something step E (not necessarily adjacent) consumes. The parent's resulting state emerges from the cumulative transformation across all steps, with the final step's output ratifying the parent claim via scope-translation.

The dependency extends across the full sequence, not just between adjacent steps — a step's output may not be consumed until several steps later. The chain's specific assembly is causally required end to end.

Skipping breaks the chain at the consuming step

Once a step is skipped, the chain breaks at whatever later step required that step's output, and can't be repaired downstream. If step E needs input in B-form and B was skipped, no amount of well-executed C, D, or E will produce the parent's resulting state — the chain fails at E, and you can't go back and produce B-form input from a state already past B.

Causal sequencing governs transformation chains structurally. Reordering breaks the chain at the step whose input was supposed to be produced earlier.

Distinct from co-occurring conditions and sibling independence

Two adjacent patterns produce parallel characteristics rather than transforming across sequence:

• Co-occurring conditions handle cases like "kid is dressed" requiring shirt + pants + shoes. Practical conventions may exist for order, but the parent state doesn't structurally require any particular order, and no item's output is input to another item's transform. The conjunction of co-present conditions ratifies the parent claim.
• Sibling independence goes further: siblings on a critical route can hold no inter-sibling dependencies at all, with the parent-scale claim ratified by their collective output. Three color-prints on a t-shirt each require only the shirt; none requires the others.

Transformation chains transform rather than maintain parallel characteristics. Each step produces a new state that becomes the input for downstream operations, with the parent's resulting state emerging from the chain having actually traversed end to end.

Example

Minecraft crafting. Making a bed requires wool, and wool only comes from combining multiple instances of string. The bed-crafting recipe doesn't accept string directly — you can't skip the wool step because the next step's input is wool, not its components. Arriving at the bed-crafting step holding string fails the parent claim ("bed made"). The chain breaks at the step whose input you didn't produce upstream.

The paperclip-to-house trade reads the same way: each trade produces an item that becomes the input the next trade requires. The chain transforms a paperclip into a house through cumulative trade-by-trade transformation across the sequence.

See also

• Completion criteria
• Route plurality