zkCraft: Prompt-Guided LLM as a Zero-Shot Mutation Pattern Oracle for TCCT-Powered ZK Fuzzing
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: I'm Nadia.
Elias: And I'm Elias, here with Priya.
Nadia: We're looking at the paper: "zkCraft: Prompt-Guided LLM as a Zero-Shot Mutation Pattern Oracle for TCCT-Powered ZK Fuzzing".
Elias: Here's the gist of the paper. Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement correctly due to the tight coupling between witness computation and circuit constraints <ref:2602.00667#pg2> The paper presents zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies <ref:2602.00667#pg4> This approach bridges formal verification and automated debugging, offering a scalable path for robust ZK circuit development <ref:2602.00667#pg2> Framework Overview zkCraft is a ZK-native pipeline that tightly couples algebraic localization, succinct violation proofs, and deterministic, prompt-guided mutation templates <ref:2602.00667#pg5> It reduces the combinatorial task of finding small, vulnerability-inducing edits to a single algebraic existence statement encoded as a Row-Vortex polynomial and certified with a Violation IOP <ref:2602.00667#pg6> The system constructs compact per-row fingerprints to prioritize a limited candidate pool Rcand, which is accelerated by LLM Oracles that provide zero-shot Mutation Templates <ref:2602.00667#pg2> Search Methodology The search for small, vulnerability-causing edits is mapped to a single algebraic existence statement encoded as a Row-Vortex polynomial and certified with a Violation IOP <ref:2602.00667#pg6> Stage 1 involves Sparse signature extraction, where diagnostic scores are computed to prune the constraint space into a manageable Candidate Pool Rcand <ref:2602.00667#pg2> Stage 3 utilizes deterministic finite-field synthesis to recover concrete substitutions from proof-embedded encodings <ref:2602.00667#pg2> Proof Certification and Extraction The Violation IOP certifies the existence of a witness satisfying the edited constraints while yielding a different public output <ref:2602.00667#pg6> The resulting Succinct Proof π serves as a Proof-as-Counterexample, from which the Witness Extraction machinery reconstructs the concrete trace to confirm the vulnerability via TCCT <ref:2602.00667#pg2> The extractor recovers (δ, c, w′) by either interpolating a witness polynomial W′(X) or solving an algebraic reconstruction system Fδ,c(w′) = 0 <ref:2602.00667#pg2> Performance and Evaluation zkCraft achieves the highest true positive counts while maintaining very high precision across all circuit size buckets <ref:2602.00667#pg2> The ZK-native mode accounts for 93 % of the successful runs, adding less than 3 % to the total running time compared with a plain TCCT replay <ref:2602.00667#pg2> It uncovers a substantial number of previously unknown vulnerabilities, and the median time to patch for confirmed reports was short <ref:2602.00667#pg2> Implementation Details The system supports two production-ready commitment/IOP combinations, HyperPlonk+ and BaseFold <ref:2602.00667#pg2> The runtime selects the ZK-native backend only when the degree and domain limits of the chosen backend are respected <ref:2602.00667#pg2> The LLM oracle is treated as an untrusted, deterministic suggestion source, and canonicalization normalizes whitespace and removes blank lines <ref:2602.00667#pg2> The final verification step checks that the synthesized counterexample indeed violates the targeted TCCT property <ref:2602.00667#pg2> The system is currently single-threaded, but all major stages are highly parallelizable, with preliminary OpenCL kernels on an NVIDIA A100 achieving a 7.3× speed-up for 50k constraints <ref:2602.00667#pg2> The main bottleneck is memory bandwidth because Row-Vortex polynomials must reside in global memory during opening <ref:2602.00667#pg2> The paper concludes that zkCraft combines targeted mutation, algebraic reasoning, and optional LLM-assisted acceleration for fast, scalable, and precise vulnerability detection <ref:2602.00667#pg2> References
1: Shankara Pailoor et al.
Nadia: Automated detection of under-constrained circuits in zero-knowledge proofs <ref:2602.00667#pg2>
3: Santiago Cuéllar Gempeler et al.
Elias: Cheesecloth: Zero-knowledge proofs of real-world vulnerabilities <ref:2602.00667#pg2>
4: Dongwei Xiao et al.
Nadia: Mtzk: Testing and exploring bugs in zero-knowledge (zk) compilers <ref:2602.00667#pg2>
5: Noga Ron-Zewi and Mor Weiss.
Paper summary: Nadia: So to wrap up on "zkCraft: Prompt-Guided LLM as a Zero-Shot Mutation Pattern Oracle for TCCT-Powered ZK Fuzzing", the paper presents this framework that combines deterministic, R1CS-aware localization with proofbearing search. Elias It’s really about reducing the task of finding small edits to a single algebraic existence statement encoded as a Row-Vortex polynomial and certifying it with a Violation IOP.
Priya: The implications for us are that we can use this to systematically find subtle bugs in zero-knowledge circuits, not just stumble upon them during standard fuzzing. This moves us toward more robust verification methods for privacy systems.
Nadia: Exactly. The paper shows that using an LLM as a deterministic template oracle helps bias the search toward edge cases while still having auditable algebraic verification alongside it <ref:2602.00667#pg2>. It’s a way to use the LLM’s suggestion quality without letting it completely derail the formal process.
Elias: The authors conclude that this method allows for fast, scalable, and precise vulnerability detection by combining targeted mutation, algebraic reasoning, and optional LLM-assisted acceleration <ref:2602.00667#pg2>. It’s a practical pipeline for developers dealing with the tight coupling between witness computation and circuit constraints.
Conclusion: Nadia: So, we’ve looked at how zkCraft uses an LLM to find bugs in zero-knowledge circuits, and now we need to talk about what that whole title says about the paper itself and who wrote it.
Elias: Yeah, let's get into the actual names. The authors are focusing on this idea of using a prompt-guided LLM as a pattern oracle for TCCT powered fuzzing.
Priya: From my angle, I want to know what that means for the privacy side—what kind of real-world vulnerability detection we’re actually getting here.
Nadia: The paper is trying to bridge that gap between formal verification and automated debugging by using a specific framework called zkCraft.
Elias: It’s about taking those hard, combinatorial searches for small edits and turning them into one algebraic existence statement, which they encode as a Row-Vortex polynomial.
Priya: So the method cuts down the search space significantly because it uses this algebraic structure to prune the possibilities before we even look at them.
Nadia: Right. And then they use a Violation IOP to certify that when you find those edits, you’ve actually found something different from what was supposed to happen in the circuit.
Elias: That proof-as-counterexample is key here; it lets the system reconstruct the exact trace of the mistake using some interpolation or solving an algebraic system.
Priya: So, if we trust this framework, we're looking at a way to systematically find small, tricky bugs in circuits that are hard to catch otherwise.
Nadia: Exactly. The authors claim they get very high true positive counts while keeping the precision really good across different circuit sizes.
Elias: They also noted that the LLM oracle is treated as an untrusted suggestion source, which makes it a practical tool rather than a guaranteed solution for correctness itself.
Priya: But what’s left is still that memory bandwidth issue with those Row-Vortex polynomials having to live in global memory during the opening of the system.
Nadia: That’s the current bottleneck they flagged, so while it's very fast on specialized hardware like an NVIDIA A100, it's not a perfect turnkey solution yet.
Elias: So, zkCraft is this targeted mutation strategy combined with algebraic reasoning and optional LLM acceleration for finding those tricky vulnerabilities quickly.
Priya: It’s a practical pipeline that moves us closer to robust ZK circuit development by making the process scalable.
Nadia: So, the paper basically shows how we can use these tools together to do targeted mutation while keeping our verification rigorous and scalable.
Elias: The real question now is whether this framework can handle the complexity of modern, large-scale zero-knowledge systems effectively.
cs.CR
Submitted: 2026-01-31
Updated: 2026-10-29
Comments: 36 pages, 12 figures, 9 tables
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 92/100
The gist: Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement correctly due to the tight coupling between witness computation and circuit constraints…
Key concepts
- Zero-knowledge circuits
- These are mathematical structures used in cryptography that allow one party to prove they know a secret without revealing the secret itself. They are fundamental to privacy-preserving systems, but ensuring their correctness is complex.
- R1CS-aware localization
- This technique uses algebraic methods, specifically Row-Lattice constraints (R1CS), to pinpoint potential areas in a circuit where small changes might cause a violation of the intended logic. It helps narrow down the vast search space for bugs.
- Violation IOP
- An Interactive Oracle Proof (IOP) is a cryptographic tool used to efficiently prove that a proposed modification actually breaks the circuit's security properties. It acts as a fast, verifiable check for potential vulnerabilities.
- LLM Oracles
- Large Language Models are used here not to solve the entire problem, but to act as smart suggestions. They provide zero-shot mutation templates—predefined patterns of edits—that guide the search process toward likely bug locations.
Terminology
Summary
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement correctly due to the tight coupling between witness computation and circuit constraints <ref:2602. p. 0 ZKCRAFT: PROMPT-GUIDED LLM AS A ZERO-SHOT MUTATION
PATTERN ORACLE FOR TCCT-POWERED ZK FUZZING
Rong Fu
Independent Researcher
Corresponding author
Jia Yee Tan
Independent Researcher
Ziyu Kong
Independent Researcher
Shuning Zhang
Independent Researcher
Xianda Li
Independent Researcher
Kun Liu
Independent Researcher
Youjin Wang
Independent Researcher
Simon Fong
Independent Researcher
August 4, 2026
ABSTRACT
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement
correctly due to the tight coupling between witness computation and circuit constraints. We present
zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies. ZKCRAFT: PROMPT-GUIDED LLM AS A ZERO-SHOT MUTATION
PATTERN ORACLE FOR TCCT-POWERED ZK FUZZING
Rong Fu
Independent Researcher
Corresponding author
Jia Yee Tan
Independent Researcher
Ziyu Kong
Independent Researcher
Shuning Zhang
Independent Researcher
Xianda Li
Independent Researcher
Kun Liu
Independent Researcher
Youjin Wang
Independent Researcher
Simon Fong
Independent Researcher
August 4, 2026
ABSTRACT
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement
correctly due to the tight coupling between witness computation and circuit constraints. We present
zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies. Evaluation on
real Circom code shows that proof-bearing localization detects diverse under- and over-constrained
faults with low false positives and reduces costly solver interaction. Our approach bridges formal
verification and automated debugging, offering a scalable path for robust ZK circuit development.Where the paper says it
Where the paper says it
Where the paper says it
Framework Overview
zkCraft is a ZK-native pipeline that tightly couples algebraic localization, succinct violation proofs, and deterministic, prompt-guided mutation templates <ref:2602.00667#pg5> It reduces the combinatorial task of finding small, vulnerability-inducing edits to a single algebraic existence statement encoded as a Row-Vortex polynomial and certified with a Violation IOP <ref:2602. p. 1 zkCraft reduces the combinatorial
task of finding small, vulnerability-inducing edits to a single algebraic existence statement. It constructs compact
per-row fingerprints to prioritize a limited candidate pool, encodes row selection and substitution parameters as a
Row-Vortex polynomial, and asks a prover to produce a Violation interactive oracle proof that certifies the existence of
a witness satisfying the edited constraints while yielding a different public output. In Stage 1 (The Slicer), a Sparse Fingerprint
Scanner computes diagnostic scores to prune the constraint space into a manageable Candidate Pool Rcand. This
process is accelerated by the LLM Oracles, which provide zero-shot Mutation Templates and learn vulnerability
patterns to bias the search.Where the paper says it
Where the paper says it
Search Methodology
The search for small, vulnerability-causing edits is mapped to a single algebraic existence statement encoded as a Row-Vortex polynomial and certified with a Violation IOP <ref:2602.00667#pg6> Stage 1 involves Sparse signature extraction, where diagnostic scores are computed to prune the constraint space into a manageable Candidate Pool Rcand <ref:2602. p. 3 The pipeline begins at the Input
Layer, where a Circom program is decomposed into R1CS matrices. In Stage 1 (The Slicer), a Sparse Fingerprint
Scanner computes diagnostic scores to prune the constraint space into a manageable Candidate Pool Rcand. We design deterministic LLM interfaces that act as zero-shot mutation-template oracles to propose
right-hand-side edits and input-sampling biases while remaining decoupled from proof generation. We describe practical
implementation techniques for compact per-row fingerprinting, a scoring heuristic to select a small candidate pool,
and a deterministic finite-field synthesis that recovers concrete substitutions from proof-embedded encodings.Where the paper says it
Where the paper says it
Proof Certification and Extraction
The Violation IOP certifies the existence of a witness satisfying the edited constraints while yielding a different public output <ref:2602.00667#pg6> The resulting Succinct Proof π serves as a Proof-as-Counterexample, from which the Witness Extraction machinery reconstructs the concrete trace to confirm the vulnerability via TCCT <ref:2602. p. 3 A Violation IOP (utilizing algebraic Sum-Check identities) then searches for a witness that
satisfies the edited constraints while diverging from the original output. The resulting Succinct Proof π serves as a
Proof-as-Counterexample, from which the Witness Extraction machinery reconstructs the concrete trace to confirm
the vulnerability via TCCT. 5 Proof-as-counterexample (verification and extraction)
A verifier’s successful validation of the succinct proof π certifies the existence of a witness satisfying the target algebraic
statement in Eq. Our practical extraction policy is two-fold: either the verifier reconstructs the finite tuple (δ, c, w′
)
from openings produced against the polynomial commitment Comm(R), or the proof itself contains an auditable
encoding of the concrete counterexample (x
′
, z′
, y′
).Where the paper says it
Where the paper says it
Performance and Evaluation
zkCraft achieves the highest true positive counts while maintaining very high precision across all circuit size buckets <ref:2602.00667#pg2> The ZK-native mode accounts for 93 % of the successful runs, adding less than 3 % to the total running time compared with a plain TCCT replay <ref:2602.00667#pg2> It uncovers a substantial number of previously unknown vulnerabilities, and the median time to patch for confirmed reports was short <ref:2602.00667#pg2>
Implementation Details
The system supports two production-ready commitment/IOP combinations, HyperPlonk+ and BaseFold <ref:2602.00667#pg2> The runtime selects the ZK-native backend only when the degree and domain limits of the chosen backend are respected <ref:2602. p. 1 Compilers and zkVM toolchains introduce additional complexity related to optimization and backend
behavior, which further complicates end-to-end detection and increases the cost of exhaustive solver-based validation
[22, 23, 24, 25]. Motivated by these observations, we design zkCraft, a ZK-native pipeline that tightly couples algebraic localization,
succinct violation proofs, and deterministic, prompt-guided mutation templates. In the final step, the prover opens the commitment Comm(R) at the sampled X-coordinates and supplies evaluation
proofs. The verifier checks that the openings are consistent with Comm(R) under the chosen commitment scheme, that
the Sum-Check consistency relations hold at the sampled challenges, and that the divergence indicator is nonzero for at
least one sampled challenge, namely ∆out(ζk) ̸= 0 for some k. Most algebraic and IOP-style techniques have not been integrated
with practical program-level mutation strategies, so solver costs remain a bottleneck for end-to-end bug discovery. arXiv:2602. Most algebraic and IOP-style techniques have not been integrated
with practical program-level mutation strategies, so solver costs remain a bottleneck for end-to-end bug discovery. arXiv:2602. ZKCRAFT: PROMPT-GUIDED LLM AS A ZERO-SHOT MUTATION
PATTERN ORACLE FOR TCCT-POWERED ZK FUZZING
Rong Fu
Independent Researcher
Corresponding author
Jia Yee Tan
Independent Researcher
Ziyu Kong
Independent Researcher
Shuning Zhang
Independent Researcher
Xianda Li
Independent Researcher
Kun Liu
Independent Researcher
Youjin Wang
Independent Researcher
Simon Fong
Independent Researcher
August 4, 2026
ABSTRACT
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement
correctly due to the tight coupling between witness computation and circuit constraints. We present
zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
References
[1] Shankara Pailoor et al. Automated detection of under-constrained circuits in zero-knowledge proofs <ref:2602. p. 0 Our approach bridges formal
verification and automated debugging, offering a scalable path for robust ZK circuit development. Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems.Where the paper says it
[3] Santiago Cuéllar Gempeler et al. Cheesecloth: Zero-knowledge proofs of real-world vulnerabilities <ref:2602. p. 2 Efforts to improve circuit description languages and make them amenable to static verification encourage safer ZK
application development [45, 51]. Compiler-focused fuzzing and white-box analysis have uncovered deep logic bugs in
real-world compilers, motivating tighter integration of source-level diagnostics with pipeline-level checks [33, 4].Where the paper says it
[4] Dongwei Xiao et al. Mtzk: Testing and exploring bugs in zero-knowledge (zk) compilers <ref:2602. p. 1 2 Related Work
2. 1 Correctness and verification of ZK pipelines and compilers
The correctness of zero-knowledge compilation and circuit-processing pipelines has attracted growing attention because
compiler or pipeline bugs can yield accepted yet invalid proofs.Where the paper says it
[5] Noga Ron-Zewi and Mor Weiss. Zero-knowledge iops approaching witness length <ref:2602. p. 0 ZKCRAFT: PROMPT-GUIDED LLM AS A ZERO-SHOT MUTATION
PATTERN ORACLE FOR TCCT-POWERED ZK FUZZING
Rong Fu
Independent Researcher
Corresponding author
Jia Yee Tan
Independent Researcher
Ziyu Kong
Independent Researcher
Shuning Zhang
Independent Researcher
Xianda Li
Independent Researcher
Kun Liu
Independent Researcher
Youjin Wang
Independent Researcher
Simon Fong
Independent Researcher
August 4, 2026
ABSTRACT
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement
correctly due to the tight coupling between witness computation and circuit constraints. We present
zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies.Where the paper says it
[8] Khoa Tan Vo et al. Zcls: A lifecycle strategy for efficient zk-rollup circuit optimization in circom <ref:2602.00667#pg2>
[9] Marco Stronati et al. Clap: a semantic-preserving optimizing edsl for plonkish proof systems <ref:2602. p. 0 ZKCRAFT: PROMPT-GUIDED LLM AS A ZERO-SHOT MUTATION
PATTERN ORACLE FOR TCCT-POWERED ZK FUZZING
Rong Fu
Independent Researcher
Corresponding author
Jia Yee Tan
Independent Researcher
Ziyu Kong
Independent Researcher
Shuning Zhang
Independent Researcher
Xianda Li
Independent Researcher
Kun Liu
Independent Researcher
Youjin Wang
Independent Researcher
Simon Fong
Independent Researcher
August 4, 2026
ABSTRACT
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement
correctly due to the tight coupling between witness computation and circuit constraints. We present
zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies.Where the paper says it
[13] Zongyang Zhang et al. Fast RSIOP multivariate polynomial commitments and verifiable secret sharing <ref:2602. p. 2 5 ZK-native proof techniques, commitments, and succinct verification
Recent advances in polynomial commitments, IOPs and succinct proof systems enable encoding higher-level search
oracles as compact ZK statements. Systems that adopt ZK-native encodings show how commitment-and-IOP primitives
can be repurposed to certify existential properties about edits and witnesses, thereby converting existential search into a
single verifiable artifact [44, 45, 46].Where the paper says it
[14] Zongyang Zhang et al. Ligerolight: Optimized iop-based zero-knowledge argument for blockchain scalability <ref:2602. p. 0 Our approach bridges formal
verification and automated debugging, offering a scalable path for robust ZK circuit development. Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems.Where the paper says it
[15] Ruijie Meng et al. Large language model guided protocol fuzzing <ref:2602. p. 0 Recent work on verifier-side encodings, interactive oracle proofs, and efficient polynomial commitments
offers promising primitives to compress or certify search outcomes [5, 13, 14]. In parallel, advances in model-guided
mutation and LLM-driven fuzzing have shown that language models can generate semantically rich test patterns and
seed mutations for security testing [15, 16, 17, 18, 19, 20].Where the paper says it
[19] Maor Ashkenazi et al. Zero-shot detection of llm-generated code via approximated task conditioning <ref:2602.00667#pg2>
[39] Zhantong Xue et al. From evaluation to enhancement: Large language models for zero-knowledge proof code generation <ref:2602. p. 0 Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems. Writing correct circuits is difficult because
the witness generator that computes private values must align precisely with the constraint system used for proof
verification.Where the paper says it
[43] José Bacelar Almeida et al. Machine-checked zkp for np relations: Formally verified security proofs and implementations of mpc-in-the-head <ref:2602. p. 2 For ZK circuit mutation and verification, solver-guided fallback channels that ground small
template families and use finite-field SMT/SAT queries remain practical when pure ZK-native IOPs are infeasible; this
hybrid approach balances completeness and engineering constraints [42, 43]. Machine-checked proofs and formally
verified protocol implementations provide strong guarantees and serve as an orthogonal means to reduce the trusted
code base for ZK constructions [43, 42].Where the paper says it
[45] Marta Bellés-Muñoz et al. Circom: A circuit description language for building zero-knowledge applications <ref:2602. p. 0 Our approach bridges formal
verification and automated debugging, offering a scalable path for robust ZK circuit development. Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems.Where the paper says it
[49] Nikola Samardzic et al. Accelerating zero-knowledge proofs through hardware-algorithm co-design <ref:2602. p. 2 Systems that adopt ZK-native encodings show how commitment-and-IOP primitives
can be repurposed to certify existential properties about edits and witnesses, thereby converting existential search into a
single verifiable artifact [44, 45, 46]. GPU-accelerated proof systems and hardware-algorithm co-design work illustrate
routes to practical prover performance that scale to larger circuits [47, 48, 49].Where the paper says it
[53] Zhibo Xing et al. Zero-knowledge proof-based verifiable decentralized machine learning in communication network: A comprehensive survey <ref:2602. p. 2 Tools
that certify circuits with refinement types or other higher-level specifications reduce a class of errors by construction
and complement testing-based approaches [52, 32]. 7 Applications, surveys, and domain-specific ZK use cases
Zero-knowledge proofs are being applied widely, from verifiable decentralized machine learning to privacy-preserving
credentialing and domain-specific verification tasks [53, 54, 55]. Tools
that certify circuits with refinement types or other higher-level specifications reduce a class of errors by construction
and complement testing-based approaches [52, 32]. 7 Applications, surveys, and domain-specific ZK use cases
Zero-knowledge proofs are being applied widely, from verifiable decentralized machine learning to privacy-preserving
credentialing and domain-specific verification tasks [53, 54, 55]. Tools
that certify circuits with refinement types or other higher-level specifications reduce a class of errors by construction
and complement testing-based approaches [52, 32]. 7 Applications, surveys, and domain-specific ZK use cases
Zero-knowledge proofs are being applied widely, from verifiable decentralized machine learning to privacy-preserving
credentialing and domain-specific verification tasks [53, 54, 55].Where the paper says it
Where the paper says it
Where the paper says it
[54] Juan Alamrio Berrios Moya et al. A zero-knowledge proof-enabled blockchainbased academic record verification system <ref:2602. p. 0 Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems. Writing correct circuits is difficult because
the witness generator that computes private values must align precisely with the constraint system used for proof
verification. Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems. Writing correct circuits is difficult because
the witness generator that computes private values must align precisely with the constraint system used for proof
verification. Keywords zero-knowledge proofs, fuzzing, Circom, TCCT, Row-Vortex commitment, Violation IOP, large language
models, mutation testing
1 Introduction
Zero-knowledge circuits provide succinct, verifiable proofs while exposing minimal information about private inputs,
and they form the foundation of many privacy and scalability systems. Writing correct circuits is difficult because
the witness generator that computes private values must align precisely with the constraint system used for proof
verification.Where the paper says it
Where the paper says it
Where the paper says it
[58] Abdu Salam et al. Securing smart manufacturing by integrating anomaly detection with zero-knowledge proofs <ref:2602. p. 2 Surveys and systematizations contextualize verifiability
challenges and catalog practical design patterns and open problems for ZKP-based applications [56, 57]. Domain work
that integrates anomaly detection, sensing, or constrained hardware contexts highlights practical verification needs in
applied settings [58, 59, 60]. Surveys and systematizations contextualize verifiability
challenges and catalog practical design patterns and open problems for ZKP-based applications [56, 57]. Domain work
that integrates anomaly detection, sensing, or constrained hardware contexts highlights practical verification needs in
applied settings [58, 59, 60].Where the paper says it
Where the paper says it
[59] Seonghwan Park et al. Mecat: Memory-safe smart contracts in arm trustzone <ref:2602. p. 0 Most algebraic and IOP-style techniques have not been integrated
with practical program-level mutation strategies, so solver costs remain a bottleneck for end-to-end bug discovery. arXiv:2602. Most algebraic and IOP-style techniques have not been integrated
with practical program-level mutation strategies, so solver costs remain a bottleneck for end-to-end bug discovery. arXiv:2602.Where the paper says it
Where the paper says it
[51] Alex Ozdemir et al. Circ: Compiler infrastructure for proof systems, software verification, and more <ref:2602. p. 1 Systematic fuzzing of
end-to-end ZK pipelines has also been shown to surface logic bugs that elude conventional testing, illustrating the
importance of domain-aware test oracles for pipelines that span DSL, compiler, and proof-generation layers [27, 28]. 2 Fuzzing, metamorphic testing, and oracles for ZK systems
Fuzzing and metamorphic testing have been successfully adapted to find pipeline-level and finalization bugs in ZK
deployments, including rollup finalization failures and pipeline logic flaws; these techniques emphasize careful oracle
design and input-generation strategies to trigger diverse behaviors [26, 29].Where the paper says it
[53] Zhibo Xing et al. Zero-knowledge proof-based verifiable decentralized machine learning in communication network: A comprehensive survey <ref:2602.00667#pg2>
[54] Juan Alamrio Berrios Moya et al. A zero-knowledge proof-enabled blockchainbased academic record verification system <ref:2602.00667#pg2>
[58] Abdu Salam et al. Securing smart manufacturing by integrating anomaly detection with zero-knowledge proofs <ref:2602.00667#pg2>
[59] Seonghwan Park et al. Mecat: Memory-safe smart contracts in arm trustzone <ref:2602.00667#pg2>
[44] Dimitris Mouris and Nektarios Georgios Tsoutsos. Zilch: A framework for deploying transparent zero-knowledge proofs <ref:2602. p. 0 ZKCRAFT: PROMPT-GUIDED LLM AS A ZERO-SHOT MUTATION
PATTERN ORACLE FOR TCCT-POWERED ZK FUZZING
Rong Fu
Independent Researcher
Corresponding author
Jia Yee Tan
Independent Researcher
Ziyu Kong
Independent Researcher
Shuning Zhang
Independent Researcher
Xianda Li
Independent Researcher
Kun Liu
Independent Researcher
Youjin Wang
Independent Researcher
Simon Fong
Independent Researcher
August 4, 2026
ABSTRACT
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement
correctly due to the tight coupling between witness computation and circuit constraints. We present
zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies.Where the paper says it
[53] Zhibo Xing et al. Zero-knowledge proof-based verifiable decentralized machine learning in communication network: A comprehensive survey <ref:2602.00667#pg2>
[54] Juan Alamrio Berrios Moya et al. A zero-knowledge proof-enabled blockchainbased academic record verification system <ref:2602.00667#pg2>
[58] Abdu Salam et al.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
ZK-native search framework for bug detection: The system can map
the search for small, vulnerability-inducing edits to a single algebraic existence statement encoded as a Row-Vortex polynomial and certified with a Violation IOP.
This allows the AI to efficiently find faults by reducing the combinatorial task of finding small edits to one verifiable statement. -
Deterministic LLM-driven mutation templates: The AI can use
deterministic LLM interfaces that act as zero-shot mutation-template oracles to propose right-hand-side edits and input-sampling biases while remaining decoupled from proof generation.
This biases exploration toward edge cases, which helps the system discoverdiverse under- and over-constrained faults.
-
Proof as counterexample workflow: The system can generate a
Proof-as-Counterexample
that serves as anauditable counterexample from which concrete substitutions can be recovered,
effectively providing aconcrete counterexample (x′, z′, y′) that can be reconstructed for developer inspection.
This streamlines debugging by producing evidence without requiring a full TCCT re-execution. -
Automated extraction and synthesis: The AI can execute the
Extractor
described in Algorithm 1, which performs a deterministic procedure toreconstruct the finite tuple (δ, c, w′)
and then synthesize the mutated source P′ by substituting constants into weak-assignment sites. This results in a fully realized program with an explicit fault trace. -
Hybrid solver-assisted fallback: The system can switch to a
solver-guided path
when ZK-native methods are impractical, performingquantifierfree finite-field SMT/SAT queries for increasing edit cardinalities up to the configured budget.
This ensures completeness by maintaining the ability to find solutions via traditional algebraic checks.
Abstract
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement correctly due to the tight coupling between witness computation and circuit constraints. We present zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proof-bearing search to detect semantic inconsistencies. zkCraft encodes candidate constraint edits into a single Row-Vortex polynomial and replaces repeated solver queries with a Violation IOP that certifies the existence of edits together with a succinct proof. Deterministic LLM-driven mutation templates bias exploration toward edge cases while preserving auditable algebraic verification. Evaluation on real Circom code shows that proof-bearing localization detects diverse under- and over-constrained faults with low false positives and reduces costly solver interaction. Our approach bridges formal verification and automated debugging, offering a scalable path for robust ZK circuit development.
Sources
- Clap: a Semantic-Preserving Optimizing eDSL for Plonkish Proof Systems
- Semantic-Aware Fuzzing: An Empirical Framework for LLM-Guided, Reasoning-Driven Input Mutation
- Large Language Models for Unit Testing: A Systematic Literature Review
- Evaluating Compiler Optimization Impacts on zkVM Performance
- BlockA2A: Towards Secure and Verifiable Agent-to-Agent Interoperability
- Arguzz: Testing zkVMs for Soundness and Completeness Bugs
- From Evaluation to Enhancement: Large Language Models for Zero-Knowledge Proof Code Generation
- if-ZKP: Intel FPGA-Based Acceleration of Zero Knowledge Proofs
- A Survey on the Applications of Zero-Knowledge Proofs
- SoK: Understanding zk-SNARKs: The Gap Between Research and Practice
- ZK-SenseLM: Verifiable Large-Model Wireless Sensing with Selective Abstention and Zero-Knowledge Attestation
- QCRMut: Quantum Circuit Random Mutant generator tool
- zkFuzz: Foundation and Framework for Effective Fuzzing of Zero-Knowledge Circuits
- AC4: Algebraic Computation Checker for Circuit Constraints in ZKPs
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data