type inference

This paper addresses the substitutability challenge in modular development for dependently typed systems. We propose a phase-separated abstraction mechanism that strictly separates interface behavior (public) from algorithmic implementation (private), ensuring library replacements preserve client behavior. Innovatively, we internalize noninterference and disentanglement modal theorems into abstract function construction—first unifying ADT’s public/private layering and computational cost privacy within dependent types. Using phase-sensitive dependent types, modal logic, and phased quotient types, we formally verify—within the single-valued Calf framework—that interface implementations admit free substitution, satisfy behavioral correctness, and guarantee private cost irrelevance. Our approach significantly enhances both expressivity and efficiency of modular verification.

This work addresses the inefficiencies and semantic inconsistencies arising from separately implementing driver and monitor programs in traditional hardware module testing. To overcome this, the authors propose a domain-specific language (DSL) tailored to hardware communication protocols, which enables the unified specification of both driver and monitor logic through an imperative syntax, thereby ensuring their semantic consistency for the first time. Building upon this DSL, they develop a prototype tool that leverages waveform parsing and transaction-level trace inference techniques to accurately reconstruct protocol-compliant transaction sequences from raw signal waveforms. Experimental results demonstrate that the approach significantly improves development efficiency, with further validation planned on real-world interconnect protocols such as Wishbone and AXI-Stream.

This work addresses the challenge of synthesizing modular specifications for client programs that use complex libraries—specifications that must simultaneously satisfy formal verification requirements and be amenable to empirical testing. To this end, the paper introduces a novel form of specification called *contextual contracts* and develops a counterexample-guided learning framework that integrates constraint solving with black-box testing. The approach leverages an ICE-learning-based generalization engine within a CHC (Constrained Horn Clauses) solver to co-synthesize concise, verifiable, and testable contracts for library methods along with inductive invariants. Experimental evaluation demonstrates that the implemented tool, vmtlc, successfully generates effective contracts meeting both verification and testing criteria on real-world client benchmarks.

Concurrent program verification suffers from exponential blowup in proof size due to interleaving-induced complexity. Method: This paper proposes a novel, fully automated method to transform interleaving-dependent correctness proofs into thread-modular Owicki-Gries proofs. It synthesizes ghost variables to abstract critical interleaving behaviors, enabling modular and compact representation of concurrency dependencies. The approach integrates program logic reasoning, abstraction analysis, and ghost variable synthesis to formally extract and reconstruct interleaving information within the Owicki-Gries framework. Contribution/Results: Our method is the first to achieve fully automatic conversion from interleaving-based to thread-modular proofs. Experiments demonstrate substantial reduction in proof size, significant improvement in verification efficiency, and strong verifiability—yielding proofs directly usable for certificate generation in algorithmic verification tools.

Verifying coverage completeness of input generators in property-based testing remains challenging. Method: This paper proposes a static verification approach based on a “must-style” refinement type system, reformulating conventional “may-produce” type semantics into “must-produce” semantics. It formally defines full coverage for higher-order functions and inductive data types, enabling fully automated verification of generator completeness. Contribution/Results: To our knowledge, this is the first refinement type system provably guaranteeing generation of all inputs satisfying both type and constraint specifications. Experimental evaluation demonstrates substantial improvements in detecting coverage gaps across diverse complex generators, while significantly reducing manual verification effort.

This work addresses the high cost of manually writing formal specifications and the limitations of existing large language model (LLM)-based approaches that require white-box access to source code, thereby posing intellectual property and deployment constraints. The authors propose a black-box-driven method that leverages only test code and dynamic execution traces to generate candidate Java Modeling Language (JML) specifications via an LLM. These candidates are locally validated using bounded model checking, and an iterative feedback loop refines them based on verification outcomes. This approach is the first to enable fully automated formal specification generation without any access to the program’s internal structure. Evaluated on the SpecGenBench benchmark, it demonstrates that test-derived information effectively guides specification synthesis, while also highlighting critical challenges in checker compatibility and diagnostic feedback, substantially enhancing industrial applicability.

This work proposes a parameterized information-flow framework that unifies confidentiality and integrity through their joint interaction, leveraging the duality between open and closed modalities in modal type theory. Traditional approaches model these security properties separately, leading to redundant reasoning, complex specifications, and degradation mechanisms that often undermine modularity and abstraction. In contrast, the proposed framework naturally supports downgrading operations without requiring additional extensions, while remaining compatible with strong noninterference guarantees and practical declassification needs. It preserves full noninterference and not only reproduces but also strengthens mechanisms such as robust declassification, demonstrating their complete compatibility with modular design and abstraction.

This work addresses the limitations of existing RTL security verification, which relies on error-prone manual property specification and lacks automated approaches. The paper proposes the first automated framework that integrates the Common Weakness Enumeration (CWE) hierarchy with a large language model (GPT-4.1) to identify security-critical assets and generate SystemVerilog assertions without requiring a trusted specification. By synergistically combining CWE knowledge, LLM-based reasoning, and formal verification via JasperGold, the method successfully detects 27 out of 42 known vulnerabilities in the Hack@DAC SoC benchmark. The generated assertions are executable in 89% of cases and non-vacuous in 92.2%, while also uncovering one previously unknown vulnerability. This approach significantly outperforms manually authored properties, markedly improving the accuracy and effectiveness of hardware security property generation.

This work addresses the challenge of automatically verifying functional correctness of message-passing concurrent programs by proposing a modular approach that reduces program verification to solving constrained Horn clauses (CHCs). The method innovatively integrates prophecy variables with a timestamp mechanism: it models send channels using lists of future messages and captures causal dependencies among channels via timestamps. This approach yields the first fully automatic, modular CHC encoding for Rust-like message-passing programs, ensuring both soundness and completeness while effectively detecting assertion violations. A prototype verifier based on this technique demonstrates strong scalability and verification efficiency across multiple benchmarks.

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.