zkCraft: Prompt-Guided LLM as a Zero-Shot Mutation Pattern Oracle for TCCT-Powered ZK Fuzzing

arXiv:2602.00667 · cs.CR · Submitted 2026-01-31 · Read on arXiv

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

Where the paper says it

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.

00667#pg2> The paper presents zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proofbearing search to detect semantic inconsistencies <ref:2602. p. 0
Where the paper says it

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.

00667#pg4> This approach bridges formal verification and automated debugging, offering a scalable path for robust ZK circuit development <ref:2602. p. 0
Where the paper says it

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.

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. p. 1

Where the paper says it

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.

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. p. 3
Where the paper says it

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.

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. p. 3

Where the paper says it

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.

00667#pg2> Stage 3 utilizes deterministic finite-field synthesis to recover concrete substitutions from proof-embedded encodings <ref:2602. p. 1
Where the paper says it

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.

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. p. 3

Where the paper says it

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.

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. p. 9
Where the paper says it

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′ ).

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. p. 1

Where the paper says it

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.

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. p. 9
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

00667#pg2> The main bottleneck is memory bandwidth because Row-Vortex polynomials must reside in global memory during opening <ref:2602. p. 0
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

00667#pg2>

References

[1] Shankara Pailoor et al. Automated detection of under-constrained circuits in zero-knowledge proofs <ref:2602. p. 0

Where the paper says it

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.

00667#pg2>

[3] Santiago Cuéllar Gempeler et al. Cheesecloth: Zero-knowledge proofs of real-world vulnerabilities <ref:2602. p. 2

Where the paper says it

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].

00667#pg2>

[4] Dongwei Xiao et al. Mtzk: Testing and exploring bugs in zero-knowledge (zk) compilers <ref:2602. p. 1

Where the paper says it

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.

00667#pg2>

[5] Noga Ron-Zewi and Mor Weiss. Zero-knowledge iops approaching witness length <ref:2602. p. 0

Where the paper says it

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.

00667#pg2>

[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

Where the paper says it

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.

00667#pg2>

[13] Zongyang Zhang et al. Fast RSIOP multivariate polynomial commitments and verifiable secret sharing <ref:2602. p. 2

Where the paper says it

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].

00667#pg2>

[14] Zongyang Zhang et al. Ligerolight: Optimized iop-based zero-knowledge argument for blockchain scalability <ref:2602. p. 0

Where the paper says it

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.

00667#pg2>

[15] Ruijie Meng et al. Large language model guided protocol fuzzing <ref:2602. p. 0

Where the paper says it

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].

00667#pg2>

[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

Where the paper says it

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.

00667#pg2>

[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

Where the paper says it

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].

00667#pg2>

[45] Marta Bellés-Muñoz et al. Circom: A circuit description language for building zero-knowledge applications <ref:2602. p. 0

Where the paper says it

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.

00667#pg2>

[49] Nikola Samardzic et al. Accelerating zero-knowledge proofs through hardware-algorithm co-design <ref:2602. p. 2

Where the paper says it

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].

00667#pg2>

[53] Zhibo Xing et al. Zero-knowledge proof-based verifiable decentralized machine learning in communication network: A comprehensive survey <ref:2602. p. 2

Where the paper says it

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].

p. 2
Where the paper says it

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].

p. 2
Where the paper says it

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].

00667#pg2>

[54] Juan Alamrio Berrios Moya et al. A zero-knowledge proof-enabled blockchainbased academic record verification system <ref:2602. p. 0

Where the paper says it

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.

p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

00667#pg2>

[58] Abdu Salam et al. Securing smart manufacturing by integrating anomaly detection with zero-knowledge proofs <ref:2602. p. 2

Where the paper says it

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].

p. 2
Where the paper says it

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].

00667#pg2>

[59] Seonghwan Park et al. Mecat: Memory-safe smart contracts in arm trustzone <ref:2602. p. 0

Where the paper says it

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.

p. 0
Where the paper says it

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.

00667#pg2>

[51] Alex Ozdemir et al. Circ: Compiler infrastructure for proof systems, software verification, and more <ref:2602. p. 1

Where the paper says it

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].

00667#pg2>

[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

Where the paper says it

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.

00667#pg2>

[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

  1. 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.

  2. 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 discover diverse under- and over-constrained faults.

  3. Proof as counterexample workflow: The system can generate a Proof-as-Counterexample that serves as an auditable counterexample from which concrete substitutions can be recovered, effectively providing a concrete counterexample (x′, z′, y′) that can be reconstructed for developer inspection. This streamlines debugging by producing evidence without requiring a full TCCT re-execution.

  4. Automated extraction and synthesis: The AI can execute the Extractor described in Algorithm 1, which performs a deterministic procedure to reconstruct 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.

  5. Hybrid solver-assisted fallback: The system can switch to a solver-guided path when ZK-native methods are impractical, performing quantifierfree 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

Related papers