implement term rewriting

This work addresses the automated verification of confluence (and non-confluence) and termination for Logic-Constrained Rewrite Systems (LCRSs). Methodologically, we propose CREST, a unified analysis framework integrating SMT solving, symbolic execution, and rewriting semantics to enable precise modeling and property derivation of rewrite rules under first-order logical constraints. Our key contribution is the first end-to-end automated verification framework capable of handling LCRSs with complex logical conditions—including inequalities and existential quantifiers—thereby overcoming the fundamental limitation of conventional rewriting tools, which only support unconstrained rules. Evaluated on diverse benchmarks, CREST achieves significantly higher accuracy, broader coverage, and superior scalability compared to state-of-the-art tools. It successfully verifies realistic LCRSs arising in program analysis and theorem prover preprocessing, demonstrating both practical applicability and theoretical advancement in constrained rewriting.

Automated confluence checking for term rewriting systems (TRSs) remains challenging due to the difficulty of automatically verifying confluence and the limitations of manually designed proof strategies. Method: This paper introduces the first machine learning–driven framework for automatic proof strategy invention. It pioneers the integration of reinforcement learning with symbolic reasoning, incorporating the CSI solver to autonomously explore and optimize within the strategy space. Additionally, it constructs the first large-scale, randomly generated benchmark dataset for TRS confluence evaluation. Contribution/Results: The framework breaks from traditional hand-crafted strategy paradigms by enabling end-to-end automatic strategy synthesis. It consistently outperforms state-of-the-art manual strategies on both the Cops benchmark and the new dataset, successfully resolving multiple long-standing TRS confluence problems previously unsolved by automated tools. This work establishes a novel paradigm for automation in formal verification and automated reasoning.

This paper addresses the decidability problem of confluence modulo an equational theory (E) (i.e., (E)-confluence) for conditional rewrite systems. To overcome the fundamental limitation of traditional approaches—which rely on enumerating infinitely many (E)-unifiers and thus fail to finitely characterize local peaks—we introduce *logical conditional critical pairs* and *parameterized conditional variable pairs*, thereby reducing (E)-confluence to a finite, decidable critical-pair analysis. Building upon the Jouannaud–Kirchner abstract rewriting framework, we integrate logical constraint solving, conditional term normalization, and equational reasoning to achieve, for the first time, a finite characterization of local peaks and a fully decidable verification procedure for (E)-confluence in conditional rewriting modulo theories. The resulting theory enables the construction of a finite critical pair set that uniformly covers major classes of conditional rewrite systems, providing a rigorous foundation for formal verification and automated theorem proving.

This paper addresses the modeling and termination proof of the “Hercules vs. Hydra” game in rewriting systems with AC (associative-commutative) symbols. To overcome the limitation of prior work—which fails to capture all winning strategies for Hercules—the authors introduce the first formal encoding that **fully characterizes arbitrary winning strategies** for Hercules. They devise an **AC-compatible weak multiset path ordering (AC-MPO)**, enhanced with semantic annotations and type-based techniques, enabling fine-grained control over AC rewriting behavior. This framework yields the first **rigorous proof of strong normalization** for the encoded game within the AC setting. Consequently, *all* Hercules-winning derivations are representable, and termination is formally verifiable. The approach establishes a new paradigm for studying strategy completeness and provable termination in AC rewriting systems. (149 words)

Compositional systems lack a structured, rewriteable mathematical foundation. Method: This work proposes a category-theoretic rewriting framework wherein structured cospans serve as the fundamental syntactic units; it introduces, for the first time, the coupling of structured cospans with double-pushout (DPO) rewriting, yielding a unified theory supporting both traced and trace-free semantics. The framework enables inductive, structure-preserving decomposition of closed systems and establishes a sound correspondence between syntax (structured cospans) and semantics (DPO rewriting). Contribution/Results: It provides the first categorical integration of structured cospans with DPO rewriting; defines two distinct rewriting paradigms—traceable and trace-free; and delivers the first mathematically rigorous, compositional, and rewriteable foundation for systems science, enabling cross-disciplinary modeling and formal analysis of complex systems.

Traditional query rewriting rules are tightly coupled with execution engines and lack formal correctness guarantees, making them difficult to port and error-prone. This work proposes Rulescript, an engine-agnostic domain-specific language that decouples rule specification from execution through a match-and-transform two-phase mechanism and automatically verifies semantic equivalence using a relational algebra core. Rulescript supports custom operators and, combined with lightweight adapters, enables cross-engine deployment. The authors experimentally reproduce 33 Apache Calcite rewrite rules and successfully migrate them to both CockroachDB and Apache DataFusion, demonstrating the feasibility of “write once, deploy anywhere.” To the best of our knowledge, this is the first extensible, verifiable, and cross-platform query rewriting framework.

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 challenge of efficiently compiling general rewrite rules with arbitrary regular-language context constraints into finite-state transducers, particularly in the presence of overlapping matches and complex contextual dependencies. The work proposes a compact compilation method based on a “worsening trick”: it first generates all valid rewrite candidates and then filters out suboptimal ones that admit better alternatives. This approach uniformly supports multiple contexts, arbitrary transformations, flag diacritics, directional rewriting, weighted rules, and parallel application. Formulated within a concise formal framework, the method reproduces classical results under semantic equivalence while significantly improving scalability and implementation simplicity. Experimental evaluation demonstrates that the generated transducers are functionally equivalent to those produced by foma across extensive grammatical and regression test suites, differing only in state numbering, thereby confirming both correctness and practical utility.

This work addresses the significant challenge of automatically generating inductive hypotheses—i.e., lemmas—required for rewriting induction in higher-order term rewriting systems with computational or constraint-based features. To this end, it introduces, for the first time, a template-based mechanism integrated into Bounded Rewriting Induction (Bounded RI). By recognizing common higher-order functional patterns in programs, the approach generates effective lemmas and establishes a complementary heuristic strategy for lemma synthesis. This method substantially expands the scope of provable program equivalences, successfully verifying previously intractable cases and thereby enhancing the practical applicability of rewriting induction in real-world code verification.