certificate verification

This paper investigates the fundamental trade-off between certificate length and verification time for language verification. Method: We establish the “Verifier Trade-off Theorem”, proving that compressing verification time from $f(n)$ to $g(n)$ necessitates certificates of length at least $Omega(log(f(n)/g(n)))$, yielding a tight lower bound on certificate length. Our approach integrates complexity-theoretic analysis, lower-bound techniques, and verifier algorithm design. Contribution/Results: We construct a natural hierarchy based on certificate complexity, systematically linking certificate length to classical complexity class separations—for the first time connecting, e.g., NP vs. EXPTIME via certificate constraints. Crucially, we show that P vs. NP is equivalent to whether sublinear-length certificates exist for all NP languages. Our framework yields concrete applications—including optimal verification algorithms for string periodicity—and provides unified structural explanations for several long-standing conjectures in computational complexity.

Algebraic proof certificates (e.g., LPACs) suffer from severe size inflation due to redundant derivation steps across distinct variable sets, leading to high verification overhead and poor scalability. To address this, we propose an extension of LPAC featuring the first systematic mechanism for reusing and recycling proof fragments. Our approach introduces two novel inference rules—“fragment extraction” and “fragment application”—enabling efficient compression and reconstruction of linear combination structures. Built upon the practical algebraic calculus framework and incorporating linear-algebraic modeling, our system is fully integrated into the Pacheck 2.0 verifier. Experimental evaluation demonstrates that our method reduces proof size by 42% on average and accelerates verification time by 38%, significantly improving the compactness, verification efficiency, and practical applicability of algebraic proofs.

To address the trustworthiness challenge in verifying multi-objective reachability, invariance, and long-run average rewards simultaneously in Markov decision processes (MDPs), this paper introduces the first logical query framework supporting existential and universal quantification over multiple objectives. Methodologically, we design a certified linear programming–based algorithm that jointly generates independently verifiable mathematical certificates, diagnostic schedulers, and minimal counterexample systems. Our approach transcends conventional single-objective certification by unifying formal correctness guarantees with human-interpretable explanations. The implemented prototype tool demonstrates, across multiple benchmarks, certificate compactness (averaging <5% of the state space), witness inspectability (100% manually verifiable), and computational feasibility on models with up to 10⁶ states.

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.

Formal verification of compilers incurs high maintenance costs, especially when modifications necessitate extensive re-verification. Method: This paper introduces the first trusted rewriting engine framework for Coq, modeling compilers as collections of algebraic rewrite rules—each independently verifiable. It employs theorem-driven modeling, metaprogramming-based automated synthesis, and proof reuse to enable rule-level formal verification and automatic composition. Contribution/Results: The framework decouples rule verification from compiler construction, significantly reducing verification and maintenance overhead. Evaluated in the Fiat Cryptography toolchain, the generated command-line compiler achieves approximately 1000× speedup over prior verified counterparts. Moreover, its proofs are more concise and exhibit substantially higher reusability across compiler transformations.

This work addresses the challenge of efficiently verifying whether an AI agent’s behavior adheres to a prescribed policy without relying on trust in the agent or re-executing its computations. The authors propose a novel paradigm that integrates formal methods with cryptographic proofs: policy specifications are encoded as logical predicates, compiled into polynomial constraints, and used to generate succinct, independently verifiable certificates via Succinct Non-interactive Arguments of Knowledge (SNARKs), optionally with zero-knowledge guarantees. This framework enables an end-to-end transformation from high-level policy statements to verifiable evidence, facilitating trustless compliance auditing and bridging the gap between AI governance, deployment, and formal verification.

This work addresses a central challenge in system security: formally verifying that system designs and implementations satisfy intended safety properties and support security certification. The authors propose a systematic approach grounded in proof assistants, integrating interactive theorem proving and formal methods to precisely model and machine-check critical security properties across diverse domains—including system security, language-level security, secure compilation, and cryptography. By enabling rigorous, machine-verifiable proofs of correctness, this methodology significantly strengthens the formal assurance of security properties and provides a unified theoretical framework and toolchain for constructing verifiable and certifiable secure systems.

This work demonstrates a fundamental limitation of unified formal verification methods within the standard Turing model when applied to nontrivial semantic invariants. By formalizing “acceptable verification schemes” as generator–verifier pairs through a model-theoretic lens, the study integrates Rice’s theorem with formal verification frameworks to prove that such schemes implicitly induce undecidable decision procedures. Crucially, this impossibility stems from the computational behavior inherent to the verification mechanism itself, rather than from unprovable complexity-theoretic assumptions. Leveraging computability theory, model theory, and Coq-based formalization, the authors construct an extended structural model capturing semantic–syntactic interactions and rigorously establish that properties related to P vs NP and cryptographic assumptions such as one-way functions cannot be certified by any such unified method. A complete Coq implementation accompanies the theoretical results.

This work addresses the challenge of efficiently verifying the validity of statistical learning models on a given data distribution without trusting the learner. It introduces publicly verifiable certificates of statistical validity (pvCSVs), establishing the first non-interactive, publicly verifiable proof system for learning that applies to adaptive statistical query (SQ) algorithms. The proposed framework enables any user to verify a model’s performance on their own distribution with a sample complexity of only $O(\log k)$, a significant improvement over the $\tilde{O}(\sqrt{k})$ complexity of standard SQ learning algorithms. This result provides a systematic characterization of the capabilities and limitations of the SQ model in the context of verifiable learning.

This work addresses the lack of formal verification for upper bounds, lower bounds, and exact covering numbers in q-ary covering codes by systematically formalizing their foundational theory in Lean 4. The formalization includes the Hamming ball volume formula, sphere-covering lower bounds, product rules, and exact covering certificates for small instances. We introduce provable certificate predicates to establish an end-to-end pipeline from classical literature results to machine-verifiable proofs, and construct the first proof-carrying database for covering codes that supports automatic replay validation. Our implementation successfully reproduces and verifies selected upper bounds originally established by van Laarhoven et al. (1989), with all bounds accompanied by traceable, auditable Lean proof artifacts, thereby providing a reusable and formally verified foundation for coding theory.