Papers for

programming language designers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

New proof simplifies weak normalization for propositional logic

Simplified proofs of Weak Normalization for propositional logic

Abstract: We present a new proof of weak normalization for intuitionistic natural deduction. The distinguishing features of this proof are that it works only with cuts rather than cut segments, provides explicit local rules for determining whether to contract a whole proof or reduce one of its subproofs, and in the latter case, which subproof to reduce. We also discuss a formalization of the entire proof in Lean, and present a deterministic algorithm for weak normalization.

Sun 13 SeptLogic in Computer Science
The gist
Logic proofs can sometimes get complicated, especially when trying to simplify or 'normalize' them. The authors found an easier way to show that any proof in a certain style of logic can be simplified. They do this by focusing on entire parts of the proof, rather than breaking them into smaller segments. They also created clear rules and a step-by-step method for this simplification, and showed it works by programming it in a computer language called Lean.
Open 2609.14314v1

Mechanized proofs verify Gödel incompleteness theorems and logic in Lean

Mechanizing Gödel's incompleteness Theorems and Provability Logic

Abstract: We mechanized proof of Gödel's first and second incompleteness theorems, Solovay's arithmetical completeness theorem of \mathbf{GL}, and related results in the Lean 4 theorem prover.

Sat 12 SeptLogic in Computer Science
The gist
Gödel's incompleteness theorems show fundamental limits in mathematical systems, but checking these proofs by hand is complex. The authors used a computer tool called Lean 4 to create fully verified digital versions of these theorems and related results in provability logic. This mechanization ensures the proofs are free of errors and can be reused in future formal reasoning. Their work also covers Solovay's theorem which links logic and arithmetic in a precise way.
Open 2609.13780v1

Formal grammars generate languages beyond Turing machine limits

Beyond the Turing threshold: Productive grammars generate essentially undecidable languages

Abstract: Emil Post's productive sets are not even semi-computable, let alone computable, being thus essentially incomputable. Accordingly, formal languages whose set of words is a (completely) productive set are essentially undecidable. In this article, I elaborate on Post productivity from the viewpoint of formal language theory: I design formal grammars that emulate the construction of productive sets of natural numbers and are thus beyond Turing-decidability.

Thu 10 SeptFormal Languages and Automata TheoryCryptography and Security
The gist
Some problems or languages cannot be decided or solved by traditional computers called Turing machines. The authors focused on special sets of numbers known as productive sets, which are even more complex and undecidable than usual. They showed how to build formal grammars—rules for generating words—that mimic these complex sets. This means the languages created by these grammars cannot be decided by any computer, going beyond standard computability limits.
Open 2609.11385v1

Infinite data types can be fully searched using topology ideas

Compact totally separated types

Abstract: Perhaps surprisingly, there are infinite types that can be exhaustively searched mechanically in finite time. We use ideas from topology to build plenty of them, referring to searchable types as compact types, and we use ordinals to measure their logical complexity. We consider two systems of ordinal notations under which a single notation denotes both a discrete ordinal and a compact one, with an embedding of the former into the latter whose image has empty complement. A boolean valued function decides which points in the image of the embedding are isolated and which are topological limit points. The first system consists of the traditional Brouwer codes and the second is an inductive-recursive universe generalizing them. The discrete ordinals so obtained are trichotomous, and the compact ones have the least element property for complemented subsets, but these two desirable properties cannot be fulfilled simultaneously in a constructive setting. The ordinals obtained from Brouwer codes further enjoy a boolean Leibniz principle, which has the notion of total separatedness as its topological counterpart. This extends previous work from Gödel's system T to intensional Martin-Löf type theory with univalent universes, and is formalized in Agda in the TypeTopology repository.

Wed 9 SeptLogic in Computer Science
The gist
The paper shows that some infinite types, or collections of data, can be completely searched in a finite amount of time using a concept called compactness from topology. The authors connect these compact types with ordinal numbers to describe their complexity. They also explore how different systems of ordinals relate to these types and their properties, including limitations in constructively combining certain desirable features. This work extends earlier research into more advanced type theories and is implemented in a programming language called Agda.
Open 2609.10447v1

Type theory advances ensure safe erasure with identity and quotients

Erased Postulates, Identity Types and Quotients

Abstract: This text is concerned with the question of whether, in type theory with erasure annotations, one can postulate that some type is inhabited and still have a guarantee that a program will not get stuck. Previous work has provided such guarantees for consistent erased postulates, i.e. postulates that are restricted to be used in erased contexts. Here those guarantees are extended to type theory with identity types. Similar ideas provide a simple way to support quotient types: it is shown that one can let things like "the equivalence classes for two related values are equal" be erased postulates and have an eliminator that only computes for the equivalence class constructor, and still get a guarantee that programs will compute correctly. Another question is whether programs compute correctly if one is allowed to transport (cast) using erased identity proofs. It is shown that this is safe in the absence of quotients and postulates, and in the presence of quotients and erased postulates that can be implemented using equality reflection. However, unrestricted transports of this kind are not compatible with erased, postulated univalence. For that reason the text includes a study of the function []-cong, which encapsulates a limited form of transport for erased identity proofs. The text is accompanied by machine-checked Agda proofs.

Tue 8 SeptProgramming LanguagesLogic in Computer Science
The gist
When programmers use type theory to write programs, they sometimes assume certain facts without giving explicit evidence, called postulates. The authors study how to safely erase these assumptions in the final program without causing it to get stuck or stop working. They show it is safe to do this even when working with concepts that identify things as equal (identity types) and when grouping things into classes (quotients). They also explore limits on safely transporting values using these erased proofs and provide formal machine-checked proofs to back their results.
Open 2609.08578v1