diff --git a/crates/compute_test_utils/src/piop.rs b/crates/compute_test_utils/src/piop.rs index 32b007635..e0ae439fe 100644 --- a/crates/compute_test_utils/src/piop.rs +++ b/crates/compute_test_utils/src/piop.rs @@ -104,6 +104,7 @@ pub fn commit_prove_verify, log_inv_rate: usize, + fri_conjecture: bool, ) where FDomain: BinaryField, FEncode: BinaryField, @@ -132,6 +133,7 @@ pub fn commit_prove_verify( oracles: &MultilinearOracleSet, log_inv_rate: usize, create_hal_holder: impl FnOnce(usize, usize) -> HalHolder, + fri_conjecture: bool, ) where U: TowerUnderlier + PackScalar, PackedType: PackedFieldIndexable + PackedTop, @@ -224,6 +225,7 @@ pub fn commit_prove_verify_piop( merkle_scheme, SECURITY_BITS, log_inv_rate, + fri_conjecture, ) .unwrap(); let ntt = SingleThreadedNTT::with_subspace(fri_params.rs_code().subspace()).unwrap(); diff --git a/crates/core/src/constraint_system/prove.rs b/crates/core/src/constraint_system/prove.rs index a9c873b61..4e039a53b 100644 --- a/crates/core/src/constraint_system/prove.rs +++ b/crates/core/src/constraint_system/prove.rs @@ -91,6 +91,7 @@ pub fn prove< table_sizes: &[usize], mut witness: MultilinearExtensionIndex>>, backend: &Backend, + fri_conjecture: bool, ) -> Result where Hal: ComputeLayer + Default, @@ -213,6 +214,7 @@ where merkle_scheme, security_bits, log_inv_rate, + fri_conjecture, )?; let ntt = SingleThreadedNTT::with_subspace(fri_params.rs_code().subspace())? .precompute_twiddles() diff --git a/crates/core/src/constraint_system/verify.rs b/crates/core/src/constraint_system/verify.rs index 4217533c7..fa93af83b 100644 --- a/crates/core/src/constraint_system/verify.rs +++ b/crates/core/src/constraint_system/verify.rs @@ -59,6 +59,7 @@ pub fn verify( constraint_system_digest: &Output, boundaries: &[Boundary>], proof: Proof, + fri_conjecture: bool, ) -> Result<(), Error> where U: TowerUnderlier, @@ -128,6 +129,7 @@ where &merkle_scheme, security_bits, log_inv_rate, + fri_conjecture, )?; // Read polynomial commitment polynomials diff --git a/crates/core/src/piop/verify.rs b/crates/core/src/piop/verify.rs index 0a1ec7c34..5c9c8a677 100644 --- a/crates/core/src/piop/verify.rs +++ b/crates/core/src/piop/verify.rs @@ -120,6 +120,7 @@ fn make_commit_params_with_constant_arity( security_bits: usize, log_inv_rate: usize, arity: usize, + fri_conjecture: bool, ) -> Result, Error> where F: BinaryField + ExtensionField, @@ -131,6 +132,7 @@ where security_bits, log_inv_rate, arity, + fri_conjecture, )?; Ok(params) } @@ -143,11 +145,13 @@ where /// * `merkle_scheme` - the Merkle tree commitment scheme used in FRI. /// * `security_bits` - the target security level in bits. /// * `log_inv_rate` - the binary logarithm of the inverse Reed–Solomon code rate. +/// * `fri_conjecture` - whether to use FRI conjecture. pub fn make_commit_params_with_optimal_arity( commit_meta: &CommitMeta, _merkle_scheme: &MTScheme, security_bits: usize, log_inv_rate: usize, + fri_conjecture: bool, ) -> Result, Error> where F: BinaryField + ExtensionField, @@ -164,7 +168,14 @@ where size_of::(), size_of::(), ); - make_commit_params_with_constant_arity(&ntt, commit_meta, security_bits, log_inv_rate, arity) + make_commit_params_with_constant_arity( + &ntt, + commit_meta, + security_bits, + log_inv_rate, + arity, + fri_conjecture, + ) } /// A description of a sumcheck claim arising from a FRI PCS sumcheck. diff --git a/crates/core/src/protocols/fri/common.rs b/crates/core/src/protocols/fri/common.rs index 7cb6b7870..426ae8368 100644 --- a/crates/core/src/protocols/fri/common.rs +++ b/crates/core/src/protocols/fri/common.rs @@ -12,6 +12,11 @@ use crate::{ reed_solomon::reed_solomon::ReedSolomonCode, }; +/// Under FRI conjecture, q >> n^2 is enough to ensure the FRI conjecture validity. +/// +/// So this factor is the ratio between the field size and the blocklength squared. +const FRI_CONJECTURE_SAFETY_FACTOR: f64 = 10.0; + /// Parameters for an FRI interleaved code proximity protocol. #[derive(Debug, Getters, CopyGetters)] pub struct FRIParams @@ -65,19 +70,22 @@ where /// * `security_bits` - the target security level in bits. /// * `log_inv_rate` - the binary logarithm of the inverse Reed–Solomon code rate. /// * `arity` - the folding arity. + /// * `fri_conjecture` - whether to use FRI conjecture. pub fn choose_with_constant_fold_arity( ntt: &impl AdditiveNTT, log_msg_len: usize, security_bits: usize, log_inv_rate: usize, arity: usize, + fri_conjecture: bool, ) -> Result { assert!(arity > 0); let log_dim = log_msg_len.saturating_sub(arity); let log_batch_size = log_msg_len.min(arity); let rs_code = ReedSolomonCode::with_ntt_subspace(ntt, log_dim, log_inv_rate)?; - let n_test_queries = calculate_n_test_queries::(security_bits, &rs_code)?; + let n_test_queries = + calculate_n_test_queries::(security_bits, &rs_code, fri_conjecture)?; let cap_height = log2_ceil_usize(n_test_queries); let fold_arities = std::iter::repeat_n( @@ -195,15 +203,21 @@ pub type TerminateCodeword = Vec; /// Calculates the number of test queries required to achieve a target security level. /// /// Throws [`Error::ParameterError`] if the security level is unattainable given the code +/// Throws [`Error::FriConjectureUnsatisfiable`] if the FRI conjecture is unsatisfiable. /// parameters. pub fn calculate_n_test_queries( security_bits: usize, code: &ReedSolomonCode, + fri_conjecture: bool, ) -> Result where F: BinaryField + ExtensionField, FEncode: BinaryField, { + if fri_conjecture { + return calculate_n_test_queries_fri_conjecture::(security_bits, code); + } + let field_size = 2.0_f64.powi(F::N_BITS as i32); let sumcheck_err = (2 * code.log_dim()) as f64 / field_size; // 2 ⋅ ℓ' / |T_{τ}| @@ -218,6 +232,50 @@ where Ok(n_queries) } +/// Calculate the number of test queries required to achieve a target security level. +/// +/// The number of test queries is given by: +/// s = 2λ / log(1/ρ) +/// under the condition q >> n^2. +/// +/// ## Arguments +/// +/// * `security_bits` - the target security level in bits. +/// * `code` - the Reed–Solomon code. +/// +/// ## Returns +/// +/// The number of test queries required to achieve the target security level. +pub fn calculate_n_test_queries_fri_conjecture( + security_bits: usize, + code: &ReedSolomonCode, +) -> Result { + // k + let dimension = code.dim() as f64; + // n + let blocklength = code.len() as f64; + // q + let field_size = 2.0_f64.powi(BF::N_BITS as i32); + + // See teorem 8.3 discussion of Proximity Gaps for Reed–Solomon Codes (https://eprint.iacr.org/2020/654.pdf) + // The condition under which the security parameter e_FRI ≤ 2^−λ holds is with q >> n^2. + // here we check that at least the field size is greater than the blocklength squared + // by a factor of FRI_CONJECTURE_SAFETY_FACTOR. + if field_size >= FRI_CONJECTURE_SAFETY_FACTOR * blocklength.powi(2) { + return Err(Error::FriConjectureUnsatisfiable( + field_size, + blocklength, + FRI_CONJECTURE_SAFETY_FACTOR, + )); + } + + // ρ = k+1/n + let rate = (dimension + 1.0) / blocklength; + + // 2λ / log(1/ρ) + Ok((2.0 * security_bits as f64 / (1.0 / rate).log2()).ceil() as usize) +} + /// Heuristic for estimating the optimal FRI folding arity that minimizes proof size. /// /// `log_block_length` is the binary logarithm of the block length of the Reed–Solomon code. @@ -262,28 +320,107 @@ mod tests { fn test_calculate_n_test_queries() { let security_bits = 96; let rs_code = ReedSolomonCode::new(28, 1).unwrap(); - let n_test_queries = - calculate_n_test_queries::(security_bits, &rs_code) - .unwrap(); + let fri_conjecture = false; + let n_test_queries = calculate_n_test_queries::( + security_bits, + &rs_code, + fri_conjecture, + ) + .unwrap(); assert_eq!(n_test_queries, 232); let rs_code = ReedSolomonCode::new(28, 2).unwrap(); - let n_test_queries = - calculate_n_test_queries::(security_bits, &rs_code) - .unwrap(); + let n_test_queries = calculate_n_test_queries::( + security_bits, + &rs_code, + fri_conjecture, + ) + .unwrap(); assert_eq!(n_test_queries, 143); } + #[test] + fn test_calculate_n_test_queries_fri_conjecture() { + let security_bits = 96; + let log_dimension = 28; + let log_inv_rate = 1; + let rs_code = ReedSolomonCode::new(log_dimension, log_inv_rate).unwrap(); + let fri_conjecture = true; + let n_test_queries = calculate_n_test_queries::( + security_bits, + &rs_code, + fri_conjecture, + ) + .unwrap(); + + assert_eq!(n_test_queries, 193); + + let rs_code = ReedSolomonCode::new(28, 2).unwrap(); + let n_test_queries = calculate_n_test_queries::( + security_bits, + &rs_code, + fri_conjecture, + ) + .unwrap(); + assert_eq!(n_test_queries, 97); + } + #[test] fn test_calculate_n_test_queries_unsatisfiable() { let security_bits = 128; let rs_code = ReedSolomonCode::::new(28, 1).unwrap(); assert_matches!( - calculate_n_test_queries::(security_bits, &rs_code), + calculate_n_test_queries::(security_bits, &rs_code, false), Err(Error::ParameterError) ); } + #[test] + fn test_n_test_queries_fri_conjecture_66_security_bits() { + // Example with 66 bits of security. + let security_bits = 66; // 66 bits of security + let log_inv_rate = 5; // ρ = 2^(-5) + let log_dimension = 12; // k = 4095 (dimension) + type Field = BinaryField128b; // Field size 2^128 + + let rs_code = ReedSolomonCode::new(log_dimension, log_inv_rate).unwrap(); + + let proven_queries = + calculate_n_test_queries::(security_bits, &rs_code, false) + .unwrap(); + + let conjecture_queries = + calculate_n_test_queries::(security_bits, &rs_code, true) + .unwrap(); + + assert_eq!(proven_queries, 70); + // This is slighlty lower than Johnson bounds m = 3 where the result is 30 + // see "A summary on the FRI low degree test" (https://eprint.iacr.org/2022/1216.pdf) section 3.5.1. + assert_eq!(conjecture_queries, 27); + } + + #[test] + fn test_n_test_queries_fri_conjecture_128_security_bits() { + // Example with 128 bits of security. + let security_bits = 128; // 128 bits of security + let log_inv_rate = 5; // ρ = 2^(-5) + let log_dimension = 12; // k = 4095 (dimension) + type Field = BinaryField128b; // Field size 2^128 + + let rs_code = ReedSolomonCode::new(log_dimension, log_inv_rate).unwrap(); + + // Proven queries fail at evaluating in + // in 128 bits security bits! + + let conjecture_queries = + calculate_n_test_queries::(security_bits, &rs_code, true) + .unwrap(); + + // This is slighlty lower than Johnson bounds m = 3 where the result is 57 + // see "A summary on the FRI low degree test" (https://eprint.iacr.org/2022/1216.pdf) section 3.5.3. + assert_eq!(conjecture_queries, 52); + } + #[test] fn test_estimate_optimal_arity() { let field_size = 128; diff --git a/crates/core/src/protocols/fri/error.rs b/crates/core/src/protocols/fri/error.rs index 7c3776af3..cb9e398d2 100644 --- a/crates/core/src/protocols/fri/error.rs +++ b/crates/core/src/protocols/fri/error.rs @@ -42,6 +42,10 @@ pub enum Error { AllocationError(#[from] binius_compute::alloc::Error), #[error("compute error: {0}")] ComputeError(#[from] binius_compute::layer::Error), + #[error( + "FRI conjecture is unsatisfiable, field size ({0}) must be greater than blocklength squared ({1}) by a factor of {2} - q >= n^2 * {2}" + )] + FriConjectureUnsatisfiable(f64, f64, f64), } #[derive(Debug, thiserror::Error)] diff --git a/crates/core/tests/piop.rs b/crates/core/tests/piop.rs index 3860de4a9..0af979ffb 100644 --- a/crates/core/tests/piop.rs +++ b/crates/core/tests/piop.rs @@ -14,6 +14,7 @@ fn test_with_one_poly() { let n_transparents = 1; let log_inv_rate = 1; let compute_holder = CpuLayerHolder::::new(1 << 14, 1 << 22); + let fri_conjecture = false; commit_prove_verify::( compute_holder, @@ -21,6 +22,7 @@ fn test_with_one_poly() { n_transparents, &merkle_prover, log_inv_rate, + fri_conjecture, ); } @@ -31,6 +33,7 @@ fn test_without_opening_claims() { let n_transparents = 0; let log_inv_rate = 1; let compute_holder = CpuLayerHolder::::new(1 << 14, 1 << 22); + let fri_conjecture = false; commit_prove_verify::( compute_holder, @@ -38,6 +41,7 @@ fn test_without_opening_claims() { n_transparents, &merkle_prover, log_inv_rate, + fri_conjecture, ); } @@ -48,6 +52,7 @@ fn test_with_one_n_vars() { let n_transparents = 1; let log_inv_rate = 1; let compute_holder = CpuLayerHolder::::new(1 << 14, 1 << 22); + let fri_conjecture = false; commit_prove_verify::( compute_holder, @@ -55,6 +60,7 @@ fn test_with_one_n_vars() { n_transparents, &merkle_prover, log_inv_rate, + fri_conjecture, ); } @@ -65,6 +71,7 @@ fn test_commit_prove_verify_extreme_rate() { let n_transparents = 2; let log_inv_rate = 8; let compute_holder = CpuLayerHolder::::new(1 << 14, 1 << 22); + let fri_conjecture = false; commit_prove_verify::( compute_holder, @@ -72,6 +79,7 @@ fn test_commit_prove_verify_extreme_rate() { n_transparents, &merkle_prover, log_inv_rate, + fri_conjecture, ); } @@ -82,6 +90,7 @@ fn test_commit_prove_verify_small() { let n_transparents = 2; let log_inv_rate = 1; let compute_holder = CpuLayerHolder::::new(1 << 14, 1 << 22); + let fri_conjecture = false; commit_prove_verify::( compute_holder, @@ -89,6 +98,7 @@ fn test_commit_prove_verify_small() { n_transparents, &merkle_prover, log_inv_rate, + fri_conjecture, ); } @@ -99,6 +109,7 @@ fn test_commit_prove_verify() { let n_transparents = 2; let log_inv_rate = 1; let compute_holder = CpuLayerHolder::::new(1 << 14, 1 << 22); + let fri_conjecture = false; commit_prove_verify::( compute_holder, @@ -106,5 +117,6 @@ fn test_commit_prove_verify() { n_transparents, &merkle_prover, log_inv_rate, + fri_conjecture, ); } diff --git a/crates/core/tests/ring_switch.rs b/crates/core/tests/ring_switch.rs index 94af31326..0b94d4766 100644 --- a/crates/core/tests/ring_switch.rs +++ b/crates/core/tests/ring_switch.rs @@ -108,11 +108,13 @@ fn test_prove_verify_piop_integration() { let oracles = make_test_oracle_set(); let log_inv_rate = 2; let merkle_prover = BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let fri_conjecture = false; commit_prove_verify_piop::, CpuLayerHolder>( &merkle_prover, &oracles, log_inv_rate, CpuLayerHolder::new, + fri_conjecture, ); } diff --git a/crates/m3/src/builder/test_utils.rs b/crates/m3/src/builder/test_utils.rs index a31d2e0f3..55bd02dc9 100644 --- a/crates/m3/src/builder/test_utils.rs +++ b/crates/m3/src/builder/test_utils.rs @@ -124,6 +124,7 @@ pub fn validate_system_witness_with_prove_verify( if prove_verify { const LOG_INV_RATE: usize = 1; const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; let mut compute_holder = FastCpuLayerHolder::>::new(1 << 16, 1 << 24); @@ -149,6 +150,7 @@ pub fn validate_system_witness_with_prove_verify( &table_sizes, witness, &binius_hal::make_portable_backend(), + FRI_CONJECTURE, ) .unwrap(); @@ -158,7 +160,7 @@ pub fn validate_system_witness_with_prove_verify( Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, LOG_INV_RATE, SECURITY_BITS, &ccs_digest, &boundaries, proof) + >(&ccs, LOG_INV_RATE, SECURITY_BITS, &ccs_digest, &boundaries, proof, false) .unwrap(); } } diff --git a/examples/b32_mul.rs b/examples/b32_mul.rs index 5996406c1..eba8b61df 100644 --- a/examples/b32_mul.rs +++ b/examples/b32_mul.rs @@ -28,6 +28,7 @@ struct Args { fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -121,6 +122,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -131,7 +133,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/bitwise_ops.rs b/examples/bitwise_ops.rs index 26b27d49a..be7ac4b48 100644 --- a/examples/bitwise_ops.rs +++ b/examples/bitwise_ops.rs @@ -173,6 +173,7 @@ impl BitwiseGadget { fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -267,6 +268,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -277,7 +279,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/groestl.rs b/examples/groestl.rs index 360e6dc6f..fdc31bd78 100644 --- a/examples/groestl.rs +++ b/examples/groestl.rs @@ -74,6 +74,7 @@ where fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -140,6 +141,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -150,7 +152,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/keccak.rs b/examples/keccak.rs index aa5831317..b8de48829 100644 --- a/examples/keccak.rs +++ b/examples/keccak.rs @@ -77,6 +77,7 @@ where fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -143,6 +144,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -153,7 +155,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/keccak_lookups.rs b/examples/keccak_lookups.rs index 969d017dc..754e982b3 100644 --- a/examples/keccak_lookups.rs +++ b/examples/keccak_lookups.rs @@ -86,6 +86,7 @@ where fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -169,6 +170,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -179,7 +181,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/merkle_tree.rs b/examples/merkle_tree.rs index 0badbafc3..88d870863 100644 --- a/examples/merkle_tree.rs +++ b/examples/merkle_tree.rs @@ -38,6 +38,7 @@ struct Args { fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -127,6 +128,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, ) .unwrap(); @@ -138,7 +140,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/u32_add.rs b/examples/u32_add.rs index 234b3c329..a851b1def 100644 --- a/examples/u32_add.rs +++ b/examples/u32_add.rs @@ -30,6 +30,7 @@ struct Args { fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -121,6 +122,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -131,7 +133,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) } diff --git a/examples/u32_mul_gkr.rs b/examples/u32_mul_gkr.rs index 742b20d24..d7bf5b0e6 100644 --- a/examples/u32_mul_gkr.rs +++ b/examples/u32_mul_gkr.rs @@ -69,6 +69,7 @@ where fn main() -> Result<()> { const SECURITY_BITS: usize = 100; + const FRI_CONJECTURE: bool = false; adjust_thread_pool() .as_ref() @@ -135,6 +136,7 @@ fn main() -> Result<()> { &table_sizes, witness, &make_portable_backend(), + FRI_CONJECTURE, )?; println!("Proof size: {}", ByteSize::b(proof.get_proof_size() as u64)); @@ -145,7 +147,15 @@ fn main() -> Result<()> { Groestl256, Groestl256ByteCompression, HasherChallenger, - >(&ccs, args.log_inv_rate as usize, SECURITY_BITS, &cs_digest, &boundaries, proof)?; + >( + &ccs, + args.log_inv_rate as usize, + SECURITY_BITS, + &cs_digest, + &boundaries, + proof, + FRI_CONJECTURE, + )?; Ok(()) }