← Latest papers
💻 computer science

How to play the Accordion: Uniformity and the (non-)conservativity of the linear approximation of the λ-calculus (extended version)

This paper investigates the conservativity of the linear approximation of the λ\lambda-calculus via Taylor expansion, demonstrating that while the property holds for finite terms, it fails for infinitary reductions due to a counter-example called the "Accordion," which is resolved by imposing a uniformity constraint that yields a conservative extension also applicable to β\beta\bot-reductions.

Original authors: Rémy Cerda, Lionel Vaux Auclair

Published 2026-07-21
📖 4 min read☕ Coffee break read

Original authors: Rémy Cerda, Lionel Vaux Auclair

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to understand how a complex machine works, like a giant, self-assembling robot. In the world of computer science, specifically in a field called lambda calculus, these "machines" are actually mathematical expressions that represent computer programs. For decades, scientists have tried to predict what these programs will do by breaking them down into smaller, simpler pieces. One of the most powerful tools for doing this is called linear approximation. Think of it like taking a high-resolution photograph of a complex scene and breaking it down into a grid of tiny, simple pixels. If you understand how the pixels behave, you can understand the whole picture. This method, which uses ideas from calculus (like derivatives) to analyze code, has been a huge success. It allows researchers to prove that if you simplify a program enough, you can predict its final result.

However, there is a tricky question that has lingered for twenty years: Is this simplification process perfectly reversible? In other words, if you take a simplified "pixel" version of a program and watch it change, does every single change it makes correspond to a real, valid change in the original, complex program? For simple, finite programs, the answer is a confident "yes." But for programs that run forever or involve infinite loops, the rules get fuzzy. This paper asks: If we let our simplified models run wild with infinite steps, do they start doing things that the original program could never actually do? The authors set out to find the answer, and in doing so, they discovered a surprising glitch in the system.

The paper, titled "How to Play the Accordion," dives deep into this problem by testing the limits of linear approximation. The researchers first confirm that for standard, finite programs, the approximation is safe and reliable; every move the simplified model makes is a legitimate move the original program could make. But the story changes dramatically when they look at infinitary programs—those that involve infinite sequences of steps. Here, they prove that the approximation is not conservative. This means the simplified model can perform "magic tricks" that the real program cannot.

To demonstrate this, the authors design a specific, mind-bending counter-example they call the Accordion. Imagine a program that stretches and compresses itself in a rhythmic pattern, like an accordion being played. The authors show that while the simplified "pixel" version of this Accordion can be reduced to a specific final state through a series of steps, the original, infinite Accordion program cannot reach that same state through any valid sequence of its own rules. The simplified model gets ahead of itself, performing a reduction that looks correct in the pixel world but is impossible in the real world. It's as if a shadow puppet show could perform a move that the actual puppeteer's hand could never physically make.

The paper doesn't just stop at finding the problem; it offers a solution. The authors show that by adding a rule called uniformity—which essentially forces the simplified model to keep all its parts in sync, like a marching band where everyone steps at the exact same time—they can fix the glitch. By restricting the simplified model to only these "uniform" moves, they create a new system where the approximation becomes conservative again. In this stricter system, every move the model makes is guaranteed to be a valid move for the original program, even for infinite ones. They also extend this finding to include programs that might crash or produce "undefined" results, ensuring the theory holds up even in messy, real-world scenarios.

In short, the paper proves that while linear approximation is a powerful tool, it needs a "seatbelt" called uniformity to stay safe when dealing with infinite computations. Without it, the approximation can hallucinate behaviors that don't exist in reality. With it, the map perfectly matches the territory, allowing scientists to trust their simplified models even when dealing with the most complex, infinite loops imaginable.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →