set-theoretic modeling

Standard modal logic systems exhibit heterogeneous Kripke frame structures, hindering systematic comparison and semantic interoperability. Method: This paper proposes a set-theoretic universal function-space framework that formalizes the common structural core of modal logics via function-space construction and semantic model mapping. Contribution/Results: The framework achieves, for the first time, uniform modeling and semantic embedding of all standard normal modal logics—including K, T, S4, and S5—within a single mathematical foundation. Unlike conventional fragmented approaches, it ensures both expressive completeness and structural consistency, enabling cross-system semantic interoperability, rigorous logical comparison, compositional combination, and principled extension. Experimental validation confirms that each classical modal logic system can be losslessly reconstructed within the framework, demonstrating its theoretical universality and practical feasibility.

This work addresses the challenges of formalizing set theory in dependently typed proof assistants, where boilerplate code is often excessive and integration with typed libraries is difficult. Building upon Lean 4’s Mathlib, the authors develop a set-theoretic framework over a model of ZFC that incorporates relational calculus, lightweight automation with predictable behavior, and standard set constructions. Crucially, it enables seamless interoperability between ZFC objects and Lean’s native types for the first time, supporting hybrid set/type reasoning. The framework substantially reduces boilerplate in scalable set-theoretic proofs while remaining fully compatible with Mathlib. Its expressiveness and practicality are demonstrated through complete formalizations of Boolean values, natural numbers, integers, and the Curry isomorphism theorem.

Existing set-theoretic automated reasoning tools—such as {log}—lack native support for arrays, limiting their applicability to programs involving mixed data structures. Method: We propose encoding arrays as functions represented by sets of ordered pairs, thereby reducing array reasoning to pure set-theoretic reasoning. To formalize this, we define a decidable fragment of set theory extended with function and array semantics, and implement its solver using constraint logic programming. Contribution/Results: This work introduces the first unified formalization and automated reasoning framework for arrays, sets, and relations within {log}, overcoming the prior decidability barrier posed by array constructs. Experimental evaluation demonstrates that our approach effectively encodes and solves programs featuring nontrivial array operations—including indexing, update, and length constraints—thereby substantially enhancing {log}’s capability to reason about heterogeneous data structures.

Traditional database models, grounded in the set-valued functor paradigm, lack native support for algebraic operations—such as numerical comparison and arithmetic—and exhibit a fundamental semantic and computational gap with programming languages. To address this, we propose an algebraic database model that systematically embeds multiple Lawvere theories into a unified categorical semantics framework, thereby coherently formalizing schemas, instances, schema transformations, and queries. Leveraging a proarrow equipment—a double-categorical structure—we integrate all model components, enabling direct expression and execution of algebraic operations (e.g., addition, order comparison) within data constraints and queries. This approach bridges the foundational disconnect between database theory and programming language semantics, yielding a verifiable algebraic semantics for databases and establishing computational completeness.

This work addresses the automatic inference of closed-form bounds for recursively defined functions—such as operator fixed points or solutions to functional equations—arising in program cost analysis, loop acceleration, and hybrid system verification. We introduce the *B-bound abstract domain*, which approximates numerical functions via conjunctions of predefined bounding functions, enabling synthesis of highly nonlinear invariants. To systematically lift Galois connections from value domains to function spaces, we design an *abstract domain functor*. Our approach integrates constraint-driven abstract construction, higher-order abstract interpretation, operator fixed-point theory, and symbolic-numerical dimensionality reduction. Experiments demonstrate that the framework efficiently handles multivariate, piecewise, and non-discrete functions; significantly improves nonlinear invariant inference; simplifies transition function design; and achieves end-to-end automation across diverse verification and analysis tasks.

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.

This paper addresses the structured lifting problem by proposing the first systematic abstract framework that uniformly characterizes its mathematical structure and computational semantics. Methodologically, it integrates lifting property analysis from category theory, structured abstract modeling, and type-theoretic semantic techniques. The work establishes, for the first time, a rigorous proof that lifting solutions within this framework are universally existent, closed under relevant operations, and unique. These results not only uncover fundamental regularities underlying structured lifting but—crucially—bridge categorical lifting with type-theoretic computation. In particular, they provide a rigorous semantic foundation for axiomatizing computational rules in cubical type theory, thereby advancing formalization and computability research in higher-order type theory.

This work addresses the limited support for intensional functions in Answer Set Programming (ASP) by proposing functional stable model semantics as a new foundation for ASP modulo theories (ASPMT). It systematically introduces intensional functions into ASPMT for the first time, enabling a deep integration of ASP with Satisfiability Modulo Theories (SMT) and establishing a formal correspondence between the two frameworks. By efficiently translating bounded ASPMT programs into SMT instances, the approach not only subsumes existing ASP–SMT integration methods as special cases but also substantially enhances ASP’s capability to model complex functional expressions.

This work proposes a formalization of algorithms within an intensional computability framework and clarifies their relationship to implementations in computational models. Treating computational models as monoid actions on configuration spaces, programs are modeled as dynamical systems constrained by such actions. Algorithms are defined as finite directed graphs of partial maps over edge-labeled abstract data structures, explicitly separating control flow from data operations. By leveraging tools from category theory, dynamical systems theory, and graph theory, the approach constructs a rigorous semantic framework that, for the first time, treats algorithms as abstract specifications of computational behavior and precisely characterizes the structure-preserving implementation relation between programs and algorithms, thereby deepening our understanding of the nature of computation.

This work addresses the semantic fragmentation and toolchain fragmentation in traditional model-driven engineering, which stem from the lack of a unified formal foundation among models, metamodels, templates, and transformations. To bridge this gap, the paper introduces Model Expression Algebra, treating models as values and expressions as terms, and unifying modeling operations through an evaluation homomorphism. By embedding a domain-specific language (DSL), the approach integrates metamodeling, model construction, and transformation within a single functional algebraic framework—unifying all four aspects for the first time. A type system ensures transformation safety, while free variables represent templates and computational operators encode functional logic, enabling type-preserving evaluation and built-in support for large-model expressions. Experimental results demonstrate that a single language can fulfill the full spectrum of modeling tasks while providing formal guarantees.