Sub-transition
A sub-transition is a smaller activity nested inside a larger one, producing an intermediate state the larger activity passes through on its way to completion. For example, cooking one side of a pancake is a sub-transition of the larger activity of making breakfast. Each sub-transition has its own start and end and is a complete activity on its own terms, while also being a piece of the larger activity that contains it.
Definition
The activity inside a parent transition that produces sub-conditions — itself a transition, nested within another transition.
Nested transitions
A sub-transition is a transition that happens inside another transition. The parent transition has a starting state, a resulting state, and completion criteria; a sub-transition inside it has the same — its own starting state, its own resulting state, its own completion criteria. The framework treats sub-transitions with the same primitives as any other transition, with the added property that they occur in the context of a parent.
"User reaches first useful output" is a transition. Inside it, "user connects their data source" is a sub-transition — starting state (no data connected), resulting state (data connected), completion criteria of its own. "User becomes a paying customer" is a transition; "user reaches first useful output" is a sub-transition inside it. Same primitive, different scope-level.
Producing sub-conditions
Sub-transitions are paired with sub-conditions, but they're structurally distinct. Sub-conditions are the intermediate states the parent transition requires between starting conditions and completion criteria. Sub-transitions are the activities that bring those states about. The pairing is causal: each sub-transition exists to produce a specific sub-condition.
Causal sequencing and sibling independence are relations between sub-conditions, not sub-transitions. Whether sub-transition B has to follow sub-transition A depends on whether B requires a sub-condition A produces — the dependency lives at the condition layer. Sub-transitions inherit their ordering constraints from the conditions they produce.
Recursion through nesting
A sub-transition can have its own sub-transitions, because a sub-transition is itself a transition. "User becomes a paying customer" contains "user reaches first useful output" as a sub-transition; that sub-transition contains "user connects their data source" as a sub-transition; that contains "user authenticates with the source system" as a sub-transition. The nesting goes as deep as the analysis requires. Scope-translation is what enables movement back up the stack — each transition's sub-transitions collectively ratify the predicate the transition's name compresses.
Example
In a signup-to-paid offering, "user becomes a paying customer" is the parent transition. Its sub-transitions include account-creation, completing setup, reaching first useful output, and committing to a paid plan. Each is itself a transition with its own starting state and completion criteria, and each produces a sub-condition the parent transition requires. Some sub-transitions depend on others (reaching first useful output requires the account-exists sub-condition that account-creation produces); others may be independent siblings (whether the user invites a teammate and whether the user imports their data can run in parallel, depending on the product).