diff --git a/crates/core/test_utils/src/piop.rs b/crates/core/test_utils/src/piop.rs index 32b007635..8af0422f7 100644 --- a/crates/core/test_utils/src/piop.rs +++ b/crates/core/test_utils/src/piop.rs @@ -224,3 +224,146 @@ pub fn commit_prove_verify { + #[test] + fn test_with_one_poly() { + use binius_core::piop::CommitMeta; + use binius_field::PackedBinaryField2x128b; + use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; + use binius_math::{B8, B16, B128}; + + let commit_meta = CommitMeta::with_vars([4]); + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let n_transparents = 1; + let log_inv_rate = 1; + let compute_holder = <$compute_holder>::new(1 << 14, 1 << 22); + + $crate::piop::commit_prove_verify::( + compute_holder, + &commit_meta, + n_transparents, + &merkle_prover, + log_inv_rate, + ); + } + + #[test] + fn test_without_opening_claims() { + use binius_core::piop::CommitMeta; + use binius_field::PackedBinaryField2x128b; + use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; + use binius_math::{B8, B16, B128}; + + let commit_meta = CommitMeta::with_vars([4, 4, 6, 7]); + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let n_transparents = 0; + let log_inv_rate = 1; + let compute_holder = <$compute_holder>::new(1 << 14, 1 << 22); + + $crate::piop::commit_prove_verify::( + compute_holder, + &commit_meta, + n_transparents, + &merkle_prover, + log_inv_rate, + ); + } + + #[test] + fn test_with_one_n_vars() { + use binius_core::piop::CommitMeta; + use binius_field::PackedBinaryField2x128b; + use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; + use binius_math::{B8, B16, B128}; + + let commit_meta = CommitMeta::with_vars([4, 4]); + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let n_transparents = 1; + let log_inv_rate = 1; + let compute_holder = <$compute_holder>::new(1 << 14, 1 << 22); + + $crate::piop::commit_prove_verify::( + compute_holder, + &commit_meta, + n_transparents, + &merkle_prover, + log_inv_rate, + ); + } + + #[test] + fn test_commit_prove_verify_extreme_rate() { + use binius_core::piop::CommitMeta; + use binius_field::PackedBinaryField2x128b; + use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; + use binius_math::{B8, B16, B128}; + + let commit_meta = CommitMeta::with_vars([3, 3, 5, 6]); + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let n_transparents = 2; + let log_inv_rate = 8; + let compute_holder = <$compute_holder>::new(1 << 14, 1 << 22); + + $crate::piop::commit_prove_verify::( + compute_holder, + &commit_meta, + n_transparents, + &merkle_prover, + log_inv_rate, + ); + } + + #[test] + fn test_commit_prove_verify_small() { + use binius_core::piop::CommitMeta; + use binius_field::PackedBinaryField2x128b; + use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; + use binius_math::{B8, B16, B128}; + + let commit_meta = CommitMeta::with_vars([4, 4, 6, 7]); + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let n_transparents = 2; + let log_inv_rate = 1; + let compute_holder = <$compute_holder>::new(1 << 14, 1 << 22); + + $crate::piop::commit_prove_verify::( + compute_holder, + &commit_meta, + n_transparents, + &merkle_prover, + log_inv_rate, + ); + } + + #[test] + fn test_commit_prove_verify() { + use binius_core::piop::CommitMeta; + use binius_field::PackedBinaryField2x128b; + use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; + use binius_math::{B8, B16, B128}; + + let commit_meta = CommitMeta::with_vars([6, 6, 8, 9]); + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + let n_transparents = 2; + let log_inv_rate = 1; + let compute_holder = <$compute_holder>::new(1 << 14, 1 << 22); + + $crate::piop::commit_prove_verify::( + compute_holder, + &commit_meta, + n_transparents, + &merkle_prover, + log_inv_rate, + ); + } + }; +} diff --git a/crates/core/test_utils/src/ring_switch.rs b/crates/core/test_utils/src/ring_switch.rs index 44dea8b8d..abc8bd661 100644 --- a/crates/core/test_utils/src/ring_switch.rs +++ b/crates/core/test_utils/src/ring_switch.rs @@ -2,7 +2,7 @@ use std::{cmp::Ordering, iter::repeat_with}; -use binius_compute::{ComputeHolder, ComputeLayer}; +use binius_compute::{ComputeData, ComputeHolder, ComputeLayer}; use binius_core::{ fiat_shamir::HasherChallenger, merkle_tree::{MerkleTreeProver, MerkleTreeScheme}, @@ -301,3 +301,117 @@ pub fn commit_prove_verify_piop( ) .unwrap(); } + +fn with_test_instance_from_oracles( + mut rng: R, + oracles: &MultilinearOracleSet, + func: impl FnOnce(R, EvalClaimSystem, Vec>>), +) where + U: TowerUnderlier + PackScalar, + F: TowerTop, + R: Rng, +{ + let (commit_meta, oracle_to_commit_index) = piop::make_oracle_commit_meta(oracles).unwrap(); + + let witness_index = generate_multilinears::(&mut rng, oracles); + let witnesses = piop::collect_committed_witnesses::( + &commit_meta, + &oracle_to_commit_index, + oracles, + &witness_index, + ) + .unwrap(); + + let eval_claims = setup_test_eval_claims::(&mut rng, oracles, &witness_index); + + // Finish setting up the test case + let system = + EvalClaimSystem::new(oracles, &commit_meta, &oracle_to_commit_index, &eval_claims).unwrap(); + check_eval_point_consistency(&system); + + func(rng, system, witnesses) +} + +pub fn test_prove_verify_claim_reduction_with_naive_validation( + create_hal_holder: impl FnOnce(usize, usize) -> HalHolder, +) where + U: TowerUnderlier + PackScalar, + PackedType: PackedFieldIndexable + PackedTop, + F: TowerTop + PackedTop, + Hal: ComputeLayer, + HalHolder: ComputeHolder, +{ + let mut compute_holder = create_hal_holder(1 << 7, 1 << 12); + + let ComputeData { + hal, + host_alloc, + dev_alloc, + .. + } = compute_holder.to_data(); + + let rng = StdRng::seed_from_u64(0); + let oracles = make_test_oracle_set(); + + with_test_instance_from_oracles::(rng, &oracles, |_rng, system, witnesses| { + let mut proof = ProverTranscript::>::new(); + + let ReducedWitness { + transparents: transparent_witnesses, + sumcheck_claims: prover_sumcheck_claims, + } = prove(&system, &witnesses, &mut proof, MemoizedData::new(), hal, &dev_alloc, &host_alloc) + .unwrap(); + + let mut proof = proof.into_verifier(); + let ReducedClaim { + transparents: _, + sumcheck_claims: verifier_sumcheck_claims, + } = verify(&system, &mut proof).unwrap(); + + assert_eq!(prover_sumcheck_claims, verifier_sumcheck_claims); + + piop::validate_sumcheck_witness( + &witnesses, + &transparent_witnesses, + &prover_sumcheck_claims, + hal, + ) + .unwrap(); + }); +} + +#[macro_export] +macro_rules! instantiate_ring_switch_tests { + ($compute_holder:ty) => { + #[test] + fn test_prove_verify_piop_integration() { + type U = OptimalUnderlier128b; + type F = B128; + + let oracles = make_test_oracle_set(); + let log_inv_rate = 2; + let merkle_prover = + BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + + $crate::ring_switch::commit_prove_verify_piop::( + &merkle_prover, + &oracles, + log_inv_rate, + <$compute_holder>::new, + ); + } + + #[test] + fn test_prove_verify_claim_reduction_with_naive_validation() { + type U = OptimalUnderlier128b; + type F = B128; + + $crate::ring_switch::test_prove_verify_claim_reduction_with_naive_validation::< + U, + F, + _, + $compute_holder, + >(<$compute_holder>::new); + } + }; +} diff --git a/crates/core/tests/ring_switch.rs b/crates/core/tests/ring_switch.rs index 103e556ec..e4f229e1b 100644 --- a/crates/core/tests/ring_switch.rs +++ b/crates/core/tests/ring_switch.rs @@ -1,118 +1,26 @@ // Copyright 2024-2025 Irreducible Inc. -use binius_compute::{ - ComputeData, ComputeHolder, - cpu::{CpuLayer, layer::CpuLayerHolder}, -}; -use binius_core::{ - fiat_shamir::HasherChallenger, - merkle_tree::BinaryMerkleTreeProver, - oracle::MultilinearOracleSet, - piop, - protocols::evalcheck::subclaims::MemoizedData, - ring_switch::{EvalClaimSystem, ReducedClaim, ReducedWitness, prove, verify}, - transcript::ProverTranscript, - witness::MultilinearWitness, -}; -use binius_core_test_utils::ring_switch::{ - check_eval_point_consistency, commit_prove_verify_piop, generate_multilinears, - make_test_oracle_set, setup_test_eval_claims, -}; -use binius_field::{ - arch::OptimalUnderlier128b, - as_packed_field::{PackScalar, PackedType}, -}; +use binius_core::merkle_tree::BinaryMerkleTreeProver; +use binius_core_test_utils::{instantiate_ring_switch_tests, ring_switch::make_test_oracle_set}; +use binius_field::{arch::OptimalUnderlier128b, as_packed_field::PackedType}; use binius_hash::groestl::{Groestl256, Groestl256ByteCompression}; -use binius_math::{B128, TowerTop, TowerUnderlier}; -use rand::prelude::*; +use binius_math::B128; -fn with_test_instance_from_oracles( - mut rng: R, - oracles: &MultilinearOracleSet, - func: impl FnOnce(R, EvalClaimSystem, Vec>>), -) where - U: TowerUnderlier + PackScalar, - F: TowerTop, - R: Rng, -{ - let (commit_meta, oracle_to_commit_index) = piop::make_oracle_commit_meta(oracles).unwrap(); +mod cpu_tests { + use binius_compute::cpu::layer::CpuLayerHolder; - let witness_index = generate_multilinears::(&mut rng, oracles); - let witnesses = piop::collect_committed_witnesses::( - &commit_meta, - &oracle_to_commit_index, - oracles, - &witness_index, - ) - .unwrap(); + use super::*; - let eval_claims = setup_test_eval_claims::(&mut rng, oracles, &witness_index); - - // Finish setting up the test case - let system = - EvalClaimSystem::new(oracles, &commit_meta, &oracle_to_commit_index, &eval_claims).unwrap(); - check_eval_point_consistency(&system); - - func(rng, system, witnesses) -} - -#[test] -fn test_prove_verify_claim_reduction_with_naive_validation() { - type U = OptimalUnderlier128b; - type F = B128; - - let mut compute_holder = CpuLayerHolder::::new(1 << 7, 1 << 12); - - let ComputeData { - hal, - host_alloc, - dev_alloc, - .. - } = compute_holder.to_data(); - - let rng = StdRng::seed_from_u64(0); - let oracles = make_test_oracle_set(); - - with_test_instance_from_oracles::(rng, &oracles, |_rng, system, witnesses| { - let mut proof = ProverTranscript::>::new(); - - let ReducedWitness { - transparents: transparent_witnesses, - sumcheck_claims: prover_sumcheck_claims, - } = prove(&system, &witnesses, &mut proof, MemoizedData::new(), hal, &dev_alloc, &host_alloc) - .unwrap(); - - let mut proof = proof.into_verifier(); - let ReducedClaim { - transparents: _, - sumcheck_claims: verifier_sumcheck_claims, - } = verify(&system, &mut proof).unwrap(); - - assert_eq!(prover_sumcheck_claims, verifier_sumcheck_claims); - - piop::validate_sumcheck_witness( - &witnesses, - &transparent_witnesses, - &prover_sumcheck_claims, - hal, - ) - .unwrap(); - }); + instantiate_ring_switch_tests!(CpuLayerHolder); } -#[test] -fn test_prove_verify_piop_integration() { - type U = OptimalUnderlier128b; - type F = B128; +mod fast_cpu_tests { + use binius_fast_compute::layer::FastCpuLayerHolder; + use binius_field::tower::CanonicalTowerFamily; - let oracles = make_test_oracle_set(); - let log_inv_rate = 2; - let merkle_prover = BinaryMerkleTreeProver::<_, Groestl256, _>::new(Groestl256ByteCompression); + use super::*; - commit_prove_verify_piop::, CpuLayerHolder>( - &merkle_prover, - &oracles, - log_inv_rate, - CpuLayerHolder::new, + instantiate_ring_switch_tests!( + FastCpuLayerHolder::> ); }