Scope translation
Scope translation is the move where smaller conditions, once they're all met, collectively make a bigger claim true. For grilling a steak, once "sear the top, sear the bottom, get the interior rare-ish" are present, then "steak grilled" holds. The bigger claim is shorthand that the smaller conditions earn together; it only holds when they do.
Definition
The mechanism by which a transition's child-scope conditions, when collectively satisfied, ratify a parent-scope predicate that acts as shorthand for those sub-conditions.
The IF/THEN form
Scope-translation has a specific gated structure:
IF {children's collective outputs satisfy specified conditions} THEN {parent-scale predicate holds}
The specified conditions in the IF clause are the transition's completion criteria. The parent's name is the predicate; the children's outputs ratify it. "Shirt fully printed" holds when each color-print has succeeded. "Steak grilled" holds when top is seared, bottom is seared, and interior is rare-ish.
What scope-translation enables
Movement up the stack. Without it, every larger-scope operation would have to drag along child-level conditions — any reasoning about "steak grilled" would re-evaluate top-seared, bottom-seared, and interior-rare each time the parent claim came up. With scope-translation, the conjunction compresses to a parent-scale predicate that operates at the parent's scope-level on its own terms. This is what lets the framework reason about parent-scale activities — value milestones, larger workflow transitions — without enumerating their internal causal structure at every reference.
Translation goes one way
The mechanism operates upward only. Child-scope conditions ratify a parent-scope predicate, but the parent-scope predicate doesn't decompose back to the same conditions automatically. Different children can equally ratify the same parent-scope claim — multiple routes can produce "shirt fully printed," each ratifying the same parent-scale predicate from different starting conditions, per route plurality at coarse-grain inclusion criteria. The asymmetry is what makes parent-scale claims usable as building blocks: they compress the underlying ratification without committing the framework to a specific decomposition on the way back down.
Fidelity governs the compression
The parent-scope predicate must compress the children's collective ratification accurately — claiming no more than children produce, no less than their collective output supports. Scope fidelity is the constraint.
Two failure modes at the parent-scale:
- Overreach: the parent name asserts characteristics the children don't collectively constitute. The compression claims more than the underlying material ratifies.
- Under-reach: the parent name drags child-scale detail upward instead of compressing to a parent-scale claim. "Steak with top seared, bottom seared, rare-ish interior" where "steak grilled" is the available compression.
The mechanism is structurally parallel to way-naming: way-naming compresses child-activities at parent-scale name-creation time; scope-translation compresses child-conditions at parent-scope predicate-firing time. Both are gated by fidelity.
Example
A value milestone like "sent first invoice" is a parent-scope predicate. Its scope-translation depends on child-scope conditions: invoice draft created with line items, recipient entered, send action fired. When children collectively satisfy those conditions, the parent predicate ratifies — "sent first invoice" holds.
Downstream apparatus then operates at the parent scope: multiplier analysis treats "sent first invoice" as a single behavioral signal, milestone tracking counts it as a single event, intent theorization references it as a parent-scale claim. The child-scope conditions don't come along for the ride — they did their work at the moment of ratification.