typeclass design

This paper addresses the lack of systematic support for theory morphisms and logical relations in the $λΠ$-calculus modulo rewriting framework. Methodologically, it introduces a unified extension mechanism that formally integrates both concepts for the first time within this framework and designs a pattern-based invariant verification procedure, reducing the proof of translation invariants to finite, decidable propositional checks. The main contributions are: (1) a structurally clear, machine-verifiable formalization of inductive translations—e.g., type erasure; (2) the first fully verified type-erasure instance in $λΠ$-calculus modulo rewriting; and (3) a reusable methodology for rigorously verifying the correctness of translations between formal systems.

Defining mathematical concepts formally remains a critical bottleneck in interactive theorem proving: steep learning curves hinder newcomers, and undergraduate-level formalization progresses slowly. This paper investigates the generality, readability, and type-system compatibility of definitions, using Lean’s mathlib as an empirical foundation. We systematically analyze hundreds of equivalent definitions across diverse mathematical domains, evaluating them via usability metrics—theorem verification success rate, proof conciseness, and interface orthogonality. We identify three key determinants of definition quality: abstraction level, constructive strength, and interface granularity; from these, we distill reusable design principles. Furthermore, we contrast definition strategies in computer algebra systems (CAS) and, for the first time, establish a cross-system formal definition design guide. Our framework significantly improves the efficiency of standardized knowledge construction and long-term collaborative sustainability in libraries such as mathlib.

This work unifies the modeling of inference rules and proof structures of formal systems within a categorical framework. It introduces a met-variable context representation based on Cartesian PROPs, encodes assumptions and conclusions using spans, and constructs a symmetric monoidal category of proofs with met-variable substitution as the sole primitive operation. This approach is the first to uniformly embed both inference rules and proof structures into the semantics of symmetric monoidal categories, thereby supporting compositional and reusable handling of hypotheses. The authors implement an open-source verification algorithm and surface syntax, successfully encoding formulas, axioms, and representative derivations of first-order logic, and release a functional proof checker.

Formal proofs in proof assistants like Coq often break under semantic changes—e.g., modifications to equivalence relations in quotient types—posing challenges for existing automated repair techniques, which lack support for behavioral-level alterations. This work introduces the first proof repair algorithm tailored to quotient-type equivalence changes. We propose a setoid-based external modeling of quotient types, enabling joint handling of representation and behavioral changes. Furthermore, we construct the first internal correctness proof of the algorithm in Cubical Agda, grounded in univalent semantics to guarantee semantic consistency. Empirical evaluation demonstrates successful repair of multiple previously intractable quotient-type equivalence changes, substantially reducing manual intervention. The approach is validated across both Coq and Cubical Agda, confirming its feasibility, cross-platform applicability, and formal correctness.

In dependent type theory, controlling the granularity of definition unfolding has long posed a dilemma: global unfolding renders proofs brittle, while manual annotation sacrifices automation and robustness. This paper introduces a novel localized unfolding mechanism grounded semantically in extension types, whereby definitions remain inert by default and admit on-demand, local, context-sensitive selective unfolding. Departing from traditional global toggle paradigms, we design a core calculus within homotopy type theory and implement a formally verified prototype in the cooltt proof assistant. Theoretically, we establish a normalization theorem ensuring computational soundness. Empirically, our approach significantly improves proof stability, effectively curbs target-term size explosion, and reconciles expressive reasoning power with maintainability—demonstrating both foundational advancement and practical viability.

This work addresses the limitation of traditional introductory computer science curricula, which often emphasize isolated knowledge points while neglecting the underlying proof techniques and abstract structures essential for cultivating computational thinking in beginners. To remedy this, the paper proposes a novel pedagogical paradigm centered on universal proof strategies and abstract frameworks, using the transitive closure of relations as a representative case study. By integrating tools such as the Kleene star, quantale theory, and closure operators over complete lattices, the approach constructs a cohesive bridge linking logic, algebra, and computational reasoning. This method yields a generalizable instructional framework that significantly enhances students’ structural understanding and analytical capacity regarding foundational concepts.

This work proposes a systematic formalization of all published mathematical knowledge into a machine-verifiable, continuously evolving structured knowledge base, addressing the challenges of scalability and organization. Taking dilatations of categories in categorical algebra as the first case study, the project integrates interactive theorem proving, dependent type theory, and category theory to frame the complete formalization of mathematics as a universal reasoning benchmark. By constructing a formal prototype of category dilatations, the study demonstrates the feasibility of this approach in expressing complex algebraic structures, thereby establishing both an architectural foundation and a practical pathway toward a large-scale, interconnected, and extensible database of formalized mathematics.

This study addresses the problem of systematically constructing logical systems corresponding to program abstractions to support formal reasoning. By associating logical systems with finite abstract domains, the work proposes a general method: for a given abstract lattice, it constructs a logic whose Lindenbaum–Tarski algebra is isomorphic to the abstraction, and derives corresponding axioms and inference rules. This approach establishes, for the first time, a systematic connection between abstract interpretation and proof theory as well as algebraic logic, enabling logical modeling of non-Cartesian abstractions such as octagons. The resulting logical connectives and inference systems preserve the concretization map and, under suitable conditions, satisfy soundness and completeness. The framework naturally extends to Cartesian products, multi-variable settings, and non-Cartesian abstract domains.

Traditional logical relations struggle to accommodate directed reductions in type theory, impeding normalization proofs in dependent type systems. This work presents the first logical relation model within simplicial homotopy type theory that integrates contravariant computability predicates with directed quotient inductive types. Reduction is internalized as an inequality type, and a comonadic flat modality cleanly separates vertical reductions from horizontal parametricity. Leveraging built-in functoriality and universal properties, the approach supports computability reasoning under directed reduction, enabling a successful proof of directed Boolean normalization. The method extends to systems featuring dependent types and universes, yielding the first formalization of representation independence with proof relevance.

Current interactive theorem provers rely heavily on dependent type theory, often overlooking the potential of structural proof theory. This work systematically compares sequent calculus and dependent type theory in the context of proof assistant design, arguing that proof-theoretic frameworks offer distinct advantages in separating logic from proof representation, supporting nondeterministic proof strategies, and simplifying type mechanisms. The paper innovatively integrates lambda-tree syntax with the nabla quantifier to intrinsically handle binding structures and implements this approach within the Abella system for validation. Empirical results demonstrate that the proposed method significantly enhances conciseness and expressiveness in formalizing metatheory and reasoning about complex binding constructs.