Well-Scoped Locally Nameless Representation of Syntax

Abstract: When using interactive theorem provers based on dependent type theory to define and reason about languages involving binding constructs, we advocate the use of a well-scoped version of the locally nameless method of representing syntax. This paper describes generic code parameterized by a Plotkin-style binding signature for this style of syntax representation within the Agda theorem prover, gives a proof of its adequacy with respect to naive nameful syntax modulo alpha-conversion and discusses some examples of its use.

• The paper develops a formal framework that intrinsically enforces well-scoped, locally nameless syntax using dependent types.
• It parameterizes syntax over arbitrary binding signatures, ensuring safe substitutions, abstractions, and renamings via indexed inductive datatypes in Agda.
• The approach proves a bijection with α-equivalence classes and supports diverse applications, including the pi-calculus, MLTT, and System T.

Well-Scoped Locally Nameless Representation of Syntax

Motivation and Background

The paper develops a formalized framework for the representation of abstract syntax involving binding, targeting proof assistants based on intensional dependent type theory such as Agda and Lean. The focus is the integration and extension of the locally nameless representation—where bound resources are encoded as de Bruijn indices and free resources as explicit atoms—enforced to be well-scoped by the type system. This enforces structural invariants, notably local closure, at the type level, removing the need for repetitive explicit invariant maintenance in metatheoretic developments.

Traditionally, the locally nameless approach offers operational transparency and low infrastructure overhead for mechanized metatheory, addressing longstanding challenges in the mechanization of languages with complex binding. However, it does not guarantee local closure intrinsically, forcing the frequent, explicit establishment of well-formedness properties. By recasting the representation to intrinsically well-scoped terms using dependent types indexed by the “in-scope” depth, the framework presented leverages the expressiveness of type theory to statically rule out ill-scoped terms, addressing pitfalls with free/dangling indices and opening avenues for more robust mechanizations.

Core Framework and Formalization

The central technical construction is a library (WSLN) parameterized by an arbitrary Plotkin-style binding signature. Syntax trees are represented as indexed inductive datatypes where each term carries an explicit scope index, ensuring (via the type Fin n) that only indices genuinely in scope are present. The foundational mechanisms—abstraction, concretion (opening), substitution, renaming, and scope weakening—are all recast with respect to these indexed types, and their correctness is ensured compositionally. For instance, closing replaces an explicit atom with a scoped index in a manner respecting context extension, and opening replaces a scoped index with a term, managing index shifting and insertion in a context-sensitive manner. Substitutions are simply total functions from atoms to closed terms, and the locally closed property now follows strictly by typing.

One nontrivial aspect is abstracting over arbitrary binding signatures, which is handled via parameterization, so the framework seamlessly applies to a range of calculi, from variants of the lambda calculus to process calculi (such as the pi-calculus), and even type theories like MLTT. The library’s definitions are supported by formal proofs of soundness, most notably the adequacy theorem: well-scoped locally nameless terms are shown to be in bijection (modulo definitional equality) with $\alpha$-equivalence classes of "nameful" syntax, and substitution corresponds to standard capture-avoiding substitution.

Adequacy Theorem

A central theoretical claim is the proof that for any binding signature $E$, the type of 0-terms (intrinsically locally closed, well-scoped locally nameless syntax) is in bijection with $\alpha$-equivalence classes of nameful syntax. This correspondence holds for substitution: substitution in the well-scoped representation aligns precisely with capture-avoiding substitution on $\alpha$-equivalence classes. The bijection is formalized by recursive translations in both directions, with nontrivial technical work in the injectivity and surjectivity directions, relying on a carefully defined notion of term size to enable recursion.

Implementation Aspects in Agda

The library is implemented in Agda, making minimal technical demands on the underlying intensional type theory. All core operations are given as structurally recursive, indexed datatypes. The design leverages Agda’s decidable equality for atoms, finite-support sets for managing variable freshness (including an explicit function for generating fresh atoms), and well-scoped de Bruijn indices.

Abstraction and concretion are precisely defined to handle the index shifting associated with context extension and context reduction, respectively. The definitions are both concise and structurally recursive, and Lemma 4.7 enumerates key algebraic properties (such as interactions between concretion, abstraction, substitution, and freshness), all machine-checked in Agda.

The WSLN library is designed to be general: the key infrastructure is parameterized over binding signatures, supporting a wide class of formal systems. This modularity reflects an emphasis on reusability and reduction of infrastructure overhead, aligning with the POPLMARK challenge's original design criteria.

Examples and Empirical Validation

Three notable case studies substantiate the scope and flexibility of the framework:

1. Pi-Calculus: The binding signature directly captures process expressions with different arities and binding profiles, demonstrating that the approach handles non-lambda-calculus-style bindings (channels, etc.) without additional complication. The example exposes a practical limitation: the framework, as built, reflects an unsorted signature; well-formedness of terms may require an additional inductive predicate for typing disciplines not expressible by simple arity information alone.

2. Martin-Löf Type Theory (MLTT): The framework mechanizes a nontrivial portion of MLTT metatheory, including rules for dependent types, universes, natural numbers, and elimination principles such as natural number induction via elimination rules. The transparency and proximity of the formal definitions to standard informal presentations is emphasized, as is the handling of freshness constraints—either via explicit assumptions (exists-fresh) or cofinite quantification, supporting a wide spectrum of metatheoretic proof styles.

3. Gödel’s System T: The framework is applied to a machine-checked normalization-by-evaluation proof for System T, demonstrating practicality for larger developments. Notably, the setoid-enriched presheaf semantics and handling of freshness within Kripke-style possible worlds shows that binding-aware representations do not preclude advanced techniques from categorical and logical semantics of syntax with binding.

Implications and Future Directions

The well-scoped locally nameless approach, equipped with intrinsic enforcement of local closure, marks a qualitative improvement in the mechanization of syntax with binding. It unifies the informal mathematical transparency of name-based syntax with the operational advantages of de Bruijn-index-based representations, without imposing shifting and order maintenance burdens. By leveraging dependent types, the approach demonstrably eliminates entire classes of bugs related to scope and dangling indices, as was observed in other large formalizations.

Nevertheless, certain limitations persist. Unsophisticated binding signatures (e.g., one binding vector per constructor, no support for mutually recursive binding or advanced “nominal” features) restrict the direct representation of more complex language features. The paper identifies the extension of these techniques to richer notions of binding as a significant future avenue—for instance, integrating with sophisticated meta-language tools like Ott, which support richer structural binding patterns.

Additionally, while the approach is elegantly realized in type-theory-based provers, its direct transfer to systems lacking dependent typing (like Isabelle/HOL) is nontrivial. As the adoption of intrinsic, strongly-typed approaches grows, one can anticipate greater convergence on this style for future large-scale mechanized language metatheory.

Conclusion

This paper presents a formally robust, general-purpose dependent-typed framework for well-scoped locally nameless representation of syntax with binding, parameterized by arbitrary binding signatures. It substantiates the practical advantages (automatic well-scoping, reduced proof overhead, operational transparency) through core theoretical results and diverse mechanized examples. The approach models a significant improvement in the design of libraries for language metatheory in proof assistants and sets a foundation for future advances in the treatment of abstract syntax modulo binding in formalized mathematics and logic.