The $\mathbf{Y}$-Combinator for LLMs: Solving Long-Context Rot with $λ$-Calculus

Abstract: LLMs are increasingly used as general-purpose reasoners, but long inputs remain bottlenecked by a fixed context window. Recursive LLMs (RLMs) address this by externalising the prompt and recursively solving subproblems. Yet existing RLMs depend on an open-ended read-eval-print loop (REPL) in which the model generates arbitrary control code, making execution difficult to verify, predict, and analyse. We introduce $λ$-RLM, a framework for long-context reasoning that replaces free-form recursive code generation with a typed functional runtime grounded in $λ$-calculus. It executes a compact library of pre-verified combinators and uses neural inference only on bounded leaf subproblems, turning recursive reasoning into a structured functional program with explicit control flow. We show that $λ$-RLM admits formal guarantees absent from standard RLMs, including termination, closed-form cost bounds, controlled accuracy scaling with recursion depth, and an optimal partition rule under a simple cost model. Empirically, across four long-context reasoning tasks and nine base models, $λ$-RLM outperforms standard RLM in 29 of 36 model-task comparisons, improves average accuracy by up to +21.9 points across model tiers, and reduces latency by up to 4.1x. These results show that typed symbolic control yields a more reliable and efficient foundation for long-context reasoning than open-ended recursive code generation. The complete implementation of $λ$-RLM, is open-sourced for the community at: https://github.com/lambda-calculus-LLM/lambda-RLM.

• The paper introduces Lambda-RLM, a novel framework using λ‑calculus to express fixed-point recursion, guaranteeing termination and bounded computational cost.
• It demonstrates significant improvements with up to +21.9 accuracy points and 4.1× faster latency across diverse long-context tasks.
• The approach decouples neural inference from symbolic orchestration, enabling robust, scalable, and strictly analyzable reasoning for complex applications.

Structured Functional Reasoning for Long-Context LLMs with Lambda Calculus

Motivation and Context

The inability of Transformer-based LLMs to reliably process long sequences remains a critical bottleneck for practical deployment in domains such as codebases, large documents, and evidence aggregation. Approaches like Recursive LLMs (RLMs) have introduced an inference-time decomposition paradigm, treating user prompts as environmental variables and recursively dividing them into manageable slices. However, standard RLMs depend on open-ended code generation within a REPL, delegating both semantic subproblem-solving and recursive control flow synthesis to the LLM. This architectural coupling leads to persistent issues such as unpredictable execution traces, non-termination, malformed intermediate outputs, and poor analyzability.

The paper "The $\mathbf{Y}$-Combinator for LLMs: Solving Long-Context Rot with $λ$-Calculus" (2603.20105) proposes $$(lambda-RLM), a paradigm shift for long-context reasoning. Instead of stochastic control, it introduces a typed, functional runtime grounded in$$\lambda$$-calculus, expressing recursion as a fixed-point combinator. Neural inference is strictly relegated to bounded leaf subproblems, and all orchestration occurs via a compact library of deterministic combinators. As a result, recursive reasoning becomes a formally analyzable functional program with guarantees on termination, complexity, and accuracy scaling. (Figure 1) *Figure 1:$$ demonstrates significant improvements in accuracy (up to $+21.9$ points) and latency reductions ($4.1\times$) compared to base and recursive LLMs.*

Formal Framework: Lambda Calculus Control Flow

At its core, $embodies the principles of$\lambda$$-calculus: - **Functional Abstractions**: Control flow is encoded using combinators such as$$Split$,$Map$,$Filter$,$Reduce$,$Concat$, and$Cross$. All but one ($M$$) are deterministic and pre-verified. - **Fixed-Point Recursion**: Recursion is expressed via the Y-combinator, eliminating the need for function naming and global state. The base model$$M$$serves only as a bounded oracle invoked at leaf subproblems. The main recursive algorithm, parameterized by partition size$$k^*$, threshold$\tau^*$, and task-specific composition$\oplus$, guarantees predictable depth ($d = \lceil \log_{k^*}(n/\tau^*) \rceil$). The control structure is decided by a planner pre-execution, yielding an explicit bound on the number of LLM calls and computational complexity. ## Theoretical Guarantees A differentiating trait of$ is its formal analyzability, contrasting starkly with agentic, open-ended control in standard RLMs:

