zkComposer: Decomposing Proof Construction to Scale zkML

A Natively Parallel Proof Framework for Clause-Sharing SAT Solving

Certified but Private: Scalable Zero-Knowledge Proofs for Neural Network Guarantees

PANDA is a scalable system that uses zero-knowledge proofs to prove the robustness and fairness properties of a model without revealing its private parameters, and can generate proofs of local robustness for neural networks with more than 2.9M parameters in 5 minutes, and can verify them in 10 seconds.

Scalable Approach for Zero-Knowledge Proofs (ZKP): Reducing Proving Time with KZG Commitments

Zero-Knowledge Proofs (ZKP) provide strong data privacy and rely on the principle of proving a statement without revealing the underlying data. However, the ZK-SNARK system has a scalability problem while generating proofs. Systems like PLONK take longer to generate a proof with increasing size of the input data. EHR(Electronic Health Records) may present a short proving time but large size data sine when they contain images and genomics it could take more time to generate a proof. ZK-Rollup systems provide scalability by batching the transactions in off-chain mode; however, they also suffer from longer proving time with large data. In this paper, we propose an approach to generate KZG commitments from healthcare FHIR records and then use these values to generate single validity ZKP. In this way, we can not only reduce the proving time, but also ensure data integrity and data correctness.

ShannonProver: Towards Automating Formal Cryptographic Proofs

Cryptographic proofs are produced at a scale that increasingly exceeds the community's ability to verify them manually. Machine-checked proofs offer a path toward scalable proof verification, but writing proof scripts for expressive proof assistants such as EasyCrypt remains a major bottleneck: even when the high-level proof plan is known, converting it into proof tactics requires substantial reasoning effort. This paper presents ShannonProver, an agentic framework for automating cryptographic proofs. ShannonProver targets the setting in which a cryptographer provides the security model and a decomposition of the target theorem into lemma-level proof obligations, while the system automatically constructs EasyCrypt proof scripts for those obligations. We evaluate ShannonProver on a dataset of formal cryptographic proofs in EasyCrypt. The dataset spans textbook primitives, deployed protocols, and standardization efforts such as NIST proposals, and includes expert case studies drawn from a corpus that has not previously been available online. We show that ShannonProver can automate substantial portions of cryptographic proof engineering for case studies such as ChaChaPoly1305 and MEE-CBC. More broadly, this work suggests a path toward accelerating cryptographic research: as agents automate the proof-engineering burden, cryptographers can iterate more quickly on new constructions, obtain machine-checked assurance earlier, and bring trustworthy protocols from design to deployment faster.

Rethinking Execution Granularity for Heterogeneous Zero-Knowledge Proof Provers

Zero-knowledge proofs (ZKPs) are increasingly used in blockchain systems, privacy-preserving applications, and verifiable cloud computation, but their practical deployment is still constrained by the cost of proof generation. This cost is especially important when proof generation is provided as a cloud-side service, where prover latency directly affects service throughput and resource efficiency. Existing heterogeneous provers mainly follow an operator-centric design, offloading selected GPU-friendly kernels while leaving the overall proving pipeline fragmented across fine-grained execution boundaries. This approach is effective at reducing the cost of major operators, but it also changes the bottleneck structure of modern proving: once dominant kernels are accelerated, end-to-end inefficiency increasingly arises from fragmented cross-stage execution, including host-device transitions, intermediate-state materialization, and CPU-side coordination overhead. In this paper, we argue that the key systems problem is no longer simply which operator to accelerate next, but what the right runtime execution unit should be for heterogeneous ZKP proving. To this end, we propose region-centric execution, a locality-aware runtime abstraction that groups tightly dependent computations into larger execution units based on dependency locality, state continuity, and boundary cost. Building on this abstraction, we design execution mechanisms that preserve deviceresident state, delay unnecessary materialization, coordinate dependent computations within a region, and reduce excessive boundary crossings. We implement our design on top of a Plonky2-based GPU prover and evaluate it on four representative workloads. Region-centric execution improves end-to-end proving performance by $1.36 \times$ on average and up to $1.52 \times$ over an operator-centric baseline, with the gains coming primarily from lower coordination overhead and reduced host-device transfer cost rather than uniformly faster GPU kernels.

ITPEval: Benchmarking Formal Translation Across Interactive Theorem Provers

ITPEval is presented, the first benchmark for evaluating automated formal proof translation across four major ITPs (Lean 4, Rocq, Isabelle, and HOL Light), spanning two distinct logical foundations and itpeval, a unified multi-ITP verification infrastructure with state-isolated warm backends that preserve per-artifact native checking semantics.