contract specification

This work addresses the asymmetric control challenge in intelligent security systems, where strong adversarial capabilities must be preserved within authorized boundaries yet strictly constrained beyond them. To this end, the paper introduces an Alignment Contract Framework that, for the first time, formally models behavioral boundaries as observable-effect-based contracts. The framework employs formal specifications of scope, permitted/prohibited effects, resource budgets, and disclosure policies, integrated with finite-trace semantics and safety property characterizations to support contract refinement and unidirectional composition. Core decidability theorems are formally verified in Lean 4. An instantiation in web security workflows demonstrates enforcement correctness of monitored execution under the assumption of effect observability, establishes undecidability boundaries, and enables modular engineering and cross-task transfer.

Smart contracts exhibit extremely low fault tolerance due to code immutability, and existing formal verification approaches suffer from limitations in semantic expressiveness and reasoning capability for specification modeling. Method: Through a systematic literature review, this work integrates model checking, theorem proving, and static analysis, and—novelty—introduces description logic (DL) into smart contract formal verification for the first time. It constructs a new verification framework that combines strong semantic expressiveness with decidable reasoning support, and proposes a cross-tool, cross-platform verification methodology. A taxonomy-based evaluation framework for mainstream verification tools is also established. Contribution/Results: Comparative experiments demonstrate that DL significantly improves the accuracy, scalability, and automation potential of specification modeling. The framework establishes a new paradigm for high-assurance smart contract development, enabling more rigorous, interoperable, and practically deployable verification workflows.

This work addresses the challenges of repairing deployed smart contracts and the limited expressiveness of existing formal methods in modeling multi-party liability allocation. To overcome these limitations, the authors propose a formal modeling approach based on Relativized Contract Language (RCL) and the RECALL verification tool, which precisely captures the responsibilities of multiple parties and automatically detects and resolves specification conflicts during the modeling phase. The method then generates Solidity code directly from the verified model and validates its functionality within the Remix IDE. Experimental results demonstrate that this approach significantly enhances the logical consistency, reliability, and security of smart contracts, thereby underscoring the critical value of upfront formal verification in the development of complex contractual systems.

Long commercial contracts—such as Share Purchase Agreements (SPAs)—suffer from excessive verbosity, undetected logical inconsistencies, and difficulties in verifying execution feasibility. Method: This paper proposes the first automated consistency verification framework for SPAs, grounded in a domain-specific ontology and decidable first-order logic (FOL) constraints. It integrates ontology-based modeling, structured natural language (blocks) encoding, and SMT-solvable assertion generation to achieve end-to-end translation from unstructured text to formal constraints, followed by satisfiability checking via solvers like Z3. Contribution/Results: It is the first work to combine a domain ontology with decidable FOL for SPA consistency verification; supports generating either a satisfying model or an infeasibility proof; and demonstrates effectiveness on real-world SPAs, significantly improving review efficiency and reliability.

This paper addresses hyperproperties—higher-order system requirements encompassing information-flow security, knowledge reasoning, and robustness, which span multiple execution traces—by proposing the first unified logical and algorithmic framework covering the entire verification lifecycle. Methodologically, it rigorously characterizes the expressive power and decidability boundaries of classical temporal logics (LTL, CTL, S1S) over hyperproperties; then introduces a novel multi-trace synchronization modeling and quantifier alternation handling mechanism grounded in higher-order temporal logic, constraint solving, and symbolic automata. Key contributions include: (i) a comprehensive taxonomy and complexity-theoretic characterization of hyperproperty logics; (ii) an open-source verification toolchain supporting HyperLTL and HyperCTL*; and (iii) end-to-end support for core verification tasks—including satisfiability checking, model checking, runtime monitoring, and controller synthesis.

This work addresses the inconsistent behavior of machine learning kernels across heterogeneous hardware and the absence of formal specifications defining their correctness boundaries. We propose the first contract-based specification language tailored for ML kernels, which employs an eight-component structure to precisely articulate behavioral expectations and encompasses twelve failure modes—including numerical precision errors, ordering violations, compiler-induced discrepancies, and outlier handling. Our framework integrates reference oracles, tolerance definitions, measurement protocols, and violation signatures into a cohesive kernel contract architecture, augmented by a three-state calibration mechanism to ensure contract validity. The approach has been successfully applied to real-world cases such as Huawei Ascend inconsistencies, Sakana AI’s CUDA engineer reward attacks, and AMD out-of-bounds memory accesses, enabling precise mapping of informal diagnostic observations to testable contract violations.

This work addresses the challenge of verifying temporal safety contracts for synchronous programs, which involve global properties spanning multiple clock cycles and are not amenable to direct handling by conventional deductive verification tools. The authors present Kairos, a novel toolchain that, for the first time, automates the generation of tick-indexed Why3 proof obligations from synchronous programs paired with assume-guarantee contracts expressed in Linear Temporal Logic (LTL). Their approach leverages automata theory by compiling LTL specifications into bad-state automata and constructing their product with the program. The correctness of this framework is formally mechanized in Rocq. Experimental evaluation successfully verifies a medical infusion controller, demonstrating that under given environment assumptions, every input trace induces a unique execution satisfying the temporal guarantees—highlighting the method’s effectiveness in supporting temporal contracts for reactive systems.

This work proposes a method for formally verifying that CPUs satisfy hardware–software contracts—thereby ensuring high-level programs are secure against side-channel attacks—without requiring explicit modeling of microarchitectural details. The core insight is to abstract contract satisfaction as relative trace equivalence and introduce relative bisimulation as the underlying proof technique. Building on coinductive reasoning, we develop the first mechanizable, sound, and complete deductive proof system that supports modular and incremental interactive verification, implemented in the Rocq proof assistant. The system has been successfully applied to verify two complex contracts, demonstrating the approach’s effectiveness, scalability, and novelty.

This work addresses the challenge of reliably conveying intent, requirements, and constraints in human–AI–tool collaborative software development by proposing a specification-centric Bosque API (BAPI) ecosystem. The system introduces a highly expressive specification language that, for the first time, enables cross-language interoperability, automated test generation, formal verification, and execution sandboxing across the entire API lifecycle—from requirement definition and implementation to invocation and validation. By providing end-to-end specification guarantees, BAPI significantly enhances system correctness, security, and the efficiency of human–AI collaboration, offering a novel infrastructure for software development in the era of AI agents.

Existing formal methods incur high costs in specification construction and maintenance and lack scalability, making them ill-suited for verifying modern AI systems. This work proposes a Learning-Integrated Formal Reasoning (LIFR) framework that innovatively combines machine learning with formal verification: it employs natural language processing to automatically generate contracts, leverages graph matching and representation learning to achieve semantic alignment and cross-system reuse of verification artifacts, and establishes a rigorous semantic foundation grounded in Unifying Theories of Programming (UTP) and institution theory. By shifting formal verification from isolated proofs toward a cumulative, knowledge-driven paradigm, the LIFR framework substantially enhances automation and scalability while preserving formal rigor.