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.

This work addresses computer-assisted internal type-theoretic reasoning within general categorical settings—such as cubical sets, groupoids, and the category of categories—by introducing novel exponentiability conditions for arrow categories and constructing corresponding polynomial functors. These advances extend algebraic approaches to type theory beyond traditional set-based frameworks. Leveraging the HoTTLean formalization system, the project achieves a syntactic–semantic co-reasoning mechanism that has been successfully instantiated in the aforementioned categorical contexts, substantially enhancing the capacity for type-theoretic analysis in non-set-theoretic foundations.