• Termination: By construction, the recursion strictly decreases problem rank, guaranteeing halting for finite prompts.
• Cost Bound: The total number of model calls and computational workload follows a closed-form recurrence; e.g., $N(n) = (k^*)^{d} + 1$, with cost-minimizing partition size $k^* = 2$ under a token-based pricing model.
• Accuracy Scaling: End-to-end accuracy decays polynomially or remains constant in decomposable tasks, avoiding the exponential drop associated with direct inference on oversized contexts:

$$A_{\lambda-\mathrm{RLM}}(n) \geq A(\tau^*)^{nk^*/\tau^*} \cdot A_\oplus^{d}$$

• Optimal Partitioning: Closed-form solution to the split factor tradeoff is derived, ensuring that composition cost and leaf inference complexity are tightly controlled.

Empirical Results

Experiments across four long-context tasks (search, aggregation, pairwise reasoning, code QA) and nine LLM variants (Qwen3, Llama, Mistral—spanning weak, medium, strong tiers) validate the superiority of $: - **Accuracy Improvement**:$ wins in 81% of model-task configurations (29/36), with average gains up to $+21.9$ points in weak models and $+18.6$ in medium models.

• Latency Reduction: Consistent $3.3$-$4.1\times$ speedups, attributed to executing a single combinator chain over multiple turns of code synthesis in RLMs.
• Robustness: The gap widens with task structural complexity; for pairwise quadratic tasks, accuracy improves by $+28.6$ points with $6.2\times$ speedup.
• Strong Model Exception: In creative code QA tasks, strongly code-capable models can outperform the fixed combinator library, indicating space for further symbolic operator enrichment.

Practical Implications

$$demonstrates that formal control scaffolding can offset the "coding tax" on weaker models, enabling an 8B model to match or exceed a 70B model under standard recursive scaffolds—this supports the scale-substitution hypothesis. For practical deployment, deterministic compositional planning leads to strictly audited behavior, predictable resource requirements, and minimized variance. From the perspective of AI reliability and scaling,$$ provides a paradigm for separating neural language understanding from orchestration, reducing stochasticity in agentic tools, and mitigating failure modes such as non-termination and memory control flow attacks prevalent in open-ended agent frameworks. The results chart a new trajectory for robust long-context reasoning, especially relevant to domains where interpretability and computational predictability are non-negotiable.

Theoretical Implications and Future Directions

The marriage of $\lambda$-calculus and LLMs sets a new standard for neuro-symbolic reasoning: recursion and decomposition become first-class semantic objects, not emergent artifacts of code synthesis. Formal guarantees on termination, complexity, and scaling laws are realized without sacrificing practical performance. Given robust open-sourcing (github.com/lambda-calculus-LLM/lambda-RLM), further development may extend the combinator library for domain-specific tasks, optimize compositional operators for creative code navigation, and integrate richer symbolic planners.

In agentic AI, this work suggests a shift from unconstrained control freedom toward high-integrity, verifiable scaffolding, with the LLM relegated to bounded oracle, not omnipotent controller. Practical systems for long-context code analysis, scientific document parsing, and evidence aggregation will likely benefit from this modular abstraction, where neural inference and symbolic planning are strictly separated.

Conclusion

The $\mathbf{Y}$-Combinator for LLMs presents a rigorously formalized, empirically validated architecture for long-context reasoning, rooted in $\lambda$-calculus control flow and deterministically planned combinator composition. By strictly isolating neural inference from symbolic orchestration, the framework achieves substantial improvements in accuracy, latency, and auditability, setting the stage for the next wave of reliable, scalable intelligent systems. Future AI development can leverage formal functional runtimes as scaffolds, enabling robust generalization and practical deployment in structurally complex domains.