definition formalization

To address the challenge in software design where abstract models struggle to simultaneously achieve intuitiveness, integrability, and code translatability, this paper introduces Conceptual—a novel behavioral modeling domain-specific language (DSL) grounded in self-contained, highly reusable “concepts.” Methodologically, it formalizes the DSL’s semantics based on concepts, establishes a rigorous semantic mapping from Conceptual to Alloy to leverage Alloy’s formal verification capabilities, and implements a VS Code–based prototype toolchain supporting syntax highlighting, parsing, and model transformation. Contributions include: (1) the first formal semantics for a concept-based DSL; (2) a sound, executable translation to Alloy enabling automated consistency checking; and (3) an integrated development environment demonstrating practical usability. Empirical evaluation shows that Conceptual accurately captures design intent across diverse domains; its prototype compiler has successfully detected multiple specification errors reported in prior literature, thereby validating its expressive power, logical consistency, and engineering feasibility.

This work addresses the challenge of achieving reliable, low-cost automatic formalization of mathematical proofs under limited computational resources. It introduces Trellis, a novel system that translates mathematicians’ intuitive notion of “rigor” into executable process semantics by constructing a deterministic, constraint-guided workflow based on general-purpose large language model agents. Without requiring domain-specific training, Trellis employs an iterative refinement mechanism to progressively transform informal natural language proofs into formal Lean proofs. The system demonstrates its efficacy and practicality by successfully formalizing, in an end-to-end manner, a recent breakthrough result in Ramsey theory, thereby validating its capacity to bridge informal mathematical reasoning and machine-checkable formalization.

This paper addresses two key challenges in foundational programming theory: the mathematical complexity of basic programming concepts and the reliance of formal verification on redundant axioms. To resolve these, we propose PRISM—a minimalist programming theory grounded solely in naive set theory. PRISM introduces only one primitive relation, one initial set, and three fundamental operations (selection, composition, and restriction), without assuming any axioms. It unifies program semantics and specifications within a single set-theoretic framework, defining correctness, specialization, and refinement via standard subset inclusion. All core results—including over thirty program properties and classical “programming laws”—are fully mechanized and formally verified in Isabelle/HOL. Our contributions are threefold: (1) the first axiom-free programming theory framework; (2) a unified semantic–specification representation for programs; and (3) an open-source, reproducible, and extensible library of machine-checked proofs.

Existing formal methods incur high costs in specification construction and maintenance and lack scalability, making them ill-suited for verifying modern AI systems. This work proposes a Learning-Integrated Formal Reasoning (LIFR) framework that innovatively combines machine learning with formal verification: it employs natural language processing to automatically generate contracts, leverages graph matching and representation learning to achieve semantic alignment and cross-system reuse of verification artifacts, and establishes a rigorous semantic foundation grounded in Unifying Theories of Programming (UTP) and institution theory. By shifting formal verification from isolated proofs toward a cumulative, knowledge-driven paradigm, the LIFR framework substantially enhances automation and scalability while preserving formal rigor.

Long commercial contracts—such as Share Purchase Agreements (SPAs)—suffer from excessive verbosity, undetected logical inconsistencies, and difficulties in verifying execution feasibility. Method: This paper proposes the first automated consistency verification framework for SPAs, grounded in a domain-specific ontology and decidable first-order logic (FOL) constraints. It integrates ontology-based modeling, structured natural language (blocks) encoding, and SMT-solvable assertion generation to achieve end-to-end translation from unstructured text to formal constraints, followed by satisfiability checking via solvers like Z3. Contribution/Results: It is the first work to combine a domain ontology with decidable FOL for SPA consistency verification; supports generating either a satisfying model or an infeasibility proof; and demonstrates effectiveness on real-world SPAs, significantly improving review efficiency and reliability.

This work addresses the prevailing lack of systematic understanding of foundational formal theories in current AI compiler design, which hinders rigorous evaluation of the completeness and desirability of intermediate representations and compilation abstractions. For the first time, it systematically establishes precise correspondences between core mechanisms of MLIR—such as term rewriting systems, refinement calculi, and abstract interpretation—and classical formal theories. By grounding compiler abstractions in formal semantics, the paper clarifies the theoretical underpinnings of these constructs, articulates a precise notion of “design completeness,” and provides assessable criteria and guiding principles to navigate trade-offs between engineering pragmatism and theoretical ideals.

This study addresses the limited semantic transparency and poor comprehensibility of existing conceptual models, which stem from their reliance on low-level syntactic constructs to represent domain abstractions, thereby hindering effective system design and stakeholder communication. To overcome this, the paper proposes a language-agnostic abstract symbol engineering approach that identifies, formalizes, visualizes, and validates recurring syntactic configuration patterns, replacing them with high-level, semantically transparent abstract symbols. The method is instantiated as the DeCleaR extension to Dynamic Condition Response (DCR) graphs. Empirical evaluation demonstrates that DeCleaR significantly enhances perceived model quality, pragmatic quality, and user preference compared to standard DCR graphs.

This study addresses the efficiency bottleneck in the large-scale automatic formalization of graduate-level mathematics textbooks. By deploying 30,000 parallel AI agents based on Claude 4.5 Opus and integrating version control with the Lean theorem prover, the project achieved the first end-to-end fully automated formalization of an entire 500-page algebraic combinatorics textbook within one week. The resulting artifact comprises 130,000 lines of Lean code and 5,900 formal statements, accompanied by an open-source repository and a side-by-side blueprint website. This effort not only demonstrates the feasibility and economic viability of large-scale formalization—achieving costs lower than expert salaries—but also establishes a new record in scale and efficiency for multi-agent collaborative software engineering.

This work addresses the semantic divergence between ShEx and SHACL, which adopt greatest fixed-point (GFP) and least fixed-point (LFP) semantics for recursion, respectively, thereby hindering interoperability. The paper proposes a unified formal semantic framework to systematically compare LFP, GFP, and supported model semantics (SMS), revealing a duality between these approaches over stratified fragments. It identifies large-scale syntactic fragments of ShEx and SHACL that are semantically equivalent and provides a complete characterization of data and combined complexity under all three semantics. The results demonstrate that ShEx and SHACL are semantically compatible in mainstream use cases, while SMS incurs higher computational costs under standard complexity assumptions, offering a theoretical foundation for future standardization efforts and tool development.

This work addresses the challenge of accurately evaluating the quality of formal program specifications generated by large language models (LLMs), a task often confounded by the inherent complexity of formal verification. To mitigate this issue, the authors propose Coins, a framework built upon the Rocq formal system that aligns evaluation with the asymmetric nature of formal reasoning. Coins instantiates generated specifications against trusted test cases and automatically derives concrete proof obligations, using test-case-driven proof success rates as a reliable proxy for specification quality—thereby avoiding misattribution of proof difficulty to specification inadequacy. Large-scale experiments on HumanEval demonstrate that current LLMs still face substantial difficulties in specification generation, and that Coins provides a more accurate assessment of genuine differences in specification quality.