formalize closure properties

Traditional closure conversion incurs redundant environment management and suffers from complex correctness proofs, particularly when targeting abstract machines with flat, share-free closure/environment representations. Method: We propose a novel correctness proof inspired by abstract machines and design a more concise and efficient environment-handling mechanism grounded in closure invariance in the target language. Using a simple tuple-extended λ-calculus as the source language, we formalize our analysis within Accattoli et al.’s time-complexity framework. Contribution/Results: Although closure conversion increases static code size, it significantly reduces dynamic overhead—including allocation, environment lookup, and escape analysis—while preserving the abstract machine’s asymptotic execution time complexity. This work establishes, for the first time under flat environments, strict computational complexity equivalence between the source and converted terms, thereby bridging theoretical closure conversion with concrete abstract-machine semantics.

This paper addresses the formal verification of prefix-closed properties over finite traces in concurrent systems. To enable compositional reasoning, it introduces LMC—the first cut-free sequent calculus framework for such properties. Methodologically, LMC rests on three key innovations: (1) closure ℓ-monoids as the minimal algebraic structure for modeling finite-trace properties; (2) a division-free modal logic based on distributive residuated lattices, uniformly capturing both prefix closure and its residuals; and (3) a Gentzen-style syntactic formulation achieved by integrating Belnap’s structural operators with Moortgat’s modal rules. LMC is proven sound and complete with respect to closure ℓ-monoids and satisfies cut elimination. Consequently, it provides a novel, semantically grounded yet proof-theoretically efficient tool for compositional verification of prefix-closed finite-trace properties.

Precise verification of global properties for infinite program families—syntactically defined and potentially containing cycles—remains challenging due to semantic ambiguity and undecidability. Method: We propose the first minimal, compositional denotational semantics framework for such families and, based thereon, develop the first Hoare-style logic that is both sound and relatively complete for infinite program families. Contribution/Results: Our key innovation is a rigorous characterization of behavioral discrimination power along unbounded execution paths, proven necessary and sufficient for exact verification. The resulting logic enables syntax-driven, compositional reasoning, significantly improving verification precision and applicability. This work establishes a rigorous, low-complexity theoretical foundation for semantic modeling, formal verification, and program synthesis of infinite program families.

This work addresses the closure properties of the class of type-0 languages (i.e., Turing-recognizable languages) under union, reversal, concatenation, and Kleene star—fundamental operations in formal language theory. We present the first fully grammar-based, machine-free formal verification in Lean 3. Our methodology relies exclusively on constructive grammatical transformations and rigorous inductive reasoning, eschewing Turing machine encodings. Specifically: (1) we formally define type-0 grammars and their generated languages, proving their Turing equivalence; (2) we provide standard yet formally verified grammatical constructions and correctness proofs for union, reversal, and concatenation; and (3) we propose an original, syntactically precise grammar construction for Kleene star and formally verify its correctness. All proofs are mechanized using inductive definitions, formal operational semantics, and deductive reasoning within Lean’s interactive theorem-proving framework, ensuring end-to-end verifiability. This work fills a critical gap in the formalization of closure properties for formal languages in mainstream proof assistants.

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 paper addresses the verification of semantic properties—such as program correctness and termination—for sets, relations, and computations defined by elementary inference systems. To overcome the fundamental limitation that canonical models are often noncomputable, we propose a novel method that eschews reliance on canonical models entirely: instead, semantic properties are decided via first-order satisfiability in *arbitrary* models. Technically, we formalize inference systems as Gentzen-style elementary deductive systems, integrate Horn clause theories with proof-tree structural modeling, and leverage automated first-order satisfiability checking for verification. Our principal contribution is a general logical decision framework for rewriting-based computational models (e.g., programming language semantics), enabling formal, machine-checkable proofs of semantic property validity or invalidity. This approach significantly enhances both the practical applicability and decidability of semantic analysis.

This work addresses the fragmentation between reasoning logics for program properties and hyperproperties in formal verification. It proposes APPL, a Hoare-style program logic parameterized by abstract domains, which unifies Hoare logic, incorrectness logic, and hyper-Hoare logic within a single framework for the first time. Leveraging additive semantics over lattices and non-idempotent monoidal operators, APPL enables flexible abstract semantic modeling capable of expressing both collecting and hyper semantics. Built upon the theory of abstract interpretation, the system is sound and achieves relative completeness when the underlying abstract domain is sufficiently expressive. Moreover, when the abstract domain is complete with respect to the monoidal operator, relative completeness is restored, yielding an abstract deductive system grounded in the notion of best correct approximation.

This work proposes a composable program verification framework grounded in dependent type theory, designed to harmonize modular development with formal verification. The approach characterizes program interfaces using polynomial functors, models implementations via Kleisli morphisms of free monads, and encodes pre- and postconditions through dependent polynomials. Wiring diagrams are employed to support compositional reasoning about correctness. The key theoretical contribution lies in uncovering a lax monoidal structure mapping specifications to interfaces, together with compatible lax monoidal natural transformations between presheaves, thereby establishing a foundation for concurrent and relational verification scenarios. The entire framework has been formalized in Agda, demonstrating both its feasibility and strong compositional properties.

Traditional least fixed-point semantics often fails to support precise static cost analysis due to its neglect of recursive structural information. This work proposes operator semantics as an intermediate representation bridging syntax and denotational semantics, treating programs as operators and constructing a higher-order abstract domain grounded in category theory, with composition as the core primitive. This framework enables abstract compilation that simultaneously achieves soundness, precision, and modularity. The approach supports cost analysis for general functional unknowns and generalized fold-based metrics, leveraging a solver-agnostic technique for extracting optimal recurrence relations. Consequently, it facilitates precise static cost analysis of recursive programs over algebraic data types, encompassing generalized size metrics beyond the reach of conventional methods.

Existing property-based testing frameworks, such as Hedgehog, lack compositional semantics, making it difficult to formally verify the correctness of generator optimizations. This work develops a formal semantic model for such frameworks, revealing that their distributional semantics are inherently non-compositional. To address this, we propose Hedgehog→, a restricted variant based on arrow calculus, which trades modest expressiveness for compositional distributional semantics. This design enables, for the first time in property-based testing, compositional formal proofs of generator equivalence. We implement a Haskell prototype of Hedgehog→ and demonstrate that it retains sufficient expressiveness to encode practical test generators while providing a rigorous, compositional foundation for reasoning about generator optimizations.