dependency injection

This paper addresses the challenge of consistently synthesizing a global model from locally interacting components in distributed systems. To this end, it proposes an algebraic modeling and generalization framework based on gate composition. The core methodological innovation is a constant-preserving variant of anti-unification, integrated with rule-driven computation under equational theories, which guarantees termination, correctness, and completeness of the synthesis process. System behavior is modeled as algebraic terms; local views are aligned via gate mechanisms, and local interaction structures are generalized using the proposed anti-unification algorithm to reconstruct a global model satisfying algebraic laws (e.g., associativity, commutativity). Experimental evaluation with a prototype tool demonstrates that the approach effectively recovers semantically consistent global interaction behavior from heterogeneous local models, significantly enhancing composability and verifiability in distributed protocol modeling.

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.

Existing package managers suffer from semantic fragmentation due to language- and operating system-specific differences, making it difficult to precisely express cross-language dependencies, versioned system or hardware requirements, and hindering effective security vulnerability tracking. To address these challenges, this work proposes Package Calculus—the first unified formal model that captures the core mechanisms of mainstream package managers through semantic reduction. Serving as an intermediate representation, Package Calculus enables translation and resolution of dependencies across heterogeneous ecosystems. The model facilitates cross-language and cross-platform dependency interoperability and supports global analysis, thereby establishing a rigorous theoretical foundation and practical pathway for dependency resolution and security research.

This work addresses a key limitation in conventional large language model (LLM)-based program repair approaches, which treat tests as static constraints and often yield under-constrained, fragile, or overfitted patches. To overcome this, the authors propose Agent-CoEvo, a novel framework that models repository-level repair as a co-evolutionary process between code patches and test patches. By leveraging a multi-agent architecture, Agent-CoEvo dynamically refines behavioral constraints through iterative mutual evaluation and semantic recombination, enabling joint evolution of both implementation and specification. The framework is trained and evaluated end-to-end on SWE-bench Lite and SWT-bench Lite, significantly outperforming state-of-the-art agent-based and non-agent baselines in both repair success rate and test reproduction quality.

This work addresses the challenges of ensuring termination, semantic reliability, and completeness for user-defined modules in algebraic simplification libraries. We propose a generic algebraic modeling paradigm based on dependent types, formalizing algebraic structures via free algebras (fral) and variable extensions (frex), and enforcing simplification rules at the type level using dependently typed languages (Idris2/Agda). This guarantees strong normalization, semantic soundness, and completeness under a given equational theory for both built-in and user-defined modules. We introduce a novel “interface–implementation” separation, enabling dual modularity: reuse of foundational infrastructure (term representation, reflection, certification) and compositional nesting of existing simplification modules. We experimentally implement verified simplifiers for monoids and their variants (commutative, involutive), demonstrating feasibility, scalability, and high reusability within real-world theorem-proving environments.

This work addresses the lack of formal guarantees regarding semantic preservation during problem reformulation and solver correctness in constraint programming. It presents the first end-to-end verified framework implemented in the Lean theorem prover, enabling formal proofs of parameterized equivalence, equisatisfiability, and symmetry-breaking correctness for entire families of problems. The approach combines general, parameterized proofs with instance-level certificate checking, thereby eliminating the need to trust external solvers. Verified certificates are produced via backend transformations, and a single high-level proof suffices for arbitrarily large instances. This methodology achieves dramatic search-space reductions—up to a factor of twenty million—and enables full verification of the largest instances in just a few minutes.

This study addresses the inaccuracies inherent in Software Bill of Materials (SBOMs) when characterizing component identities and actual dependencies, particularly their inability to reliably capture code-level hidden dependencies and consistently identify component variants. These limitations lead to inconsistencies between vulnerability reports and Vulnerability Exploitability eXchange (VEX) statements. Through SBOM-driven software composition analysis, evaluation using multiple vulnerability scanners, and consistency checks of VEX assertions, the work systematically reveals significant discrepancies and shortcomings among current mainstream SBOM generation tools in handling these challenges. The findings underscore the need for enhanced mechanisms for dependency representation and component identification, offering critical directions for improving the reliability of vulnerability management practices.

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.

This work addresses the inadequacy of traditional open-source licenses, which rely on auditable relationships between source and object code, in governing Artificial General Intelligence (AGI) systems composed of multidimensional components such as code, data, weights, and hyperparameters. To overcome this limitation, the paper proposes “reproducible builds” as a new Copyleft paradigm for the AGI era, replacing conventional code-sharing logic by ensuring models can be precisely reconstructed from declared inputs. It establishes reproducible builds as a cornerstone of AGI governance, articulates seven technical requirements, and identifies the Model Context Protocol (MCP) as a novel dynamic linking layer necessitating a “protocol-not-platform” governance framework. Integrating OSAID, MOF, OpenMDW, and deterministic inference, the study formulates a technically and legally aligned system enabling bit-accurate model reconstruction, thereby providing both theoretical grounding and practical pathways for AI open-source licensing.

This work addresses the significant disparity in verifiability among semantically equivalent yet structurally diverse programs, a key bottleneck in generating high-assurance software. The authors propose Diversify2Verify, a novel approach that leverages large language models to synthesize diverse recursive and imperative implementations of the same task, integrates the Why3 platform for automatic contract inference and formal verification, and introduces a verifier-guided annotation repair mechanism to enhance verifiability. This study is the first to systematically expose the verifiability gap across equivalent program variants and establishes a new paradigm wherein implementation diversity drives improved verification success. Evaluated on a benchmark of 73 tasks, the method yields 154 verifiable programs after two rounds of repair, with at least one successfully verified variant for 67.1% of the tasks—substantially outperforming baseline approaches.