compositional modeling

Model checking temporal properties of safety-critical embedded C programs faces significant challenges due to the difficulty of constructing accurate, tractable abstractions manually. Method: This paper proposes an automated abstraction modeling approach grounded in verified component contracts. It directly translates state-transition contracts into language-agnostic flow graphs (FGs), integrating static analysis and abstract interpretation to achieve lightweight, high-fidelity abstraction. Contribution/Results: The work establishes, for the first time, a formal semantic mapping from contracts to flow graphs, enabling compositional model checking and drastically reducing manual abstraction effort. Experiments on real-world safety-critical C code demonstrate fully automated construction of high-precision abstract models. The approach improves feasibility, efficiency, and scalability of timing property verification and has been integrated into an end-to-end prototype toolchain.

This work addresses the lack of structural correctness verification during the design phase in existing AI agent workflow platforms, which typically rely on runtime safeguards. The authors propose a workflow modeling approach centered on reusable building blocks and introduce, for the first time, a set of twelve structural rules. By leveraging graph-based representations and a rule engine, the method enables static, formal checks for compatibility and logical consistency at design time. Experimental evaluation demonstrates that the prototype system efficiently detects design violations on a dataset comprising 48 defective workflows and 168 structural variants, maintaining high detection accuracy even when tasks are split across multiple agents. This significantly enhances the reliability and maintainability of workflow designs.

Traditional formal verification lacks mechanisms for knowledge accumulation and cross-system reuse, making it difficult to transfer specifications, contracts, and proofs. This work proposes a novel paradigm that integrates artificial intelligence with formal methods, pioneering the combination of large language models and graph-based representations to enable semantic guidance across heterogeneous notations and abstraction levels. By leveraging automated contract synthesis, semantic artifact reuse, and compositional refinement theory, the authors construct a hybrid reasoning framework that ensures formal reliability while supporting continuous synthesis and migration of verification artifacts. This approach lays the foundation for a cumulative and evolvable verification ecosystem, paving the way toward scalable, knowledge-driven next-generation verification systems.

Comprehensive probabilistic verification of learning-driven cyber-physical systems (CPS) remains challenging due to black-box components and complex, realistic operational environments. Method: This paper proposes a compositional probabilistic verification framework built on the Scenic language for component-based modeling. It integrates assume-guarantee contracts with a composable evidence fusion operator, and incorporates Lean 4 formal verification, an extended Linear Temporal Logic (LTL) semantics, test-driven evidence generation, and external assumption importation. Contribution/Results: The framework enables hierarchical, traceable, and trustworthy assurance from components to full-system level. Evaluated on an autonomous emergency braking system, targeted testing under uncertainty—under identical computational budgets—significantly strengthens probabilistic guarantees, demonstrating both efficacy and practicality.

This work addresses the challenges of transferability and computational feasibility in discrete abstraction for symbolic model checking of cyber-physical systems by proposing a conservatism-first, four-step modular workflow to construct finite-state abstractions of closed-loop dynamical systems. The approach integrates state partitioning, conservative transition construction, spurious behavior elimination, and specification semantics lifting, enabling composable and replaceable subroutine design. Transition relations are built using axis-aligned bounding boxes, polyhedra, and sampling with PAC coverage certificates, combined with certified erasure and counterexample-guided refinement. Reliable lifting of LTL specifications is achieved through may–must semantics. Evaluation across three case studies demonstrates that the workflow effectively balances abstraction accuracy and verification efficiency while clearly revealing the impact of different design choices on the outcomes.

End-to-end security verification remains challenging in modern safe languages (e.g., Rust) due to the coexistence of safe and unsafe modules, which undermines compositional reasoning and hinders holistic assurance. Method: We propose the “Open Safety” theoretical framework, formalizing composable security via open-labeled transition systems; it enables modular, heterogeneous verification—separately verifying safe and unsafe components—and target-level composition. The framework unifies verified compilation and verification-aware compilation, integrating separation logic, ownership types, and verified compilation techniques to support progressive derivation from partial to full safety. Contribution/Results: We implement a verified compiler for Owlang—a custom Rust-like language—and evaluate it on an Owlang/C hybrid hash table case study. Our approach demonstrates both effectiveness—achieving end-to-end security guarantees—and scalability—supporting cross-language, mixed-safety module composition—thereby advancing practical, compositional security verification for systems programming languages.

This work addresses the challenge of ensuring safety, reliability, and trustworthiness in collective adaptive systems operating in dynamic environments by proposing a modular design paradigm centered on intrinsic trustworthiness. The approach integrates a runtime model based on local causal event sequences, a temporal logic verification technique supporting modular architectures, and a compositional reasoning mechanism for global system properties grounded in component attributes. Through this tripartite framework, the study overcomes key limitations of conventional formal methods and demonstrates substantial improvements in verifiability and scalability in case studies, thereby establishing both a theoretical foundation and a practical pathway for engineering highly trustworthy collective adaptive systems.

Current approaches to automated program synthesis lack effective governance mechanisms to ensure the compliance of generated code. This work proposes Protocol-Driven Development (PDD), a model that treats machine-executable protocols as primary artifacts and delineates the space of valid implementations through structural, behavioral, and operational invariants. PDD mandates that every implementation be accompanied by a verifiable chain of compliance evidence. By integrating formal methods, property-based testing, policy-as-code, and software provenance techniques, PDD establishes a unified framework for protocol specification and verification. This framework enables trustworthy admission control over automatically synthesized code, guaranteeing that all adopted implementations strictly adhere to protocol constraints and are backed by complete, auditable proofs of compliance.