Skip to content
This repository was archived by the owner on Sep 9, 2025. It is now read-only.

Extract macro to instantiate ring switch tests #785

Open
GraDKh wants to merge 1 commit into
base: dgordon/extract_bivariate_sumcheck_macro
Choose a base branch
from
Open

Extract macro to instantiate ring switch tests #785

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
143 changes: 143 additions & 0 deletions crates/core/test_utils/src/piop.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -224,3 +224,146 @@ pub fn commit_prove_verify<FDomain, FEncode, F, P, MTScheme, HAL, ComputeHolderT
)
.unwrap();
}

#[macro_export]
macro_rules! instantiate_piop_tests {
($compute_holder:ty) => {
#[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::<B8, B16, B128, PackedBinaryField2x128b, _, _, _>(
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::<B8, B16, B128, PackedBinaryField2x128b, _, _, _>(
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::<B8, B16, B128, PackedBinaryField2x128b, _, _, _>(
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::<B8, B16, B128, PackedBinaryField2x128b, _, _, _>(
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::<B8, B16, B128, PackedBinaryField2x128b, _, _, _>(
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::<B8, B16, B128, PackedBinaryField2x128b, _, _, _>(
compute_holder,
&commit_meta,
n_transparents,
&merkle_prover,
log_inv_rate,
);
}
};
}
116 changes: 115 additions & 1 deletion crates/core/test_utils/src/ring_switch.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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},
Expand Down Expand Up @@ -301,3 +301,117 @@ pub fn commit_prove_verify_piop<U, F, MTScheme, MTProver, Hal, HalHolder>(
)
.unwrap();
}

fn with_test_instance_from_oracles<U, F, R>(
mut rng: R,
oracles: &MultilinearOracleSet<F>,
func: impl FnOnce(R, EvalClaimSystem<F>, Vec<MultilinearWitness<PackedType<U, F>>>),
) where
U: TowerUnderlier + PackScalar<F>,
F: TowerTop,
R: Rng,
{
let (commit_meta, oracle_to_commit_index) = piop::make_oracle_commit_meta(oracles).unwrap();

let witness_index = generate_multilinears::<U, F>(&mut rng, oracles);
let witnesses = piop::collect_committed_witnesses::<U, _>(
&commit_meta,
&oracle_to_commit_index,
oracles,
&witness_index,
)
.unwrap();

let eval_claims = setup_test_eval_claims::<U, _>(&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<U, F, Hal, HalHolder>(
create_hal_holder: impl FnOnce(usize, usize) -> HalHolder,
) where
U: TowerUnderlier + PackScalar<F>,
PackedType<U, F>: PackedFieldIndexable + PackedTop,
F: TowerTop + PackedTop<Scalar = F>,
Hal: ComputeLayer<F>,
HalHolder: ComputeHolder<F, Hal>,
{
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::<U, F, _>(rng, &oracles, |_rng, system, witnesses| {
let mut proof = ProverTranscript::<HasherChallenger<Groestl256>>::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::<U, F, _, _, _, $compute_holder>(
&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);
}
};
}
Loading
Loading