Sibling independence
Sibling independence is when the subtasks that make up a bigger task have no dependencies on each other; none requires another's output, and they can be done in any order or at the same time. The bigger task still requires all of them done, but that requirement runs between each subtask and the whole, not between the subtasks themselves.
Definition
Sibling independence is the structural pattern where sibling sub-transitions on a critical route hold no dependencies on each other, with the parent-scale claim ratified by their collective output rather than by a sequenced chain.
Dependency runs child-to-parent
The parent transition depends on its sub-transitions — they produce the conditions its scope-translation requires. But that dependency doesn't have to run between siblings. Sub-transition B doesn't have to require anything from sub-transition A for the route to be well-formed; what matters is that A's output and B's output, together, ratify the parent-scale predicate.
This is easy to lose because sequence often looks like dependency. Three steps presented in order can read as a chain even when nothing structurally chains them. The check is whether one step requires a characteristic that another produces. If not, they're independent siblings, regardless of how they happen to appear in a list.
A critical route with independent siblings and a ratifiable parent-scale claim is fully well-formed. Inter-sibling dependency is a possible structural feature, not a required one.
Three sibling patterns
Sibling independence is one of three patterns sub-transitions can sit in on a critical route. Transformation chains sit at the opposite end: each step produces an intermediate state that some later step consumes as input, and skipping or reordering breaks the chain. Co-occurring conditions sit in between — siblings produce parallel characteristics whose conjunction ratifies the parent, sometimes with ordering or co-occurrence constraints the conditions themselves impose.
Independent siblings can run in any order without breaking downstream steps; chained siblings can't.
Example
Screenprinting a t-shirt with a three-color design involves three sub-transitions: printing the red layer, printing the blue layer, printing the yellow layer. Each requires only the blank shirt, none requires output from the others, and the press can run them in any order. The parent claim "shirt fully printed" depends on all three succeeding — any missing color leaves the design incomplete — but the dependency runs from each child up to the parent, not between siblings.