domain-specific language design

This paper addresses the problem of redundant semantic modeling of compilers and cross-language interoperability. It proposes a unified compiler model based on open-term multilingual semantic reduction systems, departing from conventional syntactic translation. Methodologically, cross-language reduction rules formally define both ahead-of-time (AOT) and just-in-time (JIT) compilation behaviors; properties such as confluence and type preservation directly yield partial formal guarantees of compilation correctness and secure compilation. The contributions are threefold: (1) the first holistic characterization of compilation as a multilingual reduction system that simultaneously defines both compilation semantics and interoperability semantics; (2) natural, structural support for uniform AOT/JIT interpretation via the reduction framework; and (3) significant simplification of secure compilation proofs, yielding novel semantic insights into compiler correctness and language interoperability.

Formal verification of multilingual software systems is challenging due to semantic mismatches and loss of fidelity when translating entire systems into a single modeling language. Method: This paper introduces the first contract-driven compositional verification framework that avoids full-system translation. It features: (1) a novel dual-loop abstraction-refinement mechanism integrating CEGAR and CEGIS; (2) syntax-guided, automated contract generation for cross-language update functions, augmented by SyGuS and LLMs; and (3) coordinated integration of the UCLID5 model checker with language-specific verifiers (e.g., CBMC, Kani) via shared contracts. Contribution/Results: The framework enables end-to-end, system-level property verification of native C and Rust components within Lingua Franca systems—preserving language semantics and avoiding distortion. It significantly improves verification precision and scalability, establishing a new paradigm for compositional, scalable, and language-preserving verification of multilingual systems.

This work addresses the scalability and practicality challenges in modeling operational semantics for programming languages. Methodologically, it introduces a mathematically lightweight yet semantically precise and extensible operational semantics framework, formalizing program computation steps to uniformly support semantic equivalence, reduction semantics, static analysis, compiler correctness proofs, and program property verification. Its key contributions are: (i) systematic modeling of multi-paradigm language features using minimal, accessible mathematical machinery—balancing theoretical rigor with engineering utility; and (ii) significantly enhanced portability and reusability of semantic models, demonstrated through successful formal verification of multiple production compilers and static analyzers. The framework provides a unified, scalable semantic foundation for programming language design, specification standardization, and trustworthy software construction.

This work proposes an end-to-end, large language model (LLM)-driven framework that integrates natural language directly into the formal verification pipeline, addressing the longstanding challenge that existing formal verification methods rely on rigorously defined formal specifications and thus struggle to accommodate safety requirements expressed in natural language. The approach leverages an LLM to automatically translate natural language descriptions into formal safety specifications, which are then used to perform compositional verification of code implementations. By circumventing the traditional dependency on manually crafted formal specifications, the method demonstrates a novel pathway toward bridging informal requirements and rigorous verification. Preliminary experiments indicate its feasibility and potential for enhancing code safety, offering a promising direction for making formal verification more accessible and applicable to real-world software development practices.

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.

This paper establishes logical and expression-based characterizations for the class of languages recognized by nondeterministic register automata with guessing (NRA) over infinite alphabets. We introduce Scoped MSO, a logic featuring a novel segment modality and syntactic restrictions on data comparisons. We prove this logic is expressively equivalent to NRA over data domains where ``strong guessing''can be eliminated. Furthermore, we define Data-Regular Expressions, a minimalist regular-expression calculus built from quantifier-free regions and equipped with $k$-contracting concatenation, and demonstrate its equivalence to NRA over arbitrary relational structures. Together, these formalisms provide a robust descriptive theory for register automata, bridging the gap between automata, logic, and expressions.

Existing symbolic execution approaches often lack a formal foundation aligned with the concrete semantics of programming languages, typically being constructed in an ad hoc and fragmented manner. This work proposes a symbolic Structural Operational Semantics (SOS) rule format that, for the first time, relies solely on the algebraic signature of the source language to uniformly capture both concrete and symbolic operational semantics, thereby enabling language-agnostic generation of symbolic execution semantics. Within this framework, we formally derive symbolic semantics and rigorously prove their soundness and completeness relative to the concrete semantics, demonstrating applicability to arbitrary programming languages.

This work addresses the persistent challenge of content composition vulnerabilities in software, which remain difficult to mitigate through developer training, static analysis, or templating languages, and are often reproduced in AI-generated code. The paper proposes a general-purpose secure content composition framework that incrementally extends the string expression syntax of general-purpose programming languages to enable precise security analysis and optimization at compile time. Its core innovation lies in a language design principle that minimizes the lexical distance between secure and insecure idioms, combined with dynamic-semantics-informed static analysis, compile-time diagnostics, and library-based encapsulation of secure logic. This approach facilitates collaborative remediation by both developers and AI systems, offering strong compile-time safety guarantees while maintaining performance comparable to native string concatenation, thereby significantly enhancing both the security and usability of string composition.

This work addresses the risk that lightweight attacks may escalate into severe security threats by proposing a “lingo”-based approach to protocol security enhancement. By formally modeling the core security components—referred to as lingo—within protocol dialects, the method designs composable and synthesizable generic patterns and integrates moving target defense principles to dynamically alter communication characteristics. This enables the automatic transformation of any protocol into a dialect variant with lightweight security guarantees. The contributions include the first composable formal framework for lingo, a general-purpose construction mechanism for protocol dialects, and empirical validation of the approach’s effectiveness and practicality across multiple protocols.

This work presents the first successful application of a large language model—specifically, Claude Opus 4.6—as an AI-powered programming assistant to automatically generate and verify a semantic-preserving proof for the Administrative Normal Form (ANF) transformation in the CertiCoq compiler, entirely without manual proof coding. Guided by human oversight and built upon the Rocq proof language, the approach adapts and transfers techniques from an existing continuation-passing style (CPS) transformation proof. Within approximately 96 hours, the system produced 7,800 lines of machine-checkable proof code, surpassing the previous CPS proof of 5,300 lines and substantially reducing development time. This result demonstrates the feasibility and significant potential of large language models in formal verification.