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.

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 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.

First-order Answer Set Programming (ASP) lacks systematic support for modular and parameterized subroutines, hindering structured program design. This work proposes a formal framework for parameterized modular logic programs, introducing for the first time a parameterization mechanism and intensional declarations into modular ASP. By means of precise semantic mappings, it faithfully captures the collective control mechanisms employed in clingo. The approach establishes a theoretical foundation for modular ASP while enabling declarative definition, reuse, and clear semantics for modules. Consequently, it effectively bridges the gap between modularity and traditional ASP, demonstrating strong expressiveness and practical utility in program structuring and instantiation.