# Zero-knowledge proof

Zero-knowledge proof is a cryptographic protocol in which a prover convinces a verifier that a statement is true without revealing information beyond its truth.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Correctable Enrollment and One-Transaction Seed Proofs for Ethereum's Post-Quantum Transition

DevFeed: [Correctable Enrollment and One-Transaction Seed Proofs for Ethereum's Post-Quantum Transition](<https://devfeed.tech/articles/correctable-enrollment-and-one-transaction-seed-proofs-for-ethereum-s-post-quantum-transition-146042.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25663>)

Author: Xin Jin, Maximillian Liao, Handong Chen, Yi Nancy Li, Junyu Liu

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [ecdsa](<https://devfeed.tech/tags/ecdsa.md>), [ethereum](<https://devfeed.tech/tags/ethereum.md>), [key](<https://devfeed.tech/tags/key.md>), [keys](<https://devfeed.tech/tags/keys.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [machine](<https://devfeed.tech/tags/machine.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [quant-ph](<https://devfeed.tech/tags/quant-ph.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [space](<https://devfeed.tech/tags/space.md>), [sponsor](<https://devfeed.tech/tags/sponsor.md>), [time](<https://devfeed.tech/tags/time.md>), [transaction](<https://devfeed.tech/tags/transaction.md>)

### AI overview

The proposal lets Ethereum account owners enroll post-quantum keys with existing signatures before ECDSA retirement, then correct enrollments by a shared post-retirement deadline using a zero-knowledge proof of the wallet's BIP-39 seed. Accounts never enrolled remain frozen but recoverable by seed proof without a deadline. Proofs bind the new key, nonce, and fee cap; validators switch to hash-based keys at a finalized checkpoint under a stated bound on attacker voting power. The authors report formal guarantees under explicit assumptions, model checking, and implementations in go-ethereum and a Lean consensus client. Their recursive hash-based STARK seed proof is about 190 KB, verifies in 38 ms, and takes a median 111 seconds to generate on a laptop; four proofs can be aggregated. In a ten-node simulation, block space constrained migration: 4.45 million accounts with at least 0.1 ETH took an estimated 29.4 days to enroll before retirement or 235 days to recover afterward in batches of four. During mass enrollment, public-mempool waiting had a 19.1-minute median, exceeding published estimates for a fast quantum computer to extract a key.

### Source excerpt

arXiv:2611.25663v1 Announce Type: new Abstract: A quantum computer running Shor's algorithm can extract the private key of every Ethereum account whose public key is published, and accounts exposed by their own transactions hold 54.6% of execution-layer ETH. As the first such machine may stay secret, a migration cannot wait for visible thefts, and once keys are extractable, legacy signatures no longer tell owners from attackers. We design a migration in which owners enroll post-quantum keys cheaply with their existing signatures before ECDSA is retired at a scheduled time, while a zero-knowledge proof of the wallet's BIP-39 seed can correct any such enrollment until a common deadline afterward; an account nobody enrolled stays frozen and recoverable by seed proof without a deadline. Each proof binds the new key, a nonce and a fee cap, so neither a paying sponsor nor a reordering block builder can redirect or replay it. Validators switch to hash-based keys first, at a finalized checkpoint and under a stated bound on the attacker's voting power. We prove the account guarantees under explicit assumptions, model-check the rules, and implement the design in go-ethereum and a Lean consensus client. A three-layer recursive hash-based STARK yields a seed proof of about 190 KB that fits one transaction, verifies in 38 ms and takes a median of 111 s to generate on a laptop; four proofs aggregate into one. In a ten-node simulation with mainnet-derived accounts and fee demand, block space rather than proving sets the duration: the 4.45 million accounts with at least 0.1 ETH would migrate in 29.4 days if all enroll before ECDSA is retired and in 235 days if all recover after it in batches of four. In a mass enrollment, an enrollment waits a median of 19.1 minutes in the public mempool, longer than published estimates for a fast quantum computer to extract its key, so owners with a seed and an unexposed key should migrate by seed proof.

## Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows

DevFeed: [Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows](<https://devfeed.tech/articles/threshold-choice-not-sample-size-bounds-trustless-verification-of-nondeterministic-compound-ai-workflows-143107.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.10601>)

Author: Alper Alimoglu

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-workflows](<https://devfeed.tech/tags/ai-workflows.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [verification](<https://devfeed.tech/tags/verification.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

The protocol commits digests of each workflow stage's inputs, outputs, and context under a policy fixing the metric and threshold, anchors them without trusting the executing node, defers decisions during network partitions, and evaluates challenges using the median of k re-executions without a quorum. On a synthetic HotpotQA pipeline, a calibrated fixed threshold accepted 44/45 honest reproductions and rejected 104/105 divergent pairs, but allowed same-input fabrication in 27/29 trials at k=5. Increasing samples did not solve that problem. With the metric and re-execution spread held fixed, a threshold derived per execution detected 19/29 fabrications, versus 9/29 for the best constant threshold with the same zero honest rejections at k=5. The derived rule rejected no honest commitments at k=5, compared with 3/15 at k=3, and caught 11/15 trials by an attacker targeting it. The rule was measured, not deployed.

### Source excerpt

arXiv:2609.10601v2 Announce Type: replace Abstract: Compound AI pipelines chain LLM calls, retrievers, and tools and are nondeterministic: sampling, model updates, and volatile tool responses make one input yield different outputs across runs. Such pipelines increasingly run across edge, cloud, and orbital nodes owned by no single party, whose optimizations discard intermediate results before inspection. Verifying reproduction there means tolerating nondeterministic outputs, a node that may not report honestly, and intermittent access to any shared record; existing work addresses at most two at once. We give a protocol covering all three: it commits digests of each stage's inputs, outputs, and context under a policy digest pinning the metric and threshold, anchors them without trusting the executing node, defers under partition, and decides a challenge on the median of $k$ re-executions, with no quorum. Where that procedure breaks is the main result. On a synthetic HotpotQA pipeline a calibrated fixed threshold accepts 44 of 45 honest reproductions and rejects 104 of 105 divergent pairs, yet lets same-input fabrication through in 27 of 29 trials at k=5, more samples being no help since sampling sharpens an estimate without moving it. Holding that metric and this pipeline's re-execution spread fixed, the binding constraint is the threshold rather than the sample size: one derived per execution detects 19 of 29 where the best constant matched to the same zero honest rejections reaches 9, rejects no honest commitment at k=5 though 3 of 15 at k=3, and catches 11 of 15 of an attacker built against it, which has to aim at a target drawn only after its commitment exists. That rule is measured rather than deployed.

## Incrementally Verifiable Oracle Aided Computation

DevFeed: [Incrementally Verifiable Oracle Aided Computation](<https://devfeed.tech/articles/incrementally-verifiable-oracle-aided-computation-133279.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14698>)

Author: Shafi Goldwasser, Yael Kalai

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [completeness](<https://devfeed.tech/tags/completeness.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [lwe](<https://devfeed.tech/tags/lwe.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [private](<https://devfeed.tech/tags/private.md>), [robust](<https://devfeed.tech/tags/robust.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Under the LWE assumption, the paper builds incrementally verifiable computation (IVC) for computations that rely on external oracles by constructing SNARGs and extending them to IVC. For bounded-space robust computations, where false accepting executions contain at least an ε-fraction of incorrect oracle answers, it gives privately verifiable schemes with parameters, keys, and proofs of length poly(k,S,log T,1/ε) and O(k/ε) verifier oracle calls. A lower bound rules out deterministic publicly verifiable schemes with both public parameters o(n) and fewer than o(Q) verifier oracle queries. For digitally signed oracles, it gives publicly verifiable schemes without a robustness assumption and with oracle-free setup and verification; lengths are poly(k,S,log T). For deterministic computations with short queries and answers, the S dependence is removed. The constructions claim adaptive completeness and soundness.

### Source excerpt

arXiv:2611.14698v1 Announce Type: new Abstract: Incrementally verifiable computation (IVC) allows a prover to maintain a short proof that can be efficiently updated after each computation step, without retaining or recomputing the preceding execution. Standard IVC schemes do not directly address a crucial feature of AI tasks: their dependence on external information and expertise. We construct IVC schemes for oracle-aided computations under the LWE assumption by first constructing SNARGs, and then extending them to IVC. We consider the following two settings, where below, k is the security parameter, n is the input length, and T, S, and Q are the time, space, and oracle-query bounds. 1. Robust computations: For bounded-space computations, including non-deterministic computations, in which every accepting purported execution on a false input contains at least an eps-fraction of incorrect oracle answers, we construct privately verifiable SNARGs and IVC. Public parameters, private verification keys, and proofs have length poly(k ,S, log T,1/eps), and verification uses O(k/eps) oracle calls. We complement this result with a lower bound ruling out (deterministic) publicly verifiable SNARGs and IVCs with public parameters of length o(n), and o(Q) verifier oracle queries. 2. Signed oracles: For oracles that digitally sign their query-answer pairs, we construct publicly verifiable SNARGs and IVC without a robustness assumption, and with oracle-free setup and verification. Public parameters and proofs have length poly(k,S,log T). For deterministic computations with oracle query and answer lengths poly(k,log T), we remove the dependence on S, obtaining public parameter and proof lengths poly(k,log T). All our constructions have adaptive completeness and soundness.

## VRMaaS: Verifiable Reward-Model-as-a-Service for Trustworthy LLM Alignment

DevFeed: [VRMaaS: Verifiable Reward-Model-as-a-Service for Trustworthy LLM Alignment](<https://devfeed.tech/articles/vrmaas-verifiable-reward-model-as-a-service-for-trustworthy-llm-alignment-133290.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14984>)

Author: Guofu Liao, Hailang Xi, Taotao Wang, Shengli Zhang, Rongcheng Tu, Hao Liao

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>)

Tags: [alignment](<https://devfeed.tech/tags/alignment.md>), [attestation](<https://devfeed.tech/tags/attestation.md>), [audit](<https://devfeed.tech/tags/audit.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [framework](<https://devfeed.tech/tags/framework.md>), [governance](<https://devfeed.tech/tags/governance.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [inference](<https://devfeed.tech/tags/inference.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [llm](<https://devfeed.tech/tags/llm.md>), [model-as-a-service](<https://devfeed.tech/tags/model-as-a-service.md>), [reward](<https://devfeed.tech/tags/reward.md>), [serving](<https://devfeed.tech/tags/serving.md>), [transformer](<https://devfeed.tech/tags/transformer.md>)

### AI overview

VRMaaS treats reward-model service integrity as more than proving inference: a score must be tied to its request, committed weights, verifier and configuration identifiers, proof-task order, and exported-package digest. Its proof-carrying artifacts let auditors verify rewards without rerunning the private model or exposing inputs, checkpoints, or hidden activations; an optional on-chain zero-knowledge wrapper attests selected consistency checks and supplied fields. A GPU prototype on 1B, 3B, and 8B models and 128-1024 tokens achieved 93.5-99% pairwise agreement with the baseline and rejected all tested service-field substitutions in complete artifacts. Artifact generation took 49.8-206.1 seconds, retained-artifact verification 1.94-5.11 seconds, and partial public attestation about 217K gas. The authors position these costs for delayed audit, settlement, and governance.

### Source excerpt

arXiv:2611.14984v1 Announce Type: new Abstract: Reward models (RMs) are increasingly deployed as service components in LLM alignment pipelines, where payment, audit, moderation, and governance workflows act on the scores they return. An inference proof alone does not show whether a score belongs to the intended request, model checkpoint, numerical configuration, and verifier: in a controlled comparison that isolates the accepted statement from prover scale, a generic inference proof wrapped for on-chain checking remains valid after six classes of such service-field substitution. We formulate verifiable reward-model-as-a-service (VRMaaS) as a service-output integrity problem and present a framework in which each returned reward becomes a proof-carrying artifact. Its off-chain acceptance rule binds request identity, committed weights, verifier and configuration identifiers, proof-task order, and the digest of the exported package, so auditors can check a reward without rerunning the private RM or exposing inputs, checkpoints, or hidden activations; an optional on-chain zero-knowledge wrapper gives contracts a partial attestation of selected consistency checks and supplied service fields. The framework decomposes Transformer RM serving into arithmetic and lookup-backed proof tasks, aggregates them into a composite proof, and links hidden operands to the committed weights. A GPU prototype on 1B, 3B, and 8B reward models over 128-1024 tokens preserves 93.5-99% pairwise agreement with the baseline RM and rejects every tested service-field substitution in complete artifacts. Using exact integer witnesses and request-level aggregation of weight-binding openings, it generates complete artifacts in 49.8-206.1 seconds across the evaluated settings; auditors verify retained artifacts in 1.94-5.11 seconds, and partial public attestation costs about 217K gas. These costs suit delayed audit, settlement, and governance workflows.

## Infrastructure for Verifiable AI: Where Proof Costs Go and How Hardware Can Help

DevFeed: [Infrastructure for Verifiable AI: Where Proof Costs Go and How Hardware Can Help](<https://devfeed.tech/articles/infrastructure-for-verifiable-ai-where-proof-costs-go-and-how-hardware-can-help-133167.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17042>)

Author: Yihan Xia, Wenxin Xu, Taotao Wang

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Fine-tuning](<https://devfeed.tech/topics/fine-tuning.md>), [synchronization](<https://devfeed.tech/topics/synchronization.md>)

Tags: [acceleration](<https://devfeed.tech/tags/acceleration.md>), [accelerators](<https://devfeed.tech/tags/accelerators.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-workloads](<https://devfeed.tech/tags/ai-workloads.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [chips](<https://devfeed.tech/tags/chips.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [custom](<https://devfeed.tech/tags/custom.md>), [effect](<https://devfeed.tech/tags/effect.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [framework](<https://devfeed.tech/tags/framework.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [inference](<https://devfeed.tech/tags/inference.md>), [verifiable-ai](<https://devfeed.tech/tags/verifiable-ai.md>)

### AI overview

The paper finds that the cost of proving neural-network workloads depends on the proof system and input length, so hardware choices and optimizations should be matched to each workload's measured bottlenecks. Its four-layer framework connects workloads, proof systems, cryptographic kernels and hardware; measurements cover six provers and seven kernels. In low-rank fine-tuning, opening commitments to fixed weights costs nearly the same for input lengths 64-2048, while intermediate-value work grows. A 13-billion-parameter configuration exceeds a 40 GB GPU's capacity but runs on an 80 GB device. Profiling also finds instruction-issue and synchronization limits that bandwidth-only models miss. The authors identify proof-friendly numeric formats, reuse of fixed-weight commitments, heterogeneous execution and shared benchmarks as research directions. This is an abstract-level account; it does not provide detailed comparative results for each hardware type.

### Source excerpt

arXiv:2611.17042v1 Announce Type: cross Abstract: Users of artificial intelligence services, including those powered by large language models and other transformer-based models, need assurance that inference and training follow the declared computation without exposing private models or data. Zero-knowledge proofs can provide this assurance, but proof generation remains expensive. Hardware acceleration research often reports gains for individual cryptographic operations, leaving their effect on the full cost of proving neural-network workloads, particularly large transformer models, unclear. We introduce a four-layer framework linking verifiable AI workloads, proof systems, cryptographic kernels and hardware platforms, use it to review the literature, and add original measurements of six provers and seven kernels to identify which costs matter in practice. Our measurements show that the dominant cost changes with the proof system and input length. In low-rank fine-tuning, the cost of opening commitments to fixed model weights remains nearly constant across input lengths from 64 to 2048, while the work associated with intermediate values grows. A 13-billion-parameter fine-tuning configuration exceeds the capacity of a 40-gigabyte graphics processor but completes on an 80-gigabyte device, showing why capacity must be assessed alongside execution time. Our kernel profiling further identifies instruction issue and synchronization limits that a bandwidth-only model misses. We use these findings to assess graphics processors, reconfigurable logic, custom chips and existing artificial intelligence accelerators. The resulting research agenda connects proof-friendly numeric formats, reuse of fixed-weight commitments, heterogeneous execution and shared benchmarks to the measured bottlenecks. Effective acceleration requires selecting hardware and proof-system optimizations around the cost profile of the target workload.

## Sable: A Small-Field Sumcheck Argument for Bit-Exact Inference of Large Language Models

DevFeed: [Sable: A Small-Field Sumcheck Argument for Bit-Exact Inference of Large Language Models](<https://devfeed.tech/articles/sable-a-small-field-sumcheck-argument-for-bit-exact-inference-of-large-language-models-128396.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14083>)

Author: Tomer Solberg

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [qwen](<https://devfeed.tech/topics/qwen.md>), [Mixture of Experts (MoE)](<https://devfeed.tech/topics/mixture-of-experts-moe.md>)

Tags: [1-6](<https://devfeed.tech/tags/1-6.md>), [1-7](<https://devfeed.tech/tags/1-7.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [all](<https://devfeed.tech/tags/all.md>), [argument](<https://devfeed.tech/tags/argument.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [batches](<https://devfeed.tech/tags/batches.md>), [bf16](<https://devfeed.tech/tags/bf16.md>), [blackwell](<https://devfeed.tech/tags/blackwell.md>), [blackwell-gpu](<https://devfeed.tech/tags/blackwell-gpu.md>), [blake3](<https://devfeed.tech/tags/blake3.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [field](<https://devfeed.tech/tags/field.md>), [inference](<https://devfeed.tech/tags/inference.md>), [language](<https://devfeed.tech/tags/language.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large](<https://devfeed.tech/tags/large.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [models](<https://devfeed.tech/tags/models.md>), [small](<https://devfeed.tech/tags/small.md>)

### AI overview

Sable proves bit-for-bit that a committed, integer-quantized transformer produced a token sequence from a prompt, using an integer-only function and constraints designed to avoid wraparound in the 31-bit KoalaBear field. Its prover streams layers on one GPU and combines batched zerochecks and LogUp-GKR lookups in sumchecks, with a single multilinear commitment for weights and witness tensors. On an RTX PRO 6000 Blackwell, it proves Qwen2.5-32B inference in 92.5 seconds for 4,096 tokens and 398 seconds for 16,384; 4,096-token proofs take 121.8 seconds for Qwen3-32B and 84.7 seconds for Qwen3-30B-A3B. Proof generation costs 41-50 times serving time; verification takes 19-56 seconds on one CPU core. The quantized function's greedy tokens match BF16 at 86.3% of WikiText-2 positions, and its Qwen3 scores are within 1.6 points on MMLU and 1.7 on GSM8K. The proof is not zero-knowledge, so the system targets open-weight models.

### Source excerpt

arXiv:2611.14083v1 Announce Type: cross Abstract: We present Sable, an argument system and single-GPU prover for the statement that a committed, integer-quantized transformer produced a given token sequence from a given prompt, bit for bit. Sable fixes an integer function F_O with no floating-point step, in which every rounding, normalization, softmax and sampling decision is determined by its inputs, and proves it with a constraint system whose relations provably never wrap modulo the 31-bit KoalaBear prime. The proof batches zerochecks and LogUp-GKR lookups into one sumcheck per domain, and commits to every witness tensor and weight in one multilinear commitment built from Reed-Solomon codes, BLAKE3 Merkle trees and a mixed-length BaseFold opening. The prover streams the model layer by layer on one GPU. On one NVIDIA RTX PRO 6000 Blackwell GPU, Sable proves all 64 layers of Qwen2.5-32B in 92.5 s for 4,096 tokens and 398 s for 16,384 tokens, and covers Qwen3-32B and the mixture-of-experts Qwen3-30B-A3B (4,096 tokens in 121.8 and 84.7 s). A proof costs 41 to 50 times the serving time, or 6.4 cents per 4,096-token request at public GPU prices, and 40 to 64 times less time per parameter and token than zkLLM. On WikiText-2, F_O's greedy token matches the BF16 model's at 86.3% of positions; on Qwen3, F_O is within 1.6 points of BF16 on MMLU and 1.7 points on GSM8K. A verifier with a compiled core checks a proof on one CPU core in 19 to 56 s. In the random-oracle model, the interactive proof has round-by-round soundness error 2^-103. The proof is not zero-knowledge, so the system targets open-weight models. Code: https://github.com/moonmath-ai/Sable

## Verifiable, Privacy-Preserving and Collaborative Multi-Objective Optimization with NSGA-II on Blockchain

DevFeed: [Verifiable, Privacy-Preserving and Collaborative Multi-Objective Optimization with NSGA-II on Blockchain](<https://devfeed.tech/articles/verifiable-privacy-preserving-and-collaborative-multi-objective-optimization-with-nsga-ii-on-blockchain-126729.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11567>)

Author: Goshgar Can Ismayilov

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Blockchain](<https://devfeed.tech/topics/blockchain.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Operations research and optimization](<https://devfeed.tech/topics/operations-research-and-optimization.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [virtual-machine](<https://devfeed.tech/tags/virtual-machine.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>), [zero-knowledge-proof](<https://devfeed.tech/tags/zero-knowledge-proof.md>)

### AI overview

The proposed zk-NSGA-II protocol lets independent solvers contribute privately to a shared, on-chain Pareto front. It runs NSGA-II in the RISC Zero zkVM and certifies evolutionary generations with succinct proofs verified on-chain. Solvers keep their populations and local Pareto fronts off-chain; contributions enter the global front only when non-dominated against existing contributions. Hash chains link population states across generations to guard against fabricated contributions. The abstract reports correctness evaluations on 12 ZDT and DTLZ benchmark problems and a feasibility case study in portfolio optimization using the Hang Seng dataset. It says performance was assessed with nine metrics spanning optimization, zero-knowledge proof, and blockchain perspectives, and concludes that trustless collaboration appears feasible with existing technologies.

### Source excerpt

arXiv:2611.11567v1 Announce Type: new Abstract: Collaborative multi-objective optimization allows independent problem solvers to contribute their solutions to a shared problem. However, their validity cannot be reliably verified in open settings if the parties are reluctant to disclose their solutions. Therefore, this paper proposes a novel zk-NSGA-II protocol for verifiable, privacy-preserving and collaborative multi-objective optimization on blockchain. To the best of our knowledge, this is the first work that executes Non-Dominated Sorting Genetic Algorithm II (NSGA-II) on the RISC Zero Zero-Knowledge Virtual Machine (zkVM) where evolutionary generations are certified by succinct proofs that are verified on-chain. Problem solvers maintain their own independent populations as the set of solutions in the decision space and their corresponding objective vectors in the objective space. They contribute to a global on-chain Pareto front by aggregating their local off-chain Pareto fronts according to the rule of non-domination which admits a contribution if it is non-dominated with respect to the existing contributions in the global front. To prevent fabricated contributions, population states across generations are linked through hash chains. The correctness of the zk-NSGA-II protocol is first evaluated on twelve problems from the ZDT and DTLZ benchmarks. Second, its feasibility is shown in a real-world portfolio optimization case study with the Hang Seng dataset. Performance on these problems is measured with nine different metrics across three complementary perspectives for optimization, zero-knowledge proof and blockchain. The empirical findings indicate that trustless collaborative multi-objective optimization is feasible with the existing zero-knowledge and blockchain technologies.

## Delegating Computation with Approximate Arithmetic: Interactive Proofs for Wizards

DevFeed: [Delegating Computation with Approximate Arithmetic: Interactive Proofs for Wizards](<https://devfeed.tech/articles/delegating-computation-with-approximate-arithmetic-interactive-proofs-for-wizards-126964.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11618>)

Author: Aritra Das, Debayan Gupta, Arup Mondal, Mihir More

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>)

Tags: [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [circuits](<https://devfeed.tech/tags/circuits.md>), [complex](<https://devfeed.tech/tags/complex.md>), [complex-numbers](<https://devfeed.tech/tags/complex-numbers.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [proofs](<https://devfeed.tech/tags/proofs.md>)

### AI overview

The paper extends GKR to public-coin interactive proofs for logspace-uniform layered circuits over the complex numbers when both prover and verifier use approximate arithmetic. Given public bounds on gate values and wiring coefficients, it accepts honest claims within error Δ₀ of the exact output and rejects claims farther than Δ with high probability. At constant soundness, the verifier runs in (n+1)poly(L, log S, b) time, communication is poly(L, log S, b), and the prover runs in poly(S, b) time; the honest prover uses O(S log S) complex operations. To control rounding error, the protocol labels gates by complex roots of unity, combines layer claims using a random root of unity, and selects error thresholds backward from the input layer. The authors also report zero-knowledge proofs from one-way functions, one-round arguments from private information retrieval, and interactive PCPs with proof length polynomial in witness length.

### Source excerpt

arXiv:2611.11618v1 Announce Type: new Abstract: We study interactive proofs for arithmetic circuits over the complex numbers $\mathbb{C}$ in which both the prover and the verifier compute approximately (unlike muggles, wizards can use magic, i.e., floating-point numbers). The goal is to prove that a claimed output $y$ is close to the exact output $C(x)$: for thresholds $0<\Delta_0<\Delta$, the honest prover is accepted whenever $|y-C(x)|\le\Delta_0$, and every prover is rejected with high probability whenever $|y-C(x)|>\Delta$. Existing proof systems for real-valued data verify rounded finite-field computations. Bitan et al.~[EUROCRYPT~2026] gave an approximate sum-check protocol. We extend the protocol of Goldwasser, Kalai, and Rothblum (GKR) [STOC~2008] to public-coin interactive proofs for logspace-uniform layered circuits over $\mathbb{C}$ of size $S$, depth $L$, and $n$ inputs, under public bounds on gate values and wiring coefficients. At constant soundness error, the verifier runs in time $(n+1)\mathrm{poly}(L,\log S,b)$, the communication is $\mathrm{poly}(L,\log S,b)$, and the prover runs in time $\mathrm{poly}(S,b)$, where $b$ is the bit precision. To the best of our knowledge, these are the first doubly efficient interactive proofs in which both parties compute approximately. GKR reduces two claims about a layer to one on a random line, which leaves the unit circle, where our error bounds hold. We instead label gates by complex roots of unity and combine the two claims with a random root of unity as coefficient. We choose the error thresholds backward from the input layer, so that a large output error survives the verifier's rounding at every step. The honest prover needs only $O(S \log S)$ complex operations. We also obtain zero-knowledge proofs from one-way functions, one-round arguments from private information retrieval, and interactive PCPs whose proof length is polynomial in the witness length.

## zkARc: Succinctly Verifiable Proofs for Neurosymbolic Natural Language Formalization and Verification

DevFeed: [zkARc: Succinctly Verifiable Proofs for Neurosymbolic Natural Language Formalization and Verification](<https://devfeed.tech/articles/zkarc-succinctly-verifiable-proofs-for-neurosymbolic-natural-language-formalization-and-verification-125866.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10031>)

Author: Wyatt Benno (ICME Labs), Alberto Centelles (Imperial College London), Aman Goel (Amazon Web Services), Benjamin Kiesl-Reiter (Amazon Web Services)

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-generated-content](<https://devfeed.tech/tags/ai-generated-content.md>), [automated-reasoning](<https://devfeed.tech/tags/automated-reasoning.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [smt](<https://devfeed.tech/tags/smt.md>), [verification](<https://devfeed.tech/tags/verification.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>), [zero-knowledge-proof](<https://devfeed.tech/tags/zero-knowledge-proof.md>)

### AI overview

zkARc adds succinct zero-knowledge proofs to each stage of ARc, a system that formalizes natural-language policies and checks AI-generated actions with SMT solvers. Its receipt certifies the planner output, policy and action formalizations, and solver queries, binding them to the exact action received. Under stated assumptions, a third party can verify enforcement without rerunning the pipeline or learning private policies and intermediate model values beyond declared public information and the verdict. The authors prove completeness, knowledge soundness, and zero knowledge under explicit assumptions. A Qwen2-0.5B spending-policy demonstration approved two purchases and denied a third. Performance remains costly: proving a full receipt on CPU took about an hour, though verification took under a minute; a solver-only proof was 88 KiB and verified in 0.3 seconds.

### Source excerpt

arXiv:2611.10031v1 Announce Type: cross Abstract: Autonomous agents increasingly execute consequential actions on behalf of users, but ordinary middleware guardrails do not provide cryptographic proof that a policy was actually enforced. Their verdicts leave counterparties dependent on the operator unless they repeat the checks themselves, potentially exposing sensitive policies and inputs. We present zkARc, a modular proof-carrying framework that wraps each stage of Automated Reasoning checks (ARc) in an independent, succinctly verifiable zero-knowledge proof. ARc is a neurosymbolic system that translates natural language policies into formal logic and verifies AI-generated content against them using SMT solvers. zkARc certifies the planner's output, the policy's formalization, the action's formalization and both solver queries. The receipt binds these computations to the exact action received and, under the stated assumptions, reveals no additional information about private policies and intermediate model values beyond the declared public information and verdict. This lets a third party check the claimed policy enforcement without re-running the pipeline or trusting the operator. We prove completeness, knowledge soundness and zero knowledge for the composed receipt under explicit assumptions. An implementation on Qwen2-0.5B enforces a spending policy end to end, approving two purchases and denying a third. A full receipt, which also proves model inference, takes about an hour to issue with CPU-only proving and verifies in under a minute, and the solver proof alone is 88 KiB and verifies in 0.3 seconds.

## zk-DEAP: A Zero-Knowledge Decentralized Encrypted Aggregation Protocol

DevFeed: [zk-DEAP: A Zero-Knowledge Decentralized Encrypted Aggregation Protocol](<https://devfeed.tech/articles/zk-deap-a-zero-knowledge-decentralized-encrypted-aggregation-protocol-126910.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10020>)

Author: Jude Ramanan, Georgiana Haldeman, Noah Apthorpe

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [homomorphic encryption](<https://devfeed.tech/topics/homomorphic-encryption.md>), [Federated Learning](<https://devfeed.tech/topics/federated-learning.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [attacks](<https://devfeed.tech/tags/attacks.md>), [bind](<https://devfeed.tech/tags/bind.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [contribution](<https://devfeed.tech/tags/contribution.md>), [core](<https://devfeed.tech/tags/core.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [defense](<https://devfeed.tech/tags/defense.md>), [encrypted](<https://devfeed.tech/tags/encrypted.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [zero](<https://devfeed.tech/tags/zero.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

zk-DEAP combines lifted ElGamal homomorphic encryption, FROST threshold cryptography, and zero-knowledge proofs to aggregate private inputs while checking constraints without a trusted party. Its key mechanism prevents a valid proof for one value from being paired with a ciphertext containing another: Bulletproofs use ciphertext-derived randomness modification, while zk-SNARKs and zk-STARKs use a blinded arithmetic hash commitment with an embedded Schnorr constraint. The authors say these methods bind the proof's private witness to the encrypted value, so verified constraints apply to the ciphertext. Three Rust variants were evaluated with 5-500 participants; the abstract reports modest overhead versus unverified aggregation and cryptographic protection against input manipulation.

### Source excerpt

arXiv:2611.10020v1 Announce Type: new Abstract: Secure aggregation in domains such as federated learning, Internet of Things, and voting requires operating on private inputs while preserving confidentiality, verifying that each input satisfies constraints, and avoiding trusted parties. Existing protocols achieve at most two of these requirements. We present zk-DEAP, a protocol combining lifted ElGamal homomorphic encryption, FROST threshold cryptography, and zero-knowledge proofs (Bulletproofs, zk-SNARKs, or zk-STARKs) for fully decentralized, verifiable, privacy-preserving aggregation. Our core technical contribution is a cryptographic binding mechanism preventing substitution attacks, where a valid proof for one input is paired with a ciphertext encrypting a different, malicious value. For Bulletproofs, we bind via ciphertext-derived randomness modification. For zk-SNARKs/zk-STARKs, to bind across algebraic structures (a well-known challenge in practical cryptography), we introduce a novel blinded arithmetic hash commitment with an embedded Schnorr constraint. These binding techniques force the ZKP's private witness to equal the encrypted value, ensuring any circuit-verified constraint applies to the ciphertext. We implement three production-ready, defense-in-depth variants in Rust and evaluate across 5-500 participants. Compared to unverified aggregation, zk-DEAP adds modest overhead while providing cryptographic guarantees against input manipulation that statistical defenses cannot match.

## BioBind: Binding Biometric Deduplication to Zero-Knowledge Authentication

DevFeed: [BioBind: Binding Biometric Deduplication to Zero-Knowledge Authentication](<https://devfeed.tech/articles/biobind-binding-biometric-deduplication-to-zero-knowledge-authentication-126994.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.12636>)

Author: Taotao Wang, Xiaoxiao Wu, Shengli Zhang

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Facial recognition](<https://devfeed.tech/topics/facial-recognition.md>), [Ethereum](<https://devfeed.tech/topics/ethereum.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [backend](<https://devfeed.tech/tags/backend.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [deduplication](<https://devfeed.tech/tags/deduplication.md>), [encrypted](<https://devfeed.tech/tags/encrypted.md>), [gallery](<https://devfeed.tech/tags/gallery.md>), [gas](<https://devfeed.tech/tags/gas.md>), [integration](<https://devfeed.tech/tags/integration.md>), [matching](<https://devfeed.tech/tags/matching.md>), [migration](<https://devfeed.tech/tags/migration.md>), [private](<https://devfeed.tech/tags/private.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [query](<https://devfeed.tech/tags/query.md>), [snapshot](<https://devfeed.tech/tags/snapshot.md>), [state](<https://devfeed.tech/tags/state.md>), [template](<https://devfeed.tech/tags/template.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

BioBind aims to prevent duplicate biometric credentials and substituted-input attacks across off-chain deduplication and smart-contract issuance. It binds the deduplication query, gallery insertion, and issued commitment to one captured vector, authenticates gallery transitions, and requires a sound uniqueness verdict still valid at finalization. Its encrypted design adds bound requests, stale-session rejection, and committee-confirmed migration; zero-knowledge authentication links credential use to the enrolled template and a fresh device-originated probe bound to the challenge. In a prototype, tested composition attacks were rejected, and the authentication circuit used 31,445 constraints and about 305,000 gas. Verifiable matching had a 1.989-second median for witness generation and proving, versus 1.119 seconds with device-trusted matching. On Bosphorus, cooperative subjects changing appearance evaded deduplication in 1.8% of re-enrollment attempts at the tested threshold. The security argument is conditional on explicit assumptions, and full backend integration remains open.

### Source excerpt

arXiv:2611.12636v1 Announce Type: new Abstract: Biometric identity systems for decentralized applications need credentials that resist repeated enrollment and support private, publicly verifiable authentication. Capture and large-scale private deduplication run off chain while smart contracts authorize issuance and use; these stages span distinct trust domains, and a correct verdict covers only the checked inputs and gallery snapshot. Without binding and state checks, concurrent enrollments can issue duplicate credentials from correct verdicts, while substituted inputs can authorize unrelated credentials. We present BioBind, a protocol whose four backend interface conditions bind the deduplication query, gallery insertion and issued commitment to one captured vector, authenticate gallery transitions, and require a sound uniqueness verdict valid at finalization. Its encrypted instance uses bound requests, stale-session rejection and committee-confirmed migration. Capture-bound zero-knowledge authentication links credential use to the enrolled template and a fresh device-originated probe bound to the challenge. We give a conditional multi-session composition argument under explicit capture, backend and cryptographic assumptions. A prototype using LFW face features rejects the tested composition attacks; its unlinkable authentication circuit uses 31,445 constraints and about 305,000 gas. An equal-public-field baseline quantifies the cost of verifiable matching: witness-plus-proving medians are 1.989 s versus 1.119 s with device-trusted matching. Separate tests of encrypted enrollment complete three histories of 16,384 registrations without decoding errors at the tested checkpoints. Biometric accuracy bounds person-level uniqueness: on the Bosphorus database, cooperative subjects who change appearance evade deduplication in 1.8% of re-enrollment attempts at the operating threshold. Full backend integration remains open.

## Robust and Private Swarm Learning via Zero-Knowledge Validator Admission and Consensus Aggregation

DevFeed: [Robust and Private Swarm Learning via Zero-Knowledge Validator Admission and Consensus Aggregation](<https://devfeed.tech/articles/robust-and-private-swarm-learning-via-zero-knowledge-validator-admission-and-consensus-aggregation-125387.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11477>)

Author: Marco Arazzi, Mert Cihangiroglu, Antonino Nocera

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Federated Learning](<https://devfeed.tech/topics/federated-learning.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Adversarial attacks](<https://devfeed.tech/topics/adversarial-attacks.md>)

Tags: [admission](<https://devfeed.tech/tags/admission.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [attack-surface](<https://devfeed.tech/tags/attack-surface.md>), [attestation](<https://devfeed.tech/tags/attestation.md>), [audit](<https://devfeed.tech/tags/audit.md>), [client](<https://devfeed.tech/tags/client.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data-quality](<https://devfeed.tech/tags/data-quality.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [gradient](<https://devfeed.tech/tags/gradient.md>), [learning](<https://devfeed.tech/tags/learning.md>), [mask](<https://devfeed.tech/tags/mask.md>), [model](<https://devfeed.tech/tags/model.md>), [network](<https://devfeed.tech/tags/network.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [pool](<https://devfeed.tech/tags/pool.md>), [private](<https://devfeed.tech/tags/private.md>), [robust](<https://devfeed.tech/tags/robust.md>), [swarm](<https://devfeed.tech/tags/swarm.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

The framework makes validator admission depend on zero-knowledge evidence that a reference model ran correctly on private data, without disclosing raw samples. It uses attested outputs to form a label-free, collectively IID validator pool from skewed participants, then has admitted validators use Tendermint-style Byzantine fault-tolerant consensus to agree on update masks and quality-derived aggregation weights instead of dataset-size weights. A challenge-based audit rechecks masks without an end-to-end zero-knowledge proof. In four non-IID benchmarks it reportedly matches FedAvg on clean data; under gradient scaling, it retains 94% of clean accuracy on CIFAR-100 and over 99% on FashionMNIST, while FedAvg falls to random chance (2.1% and 11%, respectively).

### Source excerpt

arXiv:2611.11477v1 Announce Type: cross Abstract: Swarm Learning improves resilience and removes the need for a single trusted coordinator by distributing model aggregation and validation across participating nodes. However, it also delegates the validation of model updates to peers whose private data may be biased, unrepresentative, or adversarial, and existing Swarm Learning protocols generally do not attest that data, leaving decentralized validation as an attack surface. We present a robust, privacy-preserving Swarm Learning framework that makes verifiable data quality the condition for admission to the learning task. A validator joins only after a zero-knowledge attestation proves, without revealing any raw sample, that a reference model ran correctly on its private data. The attested outputs also yield a label-free class profile, so the network assembles a collectively IID validator pool from individually skewed validators as accurately as an oracle with the true labels (total-variation distance to uniform 0.025, against 0.021 for the oracle and 0.21 for random selection). Admitted validators score client updates and, through a Tendermint-style Byzantine Fault Tolerant consensus, agree on a gradient mask and a quality-derived aggregation weight for each submission, replacing dataset-size weighting with a quality-aware signal. Adapting the cut-layer idea of Split Learning, a challenge-based audit lets peers re-verify that a mask was computed on the attested data without an expensive end-to-end zero-knowledge proof. Across four benchmarks under non-IID partitions the framework matches FedAvg on clean data; under a gradient-scaling attack that collapses FedAvg to random chance, it retains 94% of clean accuracy on CIFAR-100 and over 99% on FashionMNIST, where FedAvg achieves only 2.1% and 11%. The result is a private, robust, and auditable foundation for decentralized learning.

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

DevFeed: [Certified but Private: Scalable Zero-Knowledge Proofs for Neural Network Guarantees](<https://devfeed.tech/articles/certified-but-private-scalable-zero-knowledge-proofs-for-neural-network-guarantees-126895.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.17070>)

Author: Youwei Zhong, Ben Merbaum, Timos Antonopoulos, Ning Luo, Charalampos Papamanthou, Katerina Sotiraki, Ruzica Piskac

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>)

Tags: [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [fairness](<https://devfeed.tech/tags/fairness.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [private](<https://devfeed.tech/tags/private.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [scale](<https://devfeed.tech/tags/scale.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

PANDA uses zero-knowledge proofs to let auditors verify neural network robustness and fairness without learning the model's private parameters. Built on CROWN, it introduces a method for proving linear relaxation bounds for nonlinear activation layers, producing lightweight proofs. The authors report generating local-robustness proofs for networks with more than 2.9 million parameters in five minutes and verifying them in 10 seconds. They say PANDA scales polynomially with neuron count, compared with prior ZKP-based robustness systems described as relying on exponential-time algorithms, and supports networks four orders of magnitude larger with lower prover overhead. These performance claims are from the supplied abstract.

### Source excerpt

arXiv:2608.17070v3 Announce Type: replace-cross Abstract: With the growing deployment of machine learning models, formal guarantees of the robustness and fairness of these models have become increasingly important in safety-critical and legal-compliance settings. However, model parameters are often commercial secrets that cannot be disclosed to auditors or end users. To this end, we present PANDA, a scalable system that uses zero-knowledge proofs (ZKPs) to prove the robustness and fairness properties of a model without revealing its private parameters. PANDA is built on top of CROWN, an efficient robustness certification framework that is used in many state-of-the-art formal verification tools for neural networks. The core contribution of PANDA is a novel algorithm for proving linear relaxation bounds for non-linear activation layers, yielding simple, lightweight proofs. Remarkably, our implementation 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. Prior ZKP-based robustness system rely on exponential-time algorithms that cannot scale to nontrivial networks. In contrast, PANDA scales polynomially in the number of neurons in a network, allowing us to support neural networks 4 orders of magnitude larger than previous approaches with significantly reduced prover overhead.

## A Practical Post-Quantum Distributed Ledger Protocol for Financial Institutions

DevFeed: [A Practical Post-Quantum Distributed Ledger Protocol for Financial Institutions](<https://devfeed.tech/articles/a-practical-post-quantum-distributed-ledger-protocol-for-financial-institutions-122763.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2603.05005>)

Author: Yeoh Wei Zhu, Naresh Goud Boddu, Yao Ma, Shaltiel Eloul, Giulio Golinelli, Yash Satsangi, Rob Otter, Kaushik Chakraborty

Published: 2026-11-09T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>), [cryptographic audit](<https://devfeed.tech/topics/cryptographic-audit.md>)

Tags: [assets](<https://devfeed.tech/tags/assets.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [encrypted](<https://devfeed.tech/tags/encrypted.md>), [financial-institutions](<https://devfeed.tech/tags/financial-institutions.md>), [lattice](<https://devfeed.tech/tags/lattice.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [private](<https://devfeed.tech/tags/private.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [security](<https://devfeed.tech/tags/security.md>), [transaction](<https://devfeed.tech/tags/transaction.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

The paper proposes a post-quantum, lattice-based transaction scheme for encrypted ledgers, aiming to meet financial institutions' confidentiality and auditability needs. It combines zero-knowledge proofs with a method for equating commitment messages during re-commitment without opening one of them, then builds a publicly verifiable scheme for single- or multi-asset transactions using a compact range proof. The abstract says the authors provide a security analysis; it does not give implementation details or quantitative performance results.

### Source excerpt

arXiv:2603.05005v2 Announce Type: replace Abstract: Traditional financial institutions face inefficiencies that can be addressed by distributed ledger technology. However, a primary barrier to adoption is the privacy concerns surrounding publicly available transaction data. Existing private protocols for distributed ledger that focus on the Ring-CT model are not suitable for adoption for financial institutions. We propose a post-quantum, lattice-based transaction scheme for encrypted ledgers which better aligns with institutions' requirements for confidentiality and audit-ability. The construction leverages various zero-knowledge proof techniques, and introduces a new method for equating two commitment messages, without the capability to open one of the commitment during the re-commitment. Subsequently, we build a publicly verifiable transaction scheme that is efficient for single or multi-assets, by introducing a new compact range-proof. We then provide a security analysis of it. The techniques used and the proofs constructed could be of independent interest.

## Performance Bottlenecks in Computing ZK Proofs on a GPU

DevFeed: [Performance Bottlenecks in Computing ZK Proofs on a GPU](<https://devfeed.tech/articles/performance-bottlenecks-in-computing-zk-proofs-on-a-gpu-122805.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.09569>)

Author: Victor Carolino, Caleb Geren, Michael Kaufman, Maximilian Nussbaum, William Scott, Henry F. Korth

Published: 2026-11-09T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Multi-GPU](<https://devfeed.tech/topics/multi-gpu.md>), [GPU optimization](<https://devfeed.tech/topics/gpu-optimization.md>), [rdma](<https://devfeed.tech/topics/rdma.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [communication](<https://devfeed.tech/tags/communication.md>), [computing](<https://devfeed.tech/tags/computing.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [data](<https://devfeed.tech/tags/data.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [low-level](<https://devfeed.tech/tags/low-level.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [multi-gpu](<https://devfeed.tech/tags/multi-gpu.md>), [performance](<https://devfeed.tech/tags/performance.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [zk-proofs](<https://devfeed.tech/tags/zk-proofs.md>)

### AI overview

The paper examines GPU acceleration of PlonK proof generation for applications that do not suit incrementally verifiable computing, focusing on how greater parallelism changes performance while increasing memory-management demands. It implements a parallelized PlonK to study these trade-offs and the proving protocol's data flows. For large circuits, it considers multi-GPU setups, which introduce communication, hardware-management, partitioning, and transfer challenges. The abstract also discusses motivating use cases, cost models, and RDMA for transfers between GPUs; it provides no specific benchmark results or implementation recommendations.

### Source excerpt

arXiv:2611.09569v1 Announce Type: new Abstract: Zero-knowledge proofs allow one party to prove the correctness of a statement or execution of a computation while revealing no more than the statement of correctness itself. Recent use cases, such as AI datasets, suggest the need for faster proof generation over increasingly large constraint sets. This paper explores efforts in optimizing zero-knowledge proof generation, specifically PlonK, using GPUs, for applications that are not amenable to solution via incrementally verifiable computing (IVC). Our intention with this work is to improve ZK performance by introducing fundamental changes in the low-level architectural structure of proof generation. These changes affect performance curves for most current proof generation algorithms. In particular, this paper explores the trade-offs between increased parallelization on GPUs and the resultant memory management problems that occur due to this parallelization. We implement a parallelized PlonK in order to analyze these trade-offs and make arguments concerning the nature of data flows within the proving protocol. Our results lead us to consider multi-GPU environments to maximize performance for large circuit sizes. Such environments introduce issues of communication, efficient hardware management, data partition, and data transfers. This paper further discusses the use cases that motivate multi-GPU implementations, their cost models, and the use of remote direct memory access (RDMA) for data transfer among GPUs.

## A Post-Quantum Interactive Hashing Theorem

DevFeed: [A Post-Quantum Interactive Hashing Theorem](<https://devfeed.tech/articles/a-post-quantum-interactive-hashing-theorem-118701.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06124>)

Author: C\\'eline Chevalier, Laurent Holin, Quoc-Huy Vu

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [np](<https://devfeed.tech/tags/np.md>), [one-way-functions](<https://devfeed.tech/tags/one-way-functions.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [quant-ph](<https://devfeed.tech/tags/quant-ph.md>), [quantum-security](<https://devfeed.tech/tags/quantum-security.md>), [security](<https://devfeed.tech/tags/security.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

The note gives a post-quantum security proof for the multi-output interactive hashing protocol with arbitrary relations. Interactive hashing is used in cryptographic protocols, and its multi-output generalization is a key ingredient in constructions of statistical zero-knowledge arguments for NP and statistically hiding commitments from arbitrary one-way functions. The supplied excerpt does not describe the proof or its assumptions in detail.

### Source excerpt

arXiv:2611.06124v1 Announce Type: cross Abstract: Interactive hashing, introduced by Ostrovsky, Venkatesan, and Yung [OVY93], is a building block in many cryptographic protocols, including perfectly hiding commitments from one-way permutations [NOVY92]. Its multi-output generalization is a key ingredient in constructions of statistical zero-knowledge arguments for NP and statistically hiding commitments from arbitrary one-way functions [NOV06,HR07]. In this note, we give a post-quantum security proof for this multi-output interactive hashing protocol with arbitrary relations.

## Clear Human Web: Where a Person Vouches for Every Client

DevFeed: [Clear Human Web: Where a Person Vouches for Every Client](<https://devfeed.tech/articles/clear-human-web-where-a-person-vouches-for-every-client-118708.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06286>)

Author: Lorenzo Porcelli

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [Web](<https://devfeed.tech/topics/web.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [multi-accounting fraud](<https://devfeed.tech/topics/multi-accounting-fraud.md>)

Tags: [adversary](<https://devfeed.tech/tags/adversary.md>), [agents](<https://devfeed.tech/tags/agents.md>), [automated-traffic](<https://devfeed.tech/tags/automated-traffic.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [browser](<https://devfeed.tech/tags/browser.md>), [client](<https://devfeed.tech/tags/client.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-cy](<https://devfeed.tech/tags/cs-cy.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [properties](<https://devfeed.tech/tags/properties.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [publisher](<https://devfeed.tech/tags/publisher.md>), [sites](<https://devfeed.tech/tags/sites.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [wallet](<https://devfeed.tech/tags/wallet.md>), [web](<https://devfeed.tech/tags/web.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>), [zero-knowledge-proof](<https://devfeed.tech/tags/zero-knowledge-proof.md>)

### AI overview

The Clear Human Web proposal gates participating sites on a person-vouched proof, aiming to make automated access harder without revealing identity attributes to each site. A wallet presents person identification data (PID) to one issuer and receives a bounded number of blind-signed, attribute-free tokens; the browser spends one per site, which learns only that a valid token from a trusted issuer was used. The paper says no PID field, new protocol, or site registration is required, and publishers use the same proof as readers. A person's identities per site per epoch are bounded to k only if the wallet restricts them to one issuer pseudonym. For k = 1, the proposal instead uses a zero-knowledge proof of PID possession and a per-site pseudonym. The supplied text is an abstract and does not provide detailed evidence about the construction's security properties.

### Source excerpt

arXiv:2611.06286v1 Announce Type: new Abstract: The web cannot tell whether a request comes from a person or from a program. Sites have checked the network address and puzzles in its place, and both have given way: automated traffic exceeds human traffic, and puzzles are solved for pay and by agents. This paper proposes the Clear Human Web, the part of the public web that sites open only to clients a person vouches for. A person's wallet presents their person identification data (PID) to one issuer, the only party that registers as a relying party, and receives a bounded number of blind-signed tokens, proofs of personhood that carry no attribute. The browser spends one token at each site that runs the gate, and the site learns that a valid token of a trusted issuer was spent, and nothing else. No field is added to the PID, no protocol is introduced, no site registers, and the publisher of a site holds the same proof as its readers. We define the Clear Human Web through five properties and seven adversaries, and state which properties the construction satisfies against each adversary. The identities a person can hold on one site in an epoch are bounded to k. The bound holds once the wallet limits a person to one pseudonym at the issuer. In the optimum k = 1, and a zero-knowledge proof of PID possession and a pseudonym per site replace the tokens.

## ToxiEval-ZKP: A Structure-Private Verification Framework for Molecular Toxicity Repair Tasks

DevFeed: [ToxiEval-ZKP: A Structure-Private Verification Framework for Molecular Toxicity Repair Tasks](<https://devfeed.tech/articles/toxieval-zkp-a-structure-private-verification-framework-for-molecular-toxicity-repair-tasks-118657.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2508.12035>)

Author: Fei Lin, Tengchao Zhang, Ziyang Gong, Fei-Yue Wang

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [classification](<https://devfeed.tech/tags/classification.md>), [complete](<https://devfeed.tech/tags/complete.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [framework](<https://devfeed.tech/tags/framework.md>), [generative](<https://devfeed.tech/tags/generative.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [model](<https://devfeed.tech/tags/model.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [private](<https://devfeed.tech/tags/private.md>), [repair](<https://devfeed.tech/tags/repair.md>), [science](<https://devfeed.tech/tags/science.md>), [security](<https://devfeed.tech/tags/security.md>), [structure](<https://devfeed.tech/tags/structure.md>), [system](<https://devfeed.tech/tags/system.md>), [validation](<https://devfeed.tech/tags/validation.md>), [verification](<https://devfeed.tech/tags/verification.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>), [zero-knowledge-proof](<https://devfeed.tech/tags/zero-knowledge-proof.md>)

### AI overview

ToxiEval-ZKP lets model developers prove to external verifiers that generated molecules satisfy multidimensional toxicity-repair criteria without disclosing the molecular structures. Its general-purpose circuit supports classification and regression, combining evaluation logic with Poseidon-based commitment hashing and a nullifier to prevent replay. The abstract reports validation under complete structural invisibility and claims circuit efficiency, security, and adaptability; it gives no quantitative results or detailed limitations.

### Source excerpt

arXiv:2508.12035v3 Announce Type: replace Abstract: In recent years, generative artificial intelligence (GenAI) has demonstrated remarkable capabilities in high-stakes domains such as molecular science. However, challenges related to the verifiability and structural privacy of its outputs remain largely unresolved. This paper focuses on the task of molecular toxicity repair. It proposes a structure-private verification framework - ToxiEval-ZKP - which, for the first time, introduces zero-knowledge proof (ZKP) mechanisms into the evaluation process of this task. The system enables model developers to demonstrate to external verifiers that the generated molecules meet multidimensional toxicity repair criteria, without revealing the molecular structures themselves. To this end, we design a general-purpose circuit compatible with both classification and regression tasks, incorporating evaluation logic, Poseidon-based commitment hashing, and a nullifier-based replay prevention mechanism to build a complete end-to-end ZK verification system. Experimental results demonstrate that ToxiEval-ZKP facilitates adequate validation under complete structural invisibility, offering strong circuit efficiency, security, and adaptability, thereby opening up a novel paradigm for trustworthy evaluation in generative scientific tasks.

## Anthropic found a way to prove which AI model answered you -- but there's a costly catch

DevFeed: [Anthropic found a way to prove which AI model answered you -- but there's a costly catch](<https://devfeed.tech/articles/anthropic-found-a-way-to-prove-which-ai-model-answered-you-but-there-s-a-costly-catch-117860.md>)

Original publisher: [Read original article](<https://thenewstack.io/anthropic-flashprove-model-verification/>)

Author: Amanda Caswell

Published: 2026-11-04T22:50:18Z

Content type: news

Language: en

Sources: [The New Stack](<https://devfeed.tech/sources/the-new-stack.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [flashprove](<https://devfeed.tech/tags/flashprove.md>), [github](<https://devfeed.tech/tags/github.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [h100](<https://devfeed.tech/tags/h100.md>), [inference](<https://devfeed.tech/tags/inference.md>), [lean](<https://devfeed.tech/tags/lean.md>), [llama-4-maverick](<https://devfeed.tech/tags/llama-4-maverick.md>), [model-weights](<https://devfeed.tech/tags/model-weights.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

FlashProve is an open-source research prototype that uses zkSNARKs to verify a response against a committed set of model weights without revealing the weights. Anthropic tested it on Meta's Llama 4 Maverick, not Claude: on one Nvidia H100 it processed about 110 prompt tokens per second while generating proofs. Each proof was about 18.78 MB and took roughly 21 seconds to verify on one CPU thread. Proof generation required 70-95 times more GPU time than standard vLLM inference, and proofs are generated in batches after requests, making routine or immediate verification costly. The protocol's properties were formally checked in Lean; FlashProve also includes a faster C++ verifier and a GPU prover, neither formally verified. The prototype is limited to 1,024 context tokens, integer inference, and greedy decoding, and is not a Claude API feature.

### Source excerpt

Developers using AI APIs have little way of knowing whether the model answering their requests is actually the one they're The post Anthropic found a way to prove which AI model answered you -- but there's a costly catch appeared first on The New Stack.

## Proving the Wrong Program: Miscompilations as a Threat to zkVM Guarantees

DevFeed: [Proving the Wrong Program: Miscompilations as a Threat to zkVM Guarantees](<https://devfeed.tech/articles/proving-the-wrong-program-miscompilations-as-a-threat-to-zkvm-guarantees-116157.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04701>)

Author: Hui Xuan Tan, Stefanos Chaliasos, Alastair F. Donaldson

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [risc-v](<https://devfeed.tech/tags/risc-v.md>), [rust](<https://devfeed.tech/tags/rust.md>), [virtual-machine](<https://devfeed.tech/tags/virtual-machine.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

The study finds that compiler miscompilations can undermine zkVM guarantees even when the zkVM and guest source are correct. Among 88 known rustc and LLVM bugs tested, 48 caused wrong outputs on SP1 and 46 on Jolt; many others did not reproduce because their faulty code was unreachable on the target. Accidental effects on existing guests appeared uncommon: across 552 buildable guest-bug pairs from 13 guests in 10 SP1 projects, 447 produced byte-identical binaries, while the rest had the same code or agreed on tested inputs. By contrast, an LLM agent found source-preserving, optimization-like patches that exposed bugs in 12 of 366 project-bug pairs across 11 of 20 projects. Four led to wrong outputs, including an Ethereum client rejecting a valid block; eight caused failures on valid inputs. The authors recommend treating the compiler as part of the trusted base and tracking known toolchain bugs.

### Source excerpt

arXiv:2611.04701v1 Announce Type: cross Abstract: A zero-knowledge virtual machine (zkVM) lets an untrusted prover convince a verifier that a program, typically Rust compiled to RISC-V, ran correctly. The proof covers the compiled binary, so a miscompilation can make a correct zkVM produce a valid proof of a computation that differs from the developer's source. We present the first empirical study of miscompilation as a threat to zkVM guarantees, on the production zkVMs SP1 and Jolt. We assemble 88 known rustc and LLVM miscompilations with Rust reproducers, using an LLM agent to recover Rust triggers for 60 of 124 LLVM bugs reported only as LLVM IR. Many of the bugs carry over to zkVMs: 48 of the 88 make a guest commit a wrong output on SP1 and 46 on Jolt, including the same 15 rustc bugs on both. Most bugs that do not reproduce never reach the faulty code on the zkVM's target, e.g. because they need an instruction-set extension. Existing guest programs are rarely affected by accident. Across 13 guests of 10 popular SP1 projects, the buggy and the fixed compiler produce byte-identical binaries in 447 of the 552 guest-bug pairs that build, and the other 105 have the same code or agree on every input we ran. An attacker who contributes code to a guest, however, can trigger these bugs on purpose. For about $40 per project, an LLM agent found patches that look like ordinary optimisations, preserve the behaviour of the guest's source, and expose a known bug in 12 of 366 project-bug pairs, across 11 of 20 projects. In four cases the guest commits a wrong output, including an Ethereum client that rejects a valid block, and in the other eight it fails on a valid input. Reviewing or formally verifying the zkVM or the guest's source cannot catch such a patch, because both are correct. zkVM projects should treat their compiler as part of their trusted base and track the known bugs of their toolchain.

## VerfGraph: Efficient Zero-Knowledge Verifiable Graph Query Evaluation System

DevFeed: [VerfGraph: Efficient Zero-Knowledge Verifiable Graph Query Evaluation System](<https://devfeed.tech/articles/verfgraph-efficient-zero-knowledge-verifiable-graph-query-evaluation-system-116142.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04240>)

Author: Tianyi Ma, Yuncong Zhang, Yuanzhuo Yu, Boshi Yuan, Shi-Feng Sun

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [graph-database](<https://devfeed.tech/topics/graph-database.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>)

Tags: [core](<https://devfeed.tech/tags/core.md>), [count](<https://devfeed.tech/tags/count.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [graph](<https://devfeed.tech/tags/graph.md>), [private](<https://devfeed.tech/tags/private.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [query](<https://devfeed.tech/tags/query.md>), [shortest-path](<https://devfeed.tech/tags/shortest-path.md>), [verification](<https://devfeed.tech/tags/verification.md>), [verify](<https://devfeed.tech/tags/verify.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

VerfGraph lets clients verify query results over a committed private graph without exposing private records or intermediate values beyond public inputs and information implied by the result. Its proof methods reduce sorting and comparison checks for expansion and shortest-path operations, and remove edge canonicalization for bidirectional expansion; it also adds correctness proofs for count and weighted shortest-path queries. On the LDBC Social Network Benchmark's complex IC queries, it reports 33.9x-59.7x faster proof generation than ZKGraph, 4.5x-6.6x lower peak prover memory, millisecond-level verification, and sub-megabyte proofs.

### Source excerpt

arXiv:2611.04240v1 Announce Type: new Abstract: Graph databases are often used to manage relationship-rich data, whose graph structure and attributes may be sensitive. In many applications, a database owner or a service provider evaluates queries over a private graph for a client. Because the graph cannot be fully disclosed and independently re-executing the query may be impractical, the client cannot directly verify the returned result. This creates a need for verifiable graph query evaluation that preserves data confidentiality. We present VerfGraph, a zero-knowledge system for verifiable graph query evaluation, which enables a client to verify that the query result was correctly computed over a committed graph data, without revealing private graph records or intermediate query values beyond the public inputs and what is implied by the query result. Building on the expansion-centric model introduced by the state-of-the-art zero-knowledge verifiable graph query evaluation system ZKGraph (ICDE'26), VerfGraph achieves more efficient and expressive zero-knowledge verifiable graph query evaluation by advancing design in two key ways. First, we propose novel operator-proof methods for core expansion and shortest-path operations that reduce costly sorting and comparison checks and eliminate edge canonicalization for bidirectional expansion. Furthermore, we introduce correctness proofs for count and weighted shortest-path operators, broadening the class of graph queries that can be verified. We evaluate VerfGraph using the LDBC Social Network Benchmark. Compared with ZKGraph on complex IC queries, VerfGraph achieves $33.9\times$-$59.7\times$ speedups in proof generation and reduces peak prover memory by factors of $4.5\times$-$6.6\times$, while maintaining millisecond-level verification and producing sub-MB proofs.

## Anthropic open-sources FlashProve, its provable inference prototype for MoE models

DevFeed: [Anthropic open-sources FlashProve, its provable inference prototype for MoE models](<https://devfeed.tech/articles/anthropic-open-sources-flashprove-its-provable-inference-prototype-for-moe-models-115936.md>)

Original publisher: [Read original article](<https://www.helpnetsecurity.com/2026/11/04/anthropic-flashprove-provable-inference/>)

Author: Anamarija Pogorelec

Published: 2026-11-04T04:36:14Z

Content type: news

Language: en

Sources: [Help Net Security](<https://devfeed.tech/sources/help-net-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Mixture of Experts (MoE)](<https://devfeed.tech/topics/mixture-of-experts-moe.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [apache-2-0](<https://devfeed.tech/tags/apache-2-0.md>), [api](<https://devfeed.tech/tags/api.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [formal](<https://devfeed.tech/tags/formal.md>), [github](<https://devfeed.tech/tags/github.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hugging-face](<https://devfeed.tech/tags/hugging-face.md>), [inference](<https://devfeed.tech/tags/inference.md>), [lean](<https://devfeed.tech/tags/lean.md>), [llama](<https://devfeed.tech/tags/llama.md>), [llms](<https://devfeed.tech/tags/llms.md>), [models](<https://devfeed.tech/tags/models.md>), [moe](<https://devfeed.tech/tags/moe.md>), [news](<https://devfeed.tech/tags/news.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [prototype](<https://devfeed.tech/tags/prototype.md>)

### AI overview

FlashProve is an Apache 2.0 prototype that produces a cryptographic proof linking a specific model to a specific reply, so a checker can verify which model generated it. Its repository includes a prover, a fast C++ verifier, a slower Lean reference verifier, formal protocol proofs, and a protocol specification. The team cautions that the paper, Lean protocol, and running code may not align; the Lean statements need manual review, and the prover itself lacks formal tooling. Tested with Llama 4 Maverick, the prover requires its separately obtained weights, one 80 GB GPU, and about 290 GB of host memory. On one H100 it processed about 110 tokens per second; checking a 1,024-token proof took about 17 seconds on 24 CPU threads. Compared with vLLM on eight H100s, reported overhead was about 72 times per GPU on average and 94 times at the heaviest tested load.

### Source excerpt

Anthropic's Frontier Red Team, with collaborators at EPFL, MIT and StarkWare, built FlashProve, a prototype that produces a cryptographic proof that one specific language model generated one specific reply. The prover, two verifiers, the formal proofs behind them and a protocol specification are on GitHub under the Apache 2.0 license. Source: Anthropic When you send a prompt to a hosted API, you can't confirm which model answered it. A provider could route the request to ... More -> The post Anthropic open-sources FlashProve, its provable inference prototype for MoE models appeared first on Help Net Security.

## Anthropic Releases FlashProve: Cryptographic Proofs That a Reply Came From Committed Weights

DevFeed: [Anthropic Releases FlashProve: Cryptographic Proofs That a Reply Came From Committed Weights](<https://devfeed.tech/articles/anthropic-releases-flashprove-cryptographic-proofs-that-a-reply-came-from-committed-weights-115947.md>)

Original publisher: [Read original article](<https://www.marktechpost.com/2026/11/03/anthropic-flashprove-provable-inference-zksnark/>)

Author: Asif Razzaq

Published: 2026-11-03T22:08:22Z

Content type: article

Language: en

Sources: [MarkTechPost](<https://devfeed.tech/sources/marktechpost.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [ai security](<https://devfeed.tech/topics/ai-security.md>), [anthropic](<https://devfeed.tech/topics/anthropic.md>), [llama](<https://devfeed.tech/topics/llama.md>), [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>)

Tags: [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [ai-paper-summary](<https://devfeed.tech/tags/ai-paper-summary.md>), [ai-shorts](<https://devfeed.tech/tags/ai-shorts.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [api](<https://devfeed.tech/tags/api.md>), [applications](<https://devfeed.tech/tags/applications.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [batch](<https://devfeed.tech/tags/batch.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cheating](<https://devfeed.tech/tags/cheating.md>), [claude](<https://devfeed.tech/tags/claude.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [editors-pick](<https://devfeed.tech/tags/editors-pick.md>), [flashprove](<https://devfeed.tech/tags/flashprove.md>), [for-devs](<https://devfeed.tech/tags/for-devs.md>), [harness](<https://devfeed.tech/tags/harness.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [llama](<https://devfeed.tech/tags/llama.md>), [llama-4-maverick](<https://devfeed.tech/tags/llama-4-maverick.md>), [model](<https://devfeed.tech/tags/model.md>), [new-releases](<https://devfeed.tech/tags/new-releases.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [releases](<https://devfeed.tech/tags/releases.md>), [staff](<https://devfeed.tech/tags/staff.md>), [tech-news](<https://devfeed.tech/tags/tech-news.md>), [technology](<https://devfeed.tech/tags/technology.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [zksnark](<https://devfeed.tech/tags/zksnark.md>)

### AI overview

FlashProve is an open-source zkSNARK prototype that lets a user verify that response tokens came from a provider's committed model while keeping its weights private. The provider first publishes a commitment, then generates per-request proofs; proving can be batched and uses host memory to stream weights. On Llama 4 Maverick, the excerpt reports about 110 tokens per second on one H100, with 18.78 MB proofs that take 17 seconds to verify on a 24-thread CPU. The prover also requires 24 CPU cores and about 290 GB of host RAM. This carries a substantial cost: roughly 70-95 times vLLM's GPU time per batch in the reported comparisons. The protocol is formalized in Lean for completeness, soundness, and zero knowledge; a fast C++ verifier is also provided without a formal guarantee. Current limits include 1,024-token contexts, greedy decoding, and MoE models.

### Source excerpt

Anthropic released FlashProve, an Apache 2.0 zkSNARK prototype that proves a reply came from a committed model without revealing weights. It proves Llama 4 Maverick at 110 tokens/second on 1 H100, with 19 MB proofs. The post Anthropic Releases FlashProve: Cryptographic Proofs That a Reply Came From Committed Weights appeared first on MarkTechPost.

## BioZero: Privacy-Preserving and Publicly Verifiable On-Chain Biometric Authentication via Homomorphic Commitments and Zero-Knowledge Proofs

DevFeed: [BioZero: Privacy-Preserving and Publicly Verifiable On-Chain Biometric Authentication via Homomorphic Commitments and Zero-Knowledge Proofs](<https://devfeed.tech/articles/biozero-privacy-preserving-and-publicly-verifiable-on-chain-biometric-authentication-via-homomorphic-commitments-and-zero-knowledge-proofs-113967.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2409.17509>)

Author: Zibin Lin, Taotao Wang, Junhao Lai, Shengli Zhang, Qing Yang, Soung Chang Liew

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Facial recognition](<https://devfeed.tech/topics/facial-recognition.md>), [sensitive data](<https://devfeed.tech/topics/sensitive-data.md>)

Tags: [attack](<https://devfeed.tech/tags/attack.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [biometric-authentication](<https://devfeed.tech/tags/biometric-authentication.md>), [bits](<https://devfeed.tech/tags/bits.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [data-costs](<https://devfeed.tech/tags/data-costs.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [execution](<https://devfeed.tech/tags/execution.md>), [exhaustive](<https://devfeed.tech/tags/exhaustive.md>), [identity](<https://devfeed.tech/tags/identity.md>), [memory](<https://devfeed.tech/tags/memory.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [services](<https://devfeed.tech/tags/services.md>), [verification](<https://devfeed.tech/tags/verification.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

BioZero evaluates on-chain biometric matching while keeping templates private and avoiding a trusted biometric server. At N=128, exhaustive FullCheck costs 22.1 million gas. SpotCheck lowers gas to 4.1 million by checking seven coordinates, but still uses 127,844 bytes of calldata; the authors show a commitment change can evade a uniform sample of t coordinates with probability 1−t/N, so negligible attack success requires nearly exhaustive checking. CircuitCheck instead proves commitment openings, coordinate ranges, and the integer distance threshold in one circuit: its reference transaction costs 255,000 gas and 356 bytes of calldata. On the evaluated workstation, proving took a median 0.63 seconds and peaked at 822 MiB. Tests on two face datasets found widths of at least 6 bits within 0.46 percentage points of float accuracy. The reported advantage applies to this integer matching task; committed probes must also be bound separately to authenticated live captures.

### Source excerpt

arXiv:2409.17509v3 Announce Type: replace Abstract: Blockchain-based identity services let applications across administrative domains verify biometric authentication results without sharing a trusted biometric server. BioZero evaluates how to protect private templates while limiting on-chain execution and submitted transaction-data costs under explicit cryptographic assumptions. FullCheck provides knowledge soundness for the modular distance relation, but exhaustive coordinate checks cost 22.1 million gas at N=128 in a threshold-stand-in benchmark. SpotCheck tests a natural optimization: sampling checks within the same homomorphic structure. Checking seven coordinates saves 81.3% gas, reducing it to 4.1 million, but retains 127,844 bytes of calldata. We prove that changing one product commitment can shift the reconstructed distance to any chosen residue and evade a uniform sample of t among N coordinates with probability 1-t/N. Negligible attack success therefore requires nearly exhaustive checking, limiting the scope for coordinate-check savings. CircuitCheck changes the verification structure, proving commitment openings, coordinate ranges, and the integer distance threshold in one circuit. Its complete reference transaction costs 255 thousand gas with 356 bytes of calldata. At N=128, median proving time and process peak memory are 0.63 s and 822 MiB on the evaluated workstation. On two face datasets, every tested width of at least 6 bits stays within 0.46 percentage points of float accuracy, supporting the shared integer-input front end. These results favor CircuitCheck for the evaluated integer matching task in blockchain-backed cross-domain identity services, provided that committed probes are separately bound to authenticated live captures.

[Next page](<https://devfeed.tech/topics/zkp.md?cursor=WyIyMDI2LTExLTAzVDA1OjAwOjAwKzAwOjAwIiwgImM5NTk2OThlLWFiMjctNDMxNy04YjYzLTc5Mjc3ZjgyZTQ0YyJd>)