DAG Topology

Pipeline shape determines yield, expected work, and rework cost. Each pass through any of these topologies is its own DAG. The cyclicality of rework lives in the attempt counter, never in a single pass.

Companion to The Knowledge-Work Assembly Line. The partial-rework corollary is the operational payoff.

Start with a scenario

Accept rate (a)

80%

P(clear) on a fresh attempt

Parts (N)

independent sub-outputs the producer emits

Cross-part ρ

0.00

how much sibling parts fail together in one run

Sticky failure σ

0.00

how much a failure lowers rerun success

The two independence assumptions, and how to dial them off

At the defaults (ρ = 0, σ = 0) the math assumes cross-part independence (one part failing does not raise the failure rate of its siblings) and repeat-attempt independence (a part that just failed has the same accept rate on rerun as it did the first time). Both are optimistic.

ρ (cross-part correlation) models the first assumption. As ρ rises from 0 to 1, parts within one producer-run share fate more strongly. Full-rework benefits (clears bundle together too), so the dominance ratio shrinks toward 1. Partial-rework cost is invariant - the marginal failure rate per part does not change.

σ (sticky failure) models the second. A failed part is evidence of a hard input; its rerun accept rate becomes a × (1 - σ). Both costs rise with σ, but full-rework rises much faster because the joint all-clear probability shrinks as the N-th power of the sticky rate. Partial dominance grows with σ.

The two effects can cancel in real systems: bad inputs that affect multiple parts (high ρ) often also produce persistent failures (high σ). Try ρ = 0.4, σ = 0.3 for a realistic mid-case. The qualitative claim survives: partial dominates full at any σ < 1, ρ < 1. Equality only holds when the parts are not actually parts.

What each topology is doing

Serial composition

Each node feeds the next. The output of A is the input of B. The joint accept rate is the product of per-node accept rates. This is the assembly-line classic and the failure mode in most AI-pipeline POCs. See the dedicated yield-collapse widget for the long-form visceral version.

Parallel-AND composition

A source fans out to N independent producers, all of which must clear for the merge node to accept. Latency drops because the branches run in parallel. Yield does not improve over a serial chain of the same N nodes - the AND merge still requires every branch to clear, so the joint probability is still the product. The win is throughput, not correctness.

A variant, parallel-OR (any branch accepts), behaves the opposite way: yield is 1 - ∏(1 - p_i) and approaches 1 fast. That is the redundant-verifier pattern, useful when a false reject is cheap.

Verifier + Producer (full rework)

A producer P emits a candidate. A verifier V either accepts it (forwards to output) or rejects it (loops back to P for a full rerun). With unbounded reruns and accept rate a, the expected number of attempts is 1 / a, so the expected total work is 1 / a producer-runs. At 80% accept, that is 1.25 producer-runs in expectation. At 50%, it is 2.0.

Partial rework (the corollary)

If the producer emits N independent parts and the verifier can check each part independently, then only failed parts need to be rerun. Expected total work per pipeline pass becomes Σ (1 / a_i) * (cost_i / total_cost) instead of 1 / a^N. For any per-part accept rate below 100%, partial rework strictly dominates full rework, and the gap grows fast as either N or the failure rate grows.

The operational implication: design pipelines so the verifier can verify parts, not just the whole. Whenever you can break an output into independent slices that can be checked independently, do it. The expected rework cost falls multiplicatively. Wrong if: the parts are not actually independent, in which case fixing one part may break another and the partial-rework assumption fails.

DAG through every pass

None of these topologies are cyclic at the per-pass level. The rework loop is a cycle only over the meta-counter of attempts. Every individual pass through the pipeline is a DAG, which is why every standard DAG property (topological order, parallelism, associative composition) still holds. Cyclicality at the attempt-counter level is what makes the expected-work math tractable.