Skip to content

Commit

Permalink
Use generic tests where possible
Browse files Browse the repository at this point in the history
  • Loading branch information
@volhovm
volhovm committed May 21, 2024
1 parent 5a075dc commit d931366
Show file tree
Hide file tree
Showing 8 changed files with 224 additions and 566 deletions.
74 changes: 13 additions & 61 deletions ivc/src/ivc/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,26 +14,19 @@ mod tests {
poseidon::{interpreter::PoseidonParams, params::static_params},
};
use ark_ff::{UniformRand, Zero};
use kimchi::circuits::domains::EvaluationDomains;
use kimchi_msm::{
circuit_design::{
composition::{IdMPrism, MPrism},
ConstraintBuilderEnv, SubEnvLookup, WitnessBuilderEnv,
},
columns::ColumnIndexer,
logup::LookupTableID,
precomputed_srs::get_bn254_srs,
proof::ProofInputs,
prover::prove,
verifier::verify,
witness::Witness,
BaseSponge, Ff1, Fp, OpeningProof, ScalarSponge, BN254,
Ff1, Fp,
};
use o1_utils::box_array;
use poly_commitment::pairing_proof::PairingSRS;
use rand::{CryptoRng, RngCore};

// Test number
// Total number of columns in IVC and Application circuits.
pub const TEST_N_COL_TOTAL: usize = IVCColumn::N_COL + 50;
// Absolutely no idea.
pub const TEST_N_CHALS: usize = 200;
Expand Down Expand Up @@ -133,77 +126,36 @@ mod tests {
#[test]
fn test_completeness_ivc() {
let mut rng = o1_utils::tests::make_test_rng();

//let mut comms_left: Box<_> = box_array2![(Fp::zero(),Fp::zero()); TEST_N_COL_TOTAL; 3];

let domain_size = 1 << 15;
let domain = EvaluationDomains::<Fp>::create(domain_size).unwrap();

let srs: PairingSRS<BN254> = get_bn254_srs(domain);

let witness_env = build_ivc_circuit::<_, IVCLookupTable<Ff1>, _>(
&mut rng,
domain_size,
IdMPrism::<IVCLookupTable<Ff1>>::default(),
);
// Don't use lookups for now
let rel_witness = witness_env.get_relation_witness(domain);
let proof_inputs = ProofInputs {
evaluations: rel_witness,
logups: vec![],
};
let relation_witness = witness_env.get_relation_witness(domain_size);

let mut constraint_env = ConstraintBuilderEnv::<Fp, IVCLookupTable<Ff1>>::create();
constrain_ivc::<Fp, Ff1, _>(&mut constraint_env);
// Don't use lookups for now
let constraints = constraint_env.get_relation_constraints();

let fixed_selectors: [Vec<Fp>; N_BLOCKS] =
build_selectors::<_, TEST_N_COL_TOTAL, TEST_N_CHALS>(domain_size);
let fixed_selectors: Box<[Vec<Fp>; N_BLOCKS]> =
Box::new(build_selectors::<_, TEST_N_COL_TOTAL, TEST_N_CHALS>(
domain_size,
));

// generate the proof
let proof = prove::<
_,
OpeningProof,
BaseSponge,
ScalarSponge,
_,
kimchi_msm::test::test_completeness_generic_no_lookups::<
{ IVCColumn::N_COL - N_BLOCKS },
{ IVCColumn::N_COL - N_BLOCKS },
0,
N_BLOCKS,
IVCLookupTable<Ff1>,
>(
domain,
&srs,
&constraints,
Box::new(fixed_selectors.clone()),
proof_inputs,
&mut rng,
)
.unwrap();

// verify the proof
let verifies = verify::<
_,
OpeningProof,
BaseSponge,
ScalarSponge,
{ IVCColumn::N_COL - N_BLOCKS },
{ IVCColumn::N_COL - N_BLOCKS },
0,
N_BLOCKS,
0,
IVCLookupTable<Ff1>,
>(
domain,
&srs,
&constraints,
Box::new(fixed_selectors),
&proof,
Witness::zero_vec(domain_size),
constraints,
fixed_selectors,
relation_witness,
domain_size,
&mut rng,
);

assert!(verifies);
}
}
68 changes: 9 additions & 59 deletions ivc/src/poseidon/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,23 +6,16 @@ pub mod params;

#[cfg(test)]
mod tests {
use std::collections::BTreeMap;

use super::{params, params::PlonkSpongeConstantsIVC};
use crate::poseidon::{columns::PoseidonColumn, interpreter, interpreter::PoseidonParams};
use ark_ff::UniformRand;
use kimchi::circuits::domains::EvaluationDomains;
use kimchi_msm::{
circuit_design::{ColAccessCap, ConstraintBuilderEnv, WitnessBuilderEnv},
columns::ColumnIndexer,
lookups::DummyLookupTable,
prover::prove,
verifier::verify,
witness::Witness,
BaseSponge, Fp, OpeningProof, ScalarSponge, BN254,
Fp,
};
use mina_poseidon::permutation::poseidon_block_cipher;
use poly_commitment::pairing_proof::PairingSRS;

pub struct PoseidonBN254Parameters;

Expand Down Expand Up @@ -102,19 +95,13 @@ mod tests {
/// Checks that poseidon circuit can be proven and verified. Big domain.
pub fn test_completeness() {
let mut rng = o1_utils::tests::make_test_rng();
let domain_size = 1 << 15;
let domain = EvaluationDomains::<Fp>::create(domain_size).unwrap();

let srs_trapdoor = Fp::rand(&mut rng);
let mut srs: PairingSRS<BN254> = PairingSRS::create(srs_trapdoor, domain.d1.size as usize);
srs.full_srs.add_lagrange_basis(domain.d1);
let domain_size: usize = 1 << 15;

let empty_lookups = BTreeMap::new();
let proof_inputs = {
let relation_witness = {
let mut witness_env: PoseidonWitnessBuilderEnv = WitnessBuilderEnv::create();

// Generate random inputs at each row
for _row in 0..domain.d1.size {
for _row in 0..domain_size {
let x: Fp = Fp::rand(&mut rng);
let y: Fp = Fp::rand(&mut rng);
let z: Fp = Fp::rand(&mut rng);
Expand All @@ -126,7 +113,7 @@ mod tests {
);
}

witness_env.get_proof_inputs(domain, empty_lookups)
witness_env.get_relation_witness(domain_size)
};

let constraints = {
Expand All @@ -147,49 +134,12 @@ mod tests {
constraints
};

// generate the proof
let proof = prove::<
_,
OpeningProof,
BaseSponge,
ScalarSponge,
_,
N_COL,
N_COL,
N_DSEL,
0,
DummyLookupTable,
>(
domain,
&srs,
&constraints,
kimchi_msm::test::test_completeness_generic_no_lookups::<N_COL, N_COL, N_DSEL, 0, _>(
constraints,
Box::new([]),
proof_inputs,
relation_witness,
domain_size,
&mut rng,
)
.unwrap();

// verify the proof
let verifies = verify::<
_,
OpeningProof,
BaseSponge,
ScalarSponge,
N_COL,
N_COL,
N_DSEL,
0,
0,
DummyLookupTable,
>(
domain,
&srs,
&constraints,
Box::new([]),
&proof,
Witness::zero_vec(domain_size),
);

assert!(verifies);
}
}
26 changes: 11 additions & 15 deletions msm/src/circuit_design/witness.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,6 @@ use crate::{
witness::Witness,
};
use ark_ff::PrimeField;
use kimchi::circuits::domains::EvaluationDomains;
use log::debug;
use std::{collections::BTreeMap, iter, marker::PhantomData};

Expand Down Expand Up @@ -263,18 +262,18 @@ impl<
}

/// Getting multiplicities for range check tables less or equal than 15 bits.
pub fn get_lookup_multiplicities(&self, domain: EvaluationDomains<F>, table_id: LT) -> Vec<F> {
let mut m = Vec::with_capacity(domain.d1.size as usize);
pub fn get_lookup_multiplicities(&self, domain_size: usize, table_id: LT) -> Vec<F> {
let mut m = Vec::with_capacity(domain_size as usize);
m.extend(self.lookup_multiplicities[&table_id].to_vec());
if table_id.length() < (domain.d1.size as usize) {
let n_repeated_dummy_value: usize = (domain.d1.size as usize) - table_id.length() - 1;
if table_id.length() < (domain_size as usize) {
let n_repeated_dummy_value: usize = (domain_size as usize) - table_id.length() - 1;
let repeated_dummy_value: Vec<F> = iter::repeat(-F::one())
.take(n_repeated_dummy_value)
.collect();
m.extend(repeated_dummy_value);
m.push(F::from(n_repeated_dummy_value as u64));
}
assert_eq!(m.len(), domain.d1.size as usize);
assert_eq!(m.len(), domain_size as usize);
m
}
}
Expand Down Expand Up @@ -328,9 +327,7 @@ impl<
self.fixed_selectors = selectors
}

pub fn get_relation_witness(&self, domain: EvaluationDomains<F>) -> Witness<N_WIT, Vec<F>> {
let domain_size: usize = domain.d1.size as usize;

pub fn get_relation_witness(&self, domain_size: usize) -> Witness<N_WIT, Vec<F>> {
// Boxing to avoid stack overflow
let mut witness: Box<Witness<N_WIT, Vec<F>>> = Box::new(Witness {
cols: Box::new(std::array::from_fn(|_| Vec::with_capacity(domain_size))),
Expand Down Expand Up @@ -362,10 +359,9 @@ impl<

pub fn get_logup_witness(
&self,
domain: EvaluationDomains<F>,
domain_size: usize,
lookup_tables_data: BTreeMap<LT, Vec<F>>,
) -> Vec<LogupWitness<F, LT>> {
let domain_size: usize = domain.d1.size as usize;
// Building lookup values
let mut lookup_tables: BTreeMap<LT, Vec<Vec<Logup<F, LT>>>> = BTreeMap::new();
if !lookup_tables_data.is_empty() {
Expand Down Expand Up @@ -399,7 +395,7 @@ impl<
let mut lookup_multiplicities: BTreeMap<LT, Vec<F>> = BTreeMap::new();
// Counting multiplicities & adding fixed column into the last column of every table.
for (table_id, table) in lookup_tables.iter_mut() {
let lookup_m = self.get_lookup_multiplicities(domain, *table_id);
let lookup_m = self.get_lookup_multiplicities(domain_size, *table_id);
lookup_multiplicities.insert(*table_id, lookup_m.clone());
let lookup_t = lookup_tables_data[table_id]
.iter()
Expand Down Expand Up @@ -432,11 +428,11 @@ impl<
/// Generates proof inputs, repacking/collecting internal witness builder state.
pub fn get_proof_inputs(
&self,
domain: EvaluationDomains<F>,
domain_size: usize,
lookup_tables_data: BTreeMap<LT, Vec<F>>,
) -> ProofInputs<N_WIT, F, LT> {
let evaluations = self.get_relation_witness(domain);
let logups = self.get_logup_witness(domain, lookup_tables_data);
let evaluations = self.get_relation_witness(domain_size);
let logups = self.get_logup_witness(domain_size, lookup_tables_data);

ProofInputs {
evaluations,
Expand Down
54 changes: 7 additions & 47 deletions msm/src/fec/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,14 +14,9 @@ mod tests {
lookups::LookupTable,
},
logup::LookupTableID,
prover::prove,
verifier::verify,
witness::Witness,
BaseSponge, Ff1, Fp, OpeningProof, ScalarSponge, BN254,
Ff1, Fp,
};
use ark_ff::UniformRand;
use kimchi::circuits::domains::EvaluationDomains;
use poly_commitment::pairing_proof::PairingSRS;
use rand::{CryptoRng, RngCore};
use std::collections::BTreeMap;

Expand Down Expand Up @@ -72,11 +67,6 @@ mod tests {
pub fn test_fec_completeness() {
let mut rng = o1_utils::tests::make_test_rng();
let domain_size = 1 << 15; // Otherwise we can't do 15-bit lookups.
let domain = EvaluationDomains::<Fp>::create(domain_size).unwrap();

let srs_trapdoor = Fp::rand(&mut rng);
let mut srs: PairingSRS<BN254> = PairingSRS::create(srs_trapdoor, domain.d1.size as usize);
srs.full_srs.add_lagrange_basis(domain.d1);

let mut constraint_env = ConstraintBuilderEnv::<Fp, LookupTable<Ff1>>::create();
constrain_ec_addition::<Fp, Ff1, _>(&mut constraint_env);
Expand All @@ -87,53 +77,23 @@ mod tests {
// Fixed tables can be generated inside lookup_tables_data. Runtime should be generated here.
let mut lookup_tables_data = BTreeMap::new();
for table_id in LookupTable::<Ff1>::all_variants().into_iter() {
lookup_tables_data.insert(table_id, table_id.entries(domain.d1.size));
lookup_tables_data.insert(table_id, table_id.entries(domain_size as u64));
}
let proof_inputs = witness_env.get_proof_inputs(domain, lookup_tables_data);
let proof_inputs = witness_env.get_proof_inputs(domain_size, lookup_tables_data);

// generate the proof
let proof = prove::<
_,
OpeningProof,
BaseSponge,
ScalarSponge,
_,
crate::test::test_completeness_generic::<
FEC_N_COLUMNS,
FEC_N_COLUMNS,
0,
0,
LookupTable<Ff1>,
_,
>(
domain,
&srs,
&constraints,
constraints,
Box::new([]),
proof_inputs,
domain_size,
&mut rng,
)
.unwrap();

// verify the proof
let verifies = verify::<
_,
OpeningProof,
BaseSponge,
ScalarSponge,
FEC_N_COLUMNS,
FEC_N_COLUMNS,
0,
0,
0,
_,
>(
domain,
&srs,
&constraints,
Box::new([]),
&proof,
Witness::zero_vec(domain_size),
);

assert!(verifies);
}
}
Loading

0 comments on commit d931366

Please sign in to comment.