From 644c369aede8be8afd4165beed76c5518a490665 Mon Sep 17 00:00:00 2001 From: M Alghazwi Date: Thu, 24 Apr 2025 20:56:35 +0200 Subject: [PATCH] add proof tracking tests --- proof-input/src/recursion/leaf_test.rs | 150 +++++++++++++++++++++++++ proof-input/src/recursion/mod.rs | 3 +- proof-input/src/recursion/uniform.rs | 25 +++-- 3 files changed, 165 insertions(+), 13 deletions(-) create mode 100644 proof-input/src/recursion/leaf_test.rs diff --git a/proof-input/src/recursion/leaf_test.rs b/proof-input/src/recursion/leaf_test.rs new file mode 100644 index 0000000..6930242 --- /dev/null +++ b/proof-input/src/recursion/leaf_test.rs @@ -0,0 +1,150 @@ +// some tests for the leaf in tree recursion + +#[cfg(test)] +mod tests { + use plonky2::plonk::circuit_data::{ProverCircuitData, VerifierCircuitData}; + use plonky2::plonk::proof::ProofWithPublicInputs; + use plonky2_field::types::{Field, PrimeField64}; + use codex_plonky2_circuits::circuit_helper::Plonky2Circuit; + use codex_plonky2_circuits::circuits::sample_cells::SampleCircuit; + use codex_plonky2_circuits::recursion::leaf::{LeafCircuit, LeafInput}; + use codex_plonky2_circuits::recursion::node::{NodeCircuit, NodeInput}; + use codex_plonky2_circuits::recursion::dummy_gen::DummyProofGen; + use crate::params::{F, D, C, HF}; + use crate::gen_input::gen_testing_circuit_input; + use crate::params::Params; + + fn run_sampling_circ() -> anyhow::Result<(ProofWithPublicInputs, ProverCircuitData, VerifierCircuitData)> { + //------------ sampling inner circuit ---------------------- + // Circuit that does the sampling - 100 samples + let mut params = Params::default(); + params.set_n_samples(100); + let one_circ_input = gen_testing_circuit_input::(¶ms.input_params); + let samp_circ = SampleCircuit::::new(params.circuit_params); + let (inner_tar, inner_data) = samp_circ.build_with_standard_config()?; + + let inner_verifier_data = inner_data.verifier_data(); + let inner_prover_data = inner_data.prover_data(); + + println!("sampling circuit degree bits = {:?}", inner_verifier_data.common.degree_bits()); + let inner_proof = samp_circ.prove(&inner_tar, &one_circ_input, &inner_prover_data)?; + + Ok((inner_proof, inner_prover_data, inner_verifier_data)) + } + + fn run_leaf_circ(inner_proof: ProofWithPublicInputs, inner_verifier_data: VerifierCircuitData, flag: bool, index: usize) -> anyhow::Result<()> { + + // ------------------- leaf -------------------- + // N inner proofs + + let leaf = LeafCircuit::::new(inner_verifier_data.common.clone(),inner_verifier_data.verifier_only.clone()); + + // build + let (targets, data) = leaf.build_with_standard_config()?; + let verifier_data: VerifierCircuitData = data.verifier_data(); + let prover_data = data.prover_data(); + println!("leaf circuit degree bits = {:?}", prover_data.common.degree_bits()); + + // prove + let input = LeafInput{ + inner_proof: vec![inner_proof], + flag, + index, + }; + let proof = leaf.prove(&targets, &input, &prover_data)?; + println!("pub input size = {}", proof.public_inputs.len()); + println!("proof size = {:?} bytes", proof.to_bytes().len()); + println!("pub input = {:?}", proof.public_inputs); + + // verify + assert!( + verifier_data.verify(proof.clone()).is_ok(), + "proof verification failed" + ); + + let flag_buckets: Vec = proof.public_inputs[9..13].to_vec(); + if flag { + check_flag_buckets(index, flag_buckets); + } else { + for i in 0..flag_buckets.len() { + assert_eq!(flag_buckets[i], F::ZERO, "bucket not valid"); + } + } + + Ok(()) + } + + fn check_flag_buckets(index: usize, flag_buckets: Vec) { + // Compute the bucket and bit position from the input index. + let bucket = index / 32; + let bit = index % 32; + // For each flag target (bucket), assign the appropriate 32-bit one-hot value. + for (i, &flag_bucket) in flag_buckets.iter().enumerate() { + let value: u64 = if i == bucket { + 1 << bit + } else { + 0 + }; + assert_eq!(value, flag_bucket.to_canonical_u64(), "bucket value mismatch"); + } + } + + fn run_node_circ(leaf_proof: ProofWithPublicInputs, leaf_verifier_data: VerifierCircuitData, flag: bool, index: usize) -> anyhow::Result<()> { + + // ------------------- Node -------------------- + // M leaf proofs + + let node = NodeCircuit::::new(leaf_verifier_data.common.clone(), leaf_verifier_data.verifier_only.clone()); + + // build + let (targets, data) = node.build_with_standard_config()?; + let verifier_data: VerifierCircuitData = data.verifier_data(); + let prover_data = data.prover_data(); + println!("node circuit degree bits = {:?}", prover_data.common.degree_bits()); + + // prove + let input = NodeInput{ + node_proofs: vec![leaf_proof.clone(), leaf_proof.clone()], + verifier_only_data: leaf_verifier_data.verifier_only, + condition: false, + flags: [true; M].to_vec(), + index, + }; + let proof = node.prove(&targets, &input, &prover_data)?; + println!("pub input size = {}", proof.public_inputs.len()); + println!("proof size = {:?} bytes", proof.to_bytes().len()); + println!("pub input = {:?}", proof.public_inputs); + + // verify + assert!( + verifier_data.verify(proof.clone()).is_ok(), + "proof verification failed" + ); + + // let flag_buckets: Vec = proof.public_inputs[9..13].to_vec(); + // if flag { + // check_flag_buckets(index, flag_buckets); + // } else { + // for i in 0..flag_buckets.len() { + // assert_eq!(flag_buckets[i], F::ZERO, "bucket not valid"); + // } + // } + + Ok(()) + } + + #[test] + fn test_real_leaf_circ() -> anyhow::Result<()> { + let (inner_proof, _, inner_verifier) = run_sampling_circ()?; + + run_leaf_circ::<1, 1>(inner_proof, inner_verifier, true, 1) + } + + #[test] + fn test_dummy_leaf_circ() -> anyhow::Result<()> { + let (_, _, inner_verifier) = run_sampling_circ()?; + let (dummy_proof, dummy_vd) = DummyProofGen::gen_dummy_proof_and_vd_zero_pi(&inner_verifier.common)?; + run_leaf_circ::<1, 1>(dummy_proof, dummy_vd, false, 0) + } + +} \ No newline at end of file diff --git a/proof-input/src/recursion/mod.rs b/proof-input/src/recursion/mod.rs index 6f4d83f..c7f7e80 100644 --- a/proof-input/src/recursion/mod.rs +++ b/proof-input/src/recursion/mod.rs @@ -1 +1,2 @@ -pub mod uniform; \ No newline at end of file +pub mod uniform; +pub mod leaf_test; \ No newline at end of file diff --git a/proof-input/src/recursion/uniform.rs b/proof-input/src/recursion/uniform.rs index db1fb19..8fa121f 100644 --- a/proof-input/src/recursion/uniform.rs +++ b/proof-input/src/recursion/uniform.rs @@ -8,9 +8,9 @@ mod tests { use crate::params::{F, D, C, HF}; use crate::gen_input::gen_testing_circuit_input; use crate::params::Params; - use codex_plonky2_circuits::recursion::uniform::{tree::TreeRecursion}; - use codex_plonky2_circuits::recursion::uniform::pi_verifier::{PublicInputVerificationCircuit, PublicInputVerificationInput}; - use codex_plonky2_circuits::recursion::uniform::tree::get_hash_of_verifier_data; + use codex_plonky2_circuits::recursion::{tree::TreeRecursion}; + use codex_plonky2_circuits::recursion::pi_verifier::{PublicInputVerificationCircuit, PublicInputVerificationInput}; + use codex_plonky2_circuits::recursion::tree::get_hash_of_verifier_data; #[test] fn test_uniform_recursion() -> anyhow::Result<()> { @@ -40,17 +40,18 @@ mod tests { const N: usize = 1; const M: usize = 2; - let mut tree = TreeRecursion::::build_with_standard_config(inner_verifier_data.common.clone(), inner_verifier_data.verifier_only.clone())?; + let mut tree = TreeRecursion::::build_with_standard_config(inner_verifier_data.common.clone(), inner_verifier_data.verifier_only.clone())?; // aggregate - no compression let root = tree.prove_tree(&proofs)?; println!("pub input size = {}", root.public_inputs.len()); + println!("pub input = {:?}", root.public_inputs); println!("proof size = {:?} bytes", root.to_bytes().len()); // aggregate with compression - let root_compressed = tree.prove_tree_and_compress(&proofs)?; - println!("pub input size (compressed) = {}", root_compressed.public_inputs.len()); - println!("proof size compressed = {:?} bytes", root_compressed.to_bytes().len()); + // let root_compressed = tree.prove_tree_and_compress(&proofs)?; + // println!("pub input size (compressed) = {}", root_compressed.public_inputs.len()); + // println!("proof size compressed = {:?} bytes", root_compressed.to_bytes().len()); let inner_pi: Vec> = proofs.iter().map(|p| p.public_inputs.clone()).collect(); @@ -59,10 +60,10 @@ mod tests { "proof verification failed" ); - assert!( - tree.verify_proof_and_public_input(root_compressed,inner_pi, true).is_ok(), - "compressed proof verification failed" - ); + // assert!( + // tree.verify_proof_and_public_input(root_compressed,inner_pi, true).is_ok(), + // "compressed proof verification failed" + // ); Ok(()) @@ -98,7 +99,7 @@ mod tests { const N: usize = 1; const M: usize = 2; - let mut tree = TreeRecursion::::build_with_standard_config(inner_verifier_data.common.clone(), inner_verifier_data.verifier_only.clone())?; + let mut tree = TreeRecursion::::build_with_standard_config(inner_verifier_data.common.clone(), inner_verifier_data.verifier_only.clone())?; let root = tree.prove_tree(&proofs)?; println!("pub input size = {}", root.public_inputs.len());