Stopping and admission under fixed tasks and budgets [ftip-00F0]
✍️source

    Definition 1. Recursive run record [ftip-00F1]

      A recursive run record is \(R=(\mathcal T,\Omega ,S_1,\mathcal A_D,\sigma )\), where \(\sigma \) lists depth, seed, evaluator version, emitted code hashes, scores, and resource costs. A record is replayable only relative to these declared inputs and versions.

      Definition 2. Convergence stopping rule [ftip-00F2]

        Fix tolerance \(\epsilon >0\), score range \(R>0\), patience \(P\geq 1\), and maximum depth \(D\). A linear recursive run stops when no emitted layer improves the mean score by more than \(\epsilon R\) for \(P\) consecutive layers, or when the driver emits empty code, or when depth \(D\) is reached.

        Lemma 3. Finite stopping bound [ftip-00F3]

          Under the rule in Definition 2, a run that reaches its depth cap emits at most \(D-1\) wrapped layers. If it stops earlier, it emits no more than this many. This bound is combinatorial and does not imply convergence of scores.

          Theorem 4. Budget-preserving layer admission [ftip-00F4]

            Let a candidate layer cost \(c\geq 0\), remaining budget be \(b\geq 0\), and admission require \(c\leq b\). After admission, set \(b'=b-c\); then \(b'\geq 0\) and the total admitted cost is at most the initial budget.

            Proof. Subtracting a nonnegative cost no larger than \(b\) preserves nonnegativity; induction over admissions gives the total bound.

            Example 5. Rollback preserves the base solver [ftip-00F5]

              If a later layer is rejected by its admission or evaluation gate, removing that layer returns to \(S_{d-1}\). This is a harness rollback, not a reversal of weight training and not evidence that the rejected layer was unsafe.

              Remark 6. What the recursive source reports [ftip-00F6]

                The source reports two backbones, eight benchmark families, convergence stopping, and archive ablations in Sections 3.1--3.4 of [kim2026metanrecursive]; its fixed-driver, conditioning, stopping, and archive setup is described in Sections 2.2--2.4. These are empirical comparisons under its task, model, and budget choices; they are not universal depth, stability, or capability theorems.

                Remark 7. Recursive harnesses with fixed evaluators and versions [ftip-00F7]

                  The finite statements assume a fixed task set, evaluator, versions, and declared budget. They do not transfer to weight learning, RLVR optimization, unbounded self-modification, or capability acquisition without new hypotheses.

                  Example 8. Whole-chain maximum and per-task oracle [ftip-00F8]

                    Consider two equally weighted tasks and an archive containing two chains \(a,b\), with score vectors \((s_1(a),s_2(a))=(1,0)\) and \((s_1(b),s_2(b))=(0,1)\) under the same evaluation law. The archive envelope is

                    \[J(a)=J(b)=J_D^{\max }=\frac 12.\]

                    Either chain attains this maximum. In contrast, a per-task oracle has value

                    \[\frac 12\sum _{i=1}^2\max _{c\in \{a,b\}}s_i(c)=1.\]

                    The oracle selects \(a\) on the first task and \(b\) on the second. A configuration constrained to select one archived chain before observing task identity obtains mean \(1/2\) in this example. If task-dependent routing is permitted, the resulting combined policy must itself be declared and evaluated, including its routing and execution costs. The oracle value is not automatically the score of either archived chain.

                    Incompatible execution configurations create a separate obstacle: an archived maximizing chain may be ineligible for a named target configuration. That feasibility restriction does not alter the distinction between the two score functionals above.

                    References

                      Reference. Meta-n: Recursive Self-Improvement through Emergent Depth [kim2026metanrecursive]

                      @article{kim2026metanrecursive,
  title = {Meta-n: Recursive Self-Improvement through Emergent Depth},
  author = {Kim, Zae Myung and Lee, Young-Jun and Jwa, Seungyeon and Kang, Dongyeop},
  year = {2026},
  url = {https://arxiv.org/abs/2608.24735v1},
  journal = {arXiv preprint arXiv:2608.24735}
}

                      Context

                        Recursive harnesses and archive envelopes [ftip-00EH]

                          Recursive harnesses can be modeled as fixed-driver transformations of traces, code, and task descriptions. Sections 2.2--2.4 of [kim2026metanrecursive] supply the fixed meta-operation, conditioning, stopping, and archive context; Sections 3.1--3.4 are empirical architecture comparisons. The finite consequences below are proved locally.

                          Fixed drivers and recursive layers [ftip-00EI]

                            A fixed meta-operation generates mutable layer artifacts. Their composition determines the resulting recursive wrapper.

                            Definition. Recursive layer state [ftip-00EJ]

                              Let \(S_1\) be a base solver and, for \(d\geq 2\), let \(C_d\) be a layer artifact and \(M_d\) a wrapper. The depth-\(d\) solver is \(S_d=M_d(C_d,S_{d-1})\). The layer state is \(\Lambda _d=(C_d,S_d)\).

                              A layer is a harness transformation when it changes \(C_d\) or the wrapper context while leaving the executable base weights in \(S_1\) fixed.

                              Definition. Fixed meta-operation [ftip-00EK]

                                A fixed meta-operation is a single map \(\Omega \) whose code and prompt template are held fixed across depths. For task set \(\mathcal T\), traces \(\boldsymbol \tau _{d-1}\), code stack \([C_2,\ldots ,C_{d-1}]\), and depth \(d\),

                                \[\Omega (\boldsymbol \tau _{d-1},[C_2,\ldots ,C_{d-1}],\mathcal T,d)=C_d.\]

                                Only the input to \(\Omega \) changes with depth; this is a declared protocol condition, not a claim that every implementation obeys it.

                                Definition. Trace-and-code input [ftip-00EL]

                                  For each task \(t_i\), a trace \(\tau _i^{(d)}\) is a finite record containing the produced artifact, execution outcome, score, and declared evaluator feedback. The depth-\(d\) input to \(\Omega \) is the pair \((\boldsymbol \tau _{d-1},[C_2,\ldots ,C_{d-1}])\); a flat refiner that sees only \(\boldsymbol \tau \) has a strictly smaller declared input when the code stack is not recoverable from the traces.

                                  Theorem. Nested wrapper composition [ftip-00EM]

                                    If every wrapper leaves its inner solver and earlier libraries unchanged, then induction on \(d\) gives

                                    \[S_d=M_d\circ M_{d-1}\circ \cdots \circ M_2\circ S_1.\]

                                    Proof. The case \(d=2\) is the definition. Substituting the induction hypothesis into \(S_d=M_d(C_d,S_{d-1})\) gives the displayed composition.

                                    Theorem. Finite trace growth under recursive wrapping [ftip-00EN]

                                      Suppose each wrapper emits one finite trace record per task and there are \(N\) tasks and depths \(2,\ldots ,d\). The audit log contains at most \(N(d-1)\) depth-tagged records, in addition to the base records. This is a counting fact; it says nothing about trace quality or score improvement.

                                      Proof. There are \(d-1\) wrapped depths and \(N\) records at each depth, so the product counts all records.

                                      Example. Code explains a regression that traces alone cannot [ftip-00EO]

                                        Two runs can share the same failing score and stderr trace while one layer adds an over-prescriptive directive and another adds a helper. Recording the code artifact alongside the trace permits a later layer to roll back the directive without discarding the helper. This is an audit example, not a guarantee that a recursive driver finds the rollback.

                                        Archives and stopping rules [ftip-00EP]

                                          A finite archive can contain several candidate chains, while execution uses a single selected chain. A stopping rule determines when recursive generation ends.

                                          Definition. Finite recursive archive [ftip-00EQ]

                                            An archive at depth bound \(D\) is a finite set \(\mathcal A_D\) of recorded chains. Each chain has the form

                                            \[a=(C_2,\ldots ,C_{d_a}),\qquad 1\leq d_a\leq D.\]

                                            Each chain stores its evaluation record and resource cost. Archive membership is a protocol state, not a learned weight update.

                                            Definition. Archive score envelope [ftip-00ER]

                                              Let \(\mathcal T=\{t_1,\ldots ,t_N\}\) be a finite task set with \(N=|\mathcal T|\geq 1\). For every chain \(a\) in the finite archive, let \(s_i(a)\in \mathbb R\) be its score on task \(t_i\) under a declared common evaluation law. Define its whole-chain mean by

                                              \[J(a)=N^{-1}\sum _{i=1}^N s_i(a).\]

                                              For a nonempty archive \(\mathcal A_D\), its archive envelope is

                                              \[J_D^{\max }=\max _{a\in \mathcal A_D}J(a).\]

                                              The finite real-valued maximum is attained by at least one archived chain. It scores a single chain across all tasks; it does not select a different chain for each task.

                                              Deployment eligibility is a separate condition. A target configuration specifies which recorded chains can execute with their stated behavior and resource requirements. Maximizing over that eligible subset gives a deployable archive choice when the subset is nonempty; if it is empty, there is no eligible archived choice. Applying the recorded score to deployment additionally requires the same evaluation law. Records from different configurations alone do not establish these conditions.

                                              Lemma. Archive envelope dominates its incumbent [ftip-00ES]

                                                If \(a_0\in \mathcal A_D\), then \(J_D^{\max }\geq J(a_0)\).

                                                Proof. The maximum of a finite nonempty set is at least each member, in particular \(a_0\). No claim about an unseen task follows.

                                                Theorem. Finite archive selection bound [ftip-00ET]

                                                  Under the archive score definition, let \(a^\star \) maximize \(J\) over a finite nonempty archive \(\mathcal A_D\). Let \(\delta \in \mathbb R\) with \(\delta \geq 0\), and let \(\hat a\in \mathcal A_D\) satisfy \(J(\hat a)\geq J(a^\star )-\delta \). Then

                                                  \[0\leq J(a^\star )-J(\hat a)\leq \delta .\]

                                                  Proof. 

                                                    Membership of \(\hat a\) in the same archive gives \(J(\hat a)\leq J(a^\star )\) by maximality. Rearranging the approximation inequality gives the upper bound.

                                                    This is a finite selection statement under the same evaluation law; it is not an optimizer-convergence or generalization theorem.

                                                    Conditioning, interference, and finite protocol records [ftip-00EU]

                                                      Conditional strategy and tactic composition can produce interference. Auditing a recursive run requires its task, conditioning, execution, and cost records.

                                                      Definition. Strategy and tactic configuration [ftip-00EV]

                                                        At depth \(d\), let \(\mathcal K_d\) be a finite set of tactic behaviors and let a strategy select a conditional tactic in \(\mathcal K_d\). A realized configuration is \((k_2,\ldots ,k_n)\). The notation records expressible choices, not the number of choices an implementation actually discovers.

                                                        Lemma. Conditional configuration upper bound [ftip-00EW]

                                                          If layer \(d\) has \(k_d\) possible tactics and all combinations are allowed, the number of configurations is at most \(\prod _{d=2}^n k_d\). An unconditioned flat choice with the same layerwise menus has at most \(\sum _{d=2}^n k_d\) listed choices.

                                                          Proof. The first count is the cardinality of a Cartesian product; the second is the cardinality of a disjoint menu union. These are upper bounds only.

                                                          Example. Product versus sum is not a measured gain [ftip-00EX]

                                                            With three menus of size three, the product bound is \(27\) and the sum bound is \(9\). A protocol that never emits most combinations can realize far fewer than \(27\); the arithmetic does not establish a benchmark improvement.

                                                            Example. Layer interference and rollback [ftip-00EY]

                                                              Let a helper improve one task while a later directive lowers its score. The archive can retain the earlier helper chain and a later layer can remove the directive. The example separates a compositional possibility from a proof that any driver detects or repairs interference.

                                                              Remark. Recursion is not a quality guarantee [ftip-00EZ]

                                                                The product bound, richer trace input, and archive envelope can all hold while scores regress, overfit, or depend on the evaluator. The source reports empirical ablations and layer roles in Sections 3.1--3.4; those observations do not become FTIP theorems or capability claims here.

                                                                Stopping and admission under fixed tasks and budgets [ftip-00F0]
                                                                ✍️source

                                                                  Definition. Recursive run record [ftip-00F1]

                                                                    A recursive run record is \(R=(\mathcal T,\Omega ,S_1,\mathcal A_D,\sigma )\), where \(\sigma \) lists depth, seed, evaluator version, emitted code hashes, scores, and resource costs. A record is replayable only relative to these declared inputs and versions.

                                                                    Definition. Convergence stopping rule [ftip-00F2]

                                                                      Fix tolerance \(\epsilon >0\), score range \(R>0\), patience \(P\geq 1\), and maximum depth \(D\). A linear recursive run stops when no emitted layer improves the mean score by more than \(\epsilon R\) for \(P\) consecutive layers, or when the driver emits empty code, or when depth \(D\) is reached.

                                                                      Lemma. Finite stopping bound [ftip-00F3]

                                                                        Under the rule in Definition [ftip-00F2], a run that reaches its depth cap emits at most \(D-1\) wrapped layers. If it stops earlier, it emits no more than this many. This bound is combinatorial and does not imply convergence of scores.

                                                                        Theorem. Budget-preserving layer admission [ftip-00F4]

                                                                          Let a candidate layer cost \(c\geq 0\), remaining budget be \(b\geq 0\), and admission require \(c\leq b\). After admission, set \(b'=b-c\); then \(b'\geq 0\) and the total admitted cost is at most the initial budget.

                                                                          Proof. Subtracting a nonnegative cost no larger than \(b\) preserves nonnegativity; induction over admissions gives the total bound.

                                                                          Example. Rollback preserves the base solver [ftip-00F5]

                                                                            If a later layer is rejected by its admission or evaluation gate, removing that layer returns to \(S_{d-1}\). This is a harness rollback, not a reversal of weight training and not evidence that the rejected layer was unsafe.

                                                                            Remark. What the recursive source reports [ftip-00F6]

                                                                              The source reports two backbones, eight benchmark families, convergence stopping, and archive ablations in Sections 3.1--3.4 of [kim2026metanrecursive]; its fixed-driver, conditioning, stopping, and archive setup is described in Sections 2.2--2.4. These are empirical comparisons under its task, model, and budget choices; they are not universal depth, stability, or capability theorems.

                                                                              Remark. Recursive harnesses with fixed evaluators and versions [ftip-00F7]

                                                                                The finite statements assume a fixed task set, evaluator, versions, and declared budget. They do not transfer to weight learning, RLVR optimization, unbounded self-modification, or capability acquisition without new hypotheses.

                                                                                Example. Whole-chain maximum and per-task oracle [ftip-00F8]

                                                                                  Consider two equally weighted tasks and an archive containing two chains \(a,b\), with score vectors \((s_1(a),s_2(a))=(1,0)\) and \((s_1(b),s_2(b))=(0,1)\) under the same evaluation law. The archive envelope is

                                                                                  \[J(a)=J(b)=J_D^{\max }=\frac 12.\]

                                                                                  Either chain attains this maximum. In contrast, a per-task oracle has value

                                                                                  \[\frac 12\sum _{i=1}^2\max _{c\in \{a,b\}}s_i(c)=1.\]

                                                                                  The oracle selects \(a\) on the first task and \(b\) on the second. A configuration constrained to select one archived chain before observing task identity obtains mean \(1/2\) in this example. If task-dependent routing is permitted, the resulting combined policy must itself be declared and evaluated, including its routing and execution costs. The oracle value is not automatically the score of either archived chain.

                                                                                  Incompatible execution configurations create a separate obstacle: an archived maximizing chain may be ineligible for a named target configuration. That feasibility restriction does not alter the distinction between the two score functionals above.