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 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 ensuring program correctness in natural language-to-code generation, which is often hindered by the absence of high-quality formal specifications. The authors propose VeriSpecGen, a framework that decomposes natural language requirements into atomic clauses through a traceable refinement mechanism, generates requirement-driven tests with explicit traceability mappings, and synthesizes formal specifications aligned with user intent by localizing and repairing faulty clauses upon verification failure. Integrating large language models (e.g., Claude Opus 4.5) with the Lean proof assistant, the approach leverages refinement trajectories to generate 343K training samples, substantially enhancing model generalization and reasoning capabilities. Evaluated on the VERINA SpecGen benchmark, VeriSpecGen achieves an accuracy of 86.6%, outperforming the best baseline by up to 31.8 percentage points and demonstrating a relative improvement of 62–106% in specification synthesis performance.

This work addresses the challenge in conceptual design where relying solely on safety invariants often fails to uniquely determine reaction rules aligned with user intent, leading to inconsistent synthesis outcomes. To overcome this, the authors propose a novel synthesis approach that integrates formal semantics with an LLM-driven Counterexample-Guided Inductive Synthesis (CEGIS) framework. The method leverages either positive/negative example scenarios or natural language prompts to guide the generation of rules satisfying given safety invariants, and introduces, for the first time, an LLM-assisted scenario-based elicitation mechanism to support early-stage design exploration. As the first effort to combine formal verification with LLM-based synthesis in conceptual design, experiments demonstrate that scenario-based guidance more reliably reproduces intended designs than natural language alone; with sufficient scenarios, LLM-augmented elicitation effectively recovers expected behaviors for most variants, though behavior omission and non-determinism remain key obstacles to achieving full coverage.