Parent: stages-and-gates
A stage = a free zone bounded by gates; its free zone can itself be a stage-gate sequence. The structure is self-similar (fractal).
We already have a 2-level instance — the interview: session stages (frame → prove → qualify → convert), and inside a stage the per-answer pipeline (read → retrieve → compose → guard) is its own stage-gate chain. Formally this is options-within-options (formalizations): a stage's intra-policy π can be a policy over sub-options. Simon–Ando: a block has internal fast dynamics before it couples out.
The rule that makes recursion work (not collapse)
Every level needs its own real gate. Recursion only pays if it converges at each level (recursion-convergence-contraction): a sub-stage's exit gate verifies its result before the parent builds on it. Skip a level's gate → that level's error compounds up the recursion (pⁿ, necessity) → the tower drifts. So recursive stages = a gate at every boundary.
Where it bottoms out (base case)
- Split a stage into sub-stages exactly where there's a verifiable "done" inside it; no verifiable sub-boundary → don't split (keep one free zone).
- Depth is bounded by gate cost (
√(2δM)logic): stop recursing when the sub-step is atomic / cheap enough that a gate isn't worth it. That's the base case.
What crosses levels (clean recursion)
- Simon–Ando: a passed sub-gate exposes only a summary/interface upward; the parent builds on the verified interface, not the child's internal mess.
- Hoare / LCF: a sub-stage's postcondition is a lemma the parent uses; tokens/mints nest (child gate mints evidence the parent gate consumes). Big proofs from nested, per-step kernel-checked tactics.
One line
Stages recurse, and should — but only as deep as you can put a real gate at each level. Gate-less recursion compounds error; gated recursion compounds capability. Bottom out where a step is atomic or has no verifiable internal "done."