intermediate representation

This work addresses the challenges of integrating external domain-specific languages (DSLs) into interactive proof assistants—namely, the tedious, type-unsafe, and error-prone nature of expression translation. We propose DSLean, a framework built on Lean 4’s metaprogramming system that enables type-safe, bidirectional translation between external DSLs and their Lean equivalents through declarative syntax definitions. DSLean introduces a lightweight, syntax-directed bidirectional transformation mechanism coupled with type-driven semantic alignment, substantially reducing the integration overhead for external automated reasoning tools. We demonstrate the framework’s generality and practicality by successfully connecting solvers for interval arithmetic, ordinary differential equations, and ideal membership in polynomial rings, showcasing its effectiveness across diverse domains.

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 problem of program synthesis in domain-specific languages (DSLs) that involve numeric constants and require optimization of quantitative objectives such as accuracy. The authors propose a provably optimal search method that constructs a search graph over program subsets and integrates A* search with a heuristic derived from abstract interpretation to efficiently prune suboptimal subtrees. The key innovation lies in the design of abstract transformers tailored to DSL components with monotonic semantics, enabling a pruning mechanism that guarantees optimality. Experimental evaluation on two real-world DSLs demonstrates that the approach substantially outperforms existing state-of-the-art synthesizers, achieving significant improvements in scalability while maintaining correctness and optimality guarantees.

Emerging verification-oriented programming languages like Move lack LLM-driven tools for automated specification generation. Method: This paper introduces the first automated specification generation framework tailored for Move smart contracts. It adopts an agent-based modular architecture that deeply integrates Move’s language features with formal specification modeling and incorporates a verification-toolchain feedback loop for iterative output refinement. Contribution/Results: Compared to conventional approaches, the framework significantly enhances code understanding and specification generation for non-mainstream languages. Experiments show it generates verifiable specifications for 84% of test functions, increasing the number of verifiable clauses by 57% over baselines; integrating feedback further improves specification quality by 30%. This work represents the first systematic exploration of large language models’ adaptation pathways and potential within verification-first language ecosystems, establishing a novel paradigm for LLM-augmented formal methods.

Automated verification in separation logic (SL) has long relied on ad hoc heuristics, lacking a systematic metatheory and suffering from poor scalability. Method: This paper establishes the first general SL metatheory grounded in category theory and algebraic structures—specifically functors, homomorphisms, and modules over rings—systematically integrating abstract algebra into SL automation. The framework supports compositional model instantiation and modular predicate synthesis for any data structure admitting an algebraic characterization. All results are formally verified in Isabelle/HOL, and an automatic algebraic instantiation algorithm is developed. Contribution/Results: Experiments demonstrate fully automated algebraic modeling of complex imperative program semantics—including lists, trees, and graphs—and yield inference engines whose performance matches state-of-the-art hand-crafted systems. This approach decisively overcomes the scalability limitations inherent in heuristic-based methods.

This work addresses the limited reusability and evolvability of existing software product line (SPL) engineering approaches, which are typically tied to specific technology stacks and integrated development environments (IDEs). To overcome this constraint, the authors propose a workspace-agnostic protocol that incrementally extracts feature models from lightweight dependency units called “atoms.” The approach introduces a configuration and generation architecture comprising a generic SPL server and pluggable clients—each combining a universal frontend with a specialized backend. This design decouples SPL engineering from underlying technical spaces, enabling flexible, cross-language and cross-IDE component substitution. A prototype implementation, with a Go/Prolog-based server, a Java backend, and a JavaScript frontend, was validated on Neverlang language artifacts, demonstrating the protocol’s generality, reusability, and independence from specific development workspaces.

Existing data pipelines often suffer from weak governance, leading to delayed schema validation, inconsistent cross-language execution, and misalignment with business semantics. This work proposes treating data contracts as types, leveraging the “everything-as-code” paradigm to inject schema annotations—encompassing column types, constraints, documentation, and lineage—into input and output tables within a lakehouse architecture via multi-language SDKs. These annotations are parsed across multiple phases of the execution lifecycle, deeply integrating data contracts into the type system. The approach enables both deterministic and non-deterministic reasoning over data flows across languages and execution engines, significantly enhancing the reliability of production data pipelines and ensuring consistent interoperability across systems.

Modular control-flow handling in abstract interpretation and supporting multiple analysis strategies—such as path- vs. flow-sensitivity, forward vs. backward directionality, and upper vs. lower approximations—traditionally relies on complex monad transformers, leading to implementation brittleness and poor composability. Method: This paper introduces the *cumulative abstract semantics* framework, the first to incorporate *scoped effects* into abstract interpretation. It decouples syntactic structure from semantic behavior via two classes of effect handlers: *syntax-resolving* and *domain-semantics-introducing*. A single syntax-driven interpreter suffices to generate diverse dynamic evaluators and static analyzers. Contribution/Results: The framework eliminates heavyweight data structures, preserving expressiveness while drastically reducing implementation complexity for multi-strategy analyses. It enhances maintainability, composability, and modularity—providing a concise, unified, and extensible theoretical and practical foundation for modular program analysis.

This work addresses the challenge of concisely expressing Datalog-style logical rules and queries within Lean, a highly expressive yet complex proof assistant based on the Calculus of Inductive Constructions (CIC). To this end, the authors propose a shallowly embedded domain-specific language (DSL) that enables, for the first time, a seamless integration of Datalog into Lean. The DSL supports declarative definitions of facts and rules, backward-chaining queries, and—crucially—the automatic translation of Datalog queries into theorems accompanied by proof scripts, thereby establishing bidirectional interoperability with Lean’s native reasoning framework. The effectiveness of the approach is demonstrated through three representative case studies, which collectively illustrate its expressiveness in rule formulation, readability of queries, and capability to support formal verification.