A Lazy, Concurrent Convertibility Checker

2025-10-21

AI Summary

This work addresses the inefficiency of convertibility checking for lambda terms in proof assistants and dependently typed languages, where heuristic approaches often trigger redundant computation. We propose a novel algorithm that integrates lazy evaluation with concurrent execution, modeled in a process-calculus style. The algorithm achieves efficient equivalence checking through shared subcomputation, parallel exploration of reduction paths, and fair interleaving scheduling. To our knowledge, this is the first approach to deeply couple laziness and concurrency for convertibility checking, guaranteeing discovery of any simple (i.e., shortest) normalizing derivation. We formally verify its partial correctness and provide theoretical complexity analysis. Lightweight experiments demonstrate that, in typical scenarios, the algorithm significantly avoids large-scale spurious reductions, thereby improving decision efficiency.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Knowledge Representation and Reasoning: Computational Complexity of Reasoning
• Reasoning under Uncertainty: Other Foundations of Reasoning under Uncertainty

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web
• Systems and Infrastructure for Web, Mobile and WoT: Experiences and lessons learnt from Web-based algorithms and system deployments

Abstract

Convertibility checking - determining whether two lambda-terms are equal up to reductions - is a crucial component of proof assistants and dependently-typed languages. Practical implementations often use heuristics to quickly conclude that two terms are or are not convertible without reducing them to normal form. However, these heuristics can backfire, triggering huge amounts of unnecessary computation. This paper presents a novel convertibility-checking algorithm that relies crucially on laziness and concurrency} Laziness is used to share computations, while concurrency is used to explore multiple convertibility subproblems in parallel or via fair interleaving. Unlike heuristics-based approaches, our algorithm always finds an easy solution to the convertibility problem, if one exists. The paper presents the algorithm in process calculus style and discusses its mechanized proof of partial correctness, its complexity, and its lightweight experimental evaluation.

Problem

• Develops lazy concurrent algorithm for lambda-term convertibility checking
• Avoids heuristic pitfalls by exploring subproblems in parallel
• Ensures finding easy solutions when they exist

Innovation

• Uses laziness to share computations efficiently
• Employs concurrency for parallel subproblem exploration
• Avoids heuristics by finding easy solutions directly