arnaucube/miden-crypto
1
0
Fork 0
mirror of https://github.com/arnaucube/miden-crypto.git synced 2026-01-09 15:41:30 +01:00
Code Issues Projects Releases Wiki Activity

minor nits

Browse Source
This commit is contained in:
Al-Kindi-0
2024-01-22 19:41:45 +01:00
parent 0b074a795d
commit 0f06fa30a9
2 changed files with 17 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/gkr/circuit/mod.rs
View File

@@ -541,19 +541,19 @@ impl<E: FieldElement<BaseField = BaseElement> + 'static> CircuitProof<E> {
H: ElementHasher<BaseField = BaseElement>, H: ElementHasher<BaseField = BaseElement>,
>( >(
&self, &self,
claims_sum_vec: &(E, E, E, E), claims_sum_vec: &[E],
transcript: &mut C, transcript: &mut C,
) -> ((E, E), Vec<E>) { ) -> ((E, E), Vec<E>) {
let num_layers = self.proof.len() as usize - 1; let num_layers = self.proof.len() as usize - 1;
let mut rand: Vec<E> = Vec::new(); let mut rand: Vec<E> = Vec::new();
let data = vec![claims_sum_vec.0, claims_sum_vec.1, claims_sum_vec.2, claims_sum_vec.3]; let data = claims_sum_vec;
transcript.reseed(H::hash_elements(&data)); transcript.reseed(H::hash_elements(&data));
let r_cord = transcript.draw().unwrap(); let r_cord = transcript.draw().unwrap();
let p_poly_coef = vec![claims_sum_vec.0, claims_sum_vec.1]; let p_poly_coef = vec![claims_sum_vec[0], claims_sum_vec[1]];
let q_poly_coef = vec![claims_sum_vec.2, claims_sum_vec.3]; let q_poly_coef = vec![claims_sum_vec[2], claims_sum_vec[3]];
let p_poly = MultiLinear::new(p_poly_coef); let p_poly = MultiLinear::new(p_poly_coef);
let q_poly = MultiLinear::new(q_poly_coef); let q_poly = MultiLinear::new(q_poly_coef);
@@ -619,27 +619,27 @@ impl<E: FieldElement<BaseField = BaseElement> + 'static> CircuitProof<E> {
&self, &self,
composition_polys: Vec<Vec<Arc<dyn CompositionPolynomial<E>>>>, composition_polys: Vec<Vec<Arc<dyn CompositionPolynomial<E>>>>,
final_layer_proof: super::sumcheck::FullProof<E>, final_layer_proof: super::sumcheck::FullProof<E>,
claims_sum_vec: &(E, E, E, E), claims_sum_vec: &[E],
transcript: &mut C, transcript: &mut C,
) -> (FinalEvaluationClaim<E>, Vec<E>) { ) -> (FinalEvaluationClaim<E>, Vec<E>) {
let num_layers = self.proof.len() as usize; let num_layers = self.proof.len() as usize;
let mut rand: Vec<E> = Vec::new(); let mut rand: Vec<E> = Vec::new();
// Check that a/b + d/e is equal to 0 // Check that a/b + d/e is equal to 0
assert_ne!(claims_sum_vec.2, E::ZERO); assert_ne!(claims_sum_vec[2], E::ZERO);
assert_ne!(claims_sum_vec.3, E::ZERO); assert_ne!(claims_sum_vec[3], E::ZERO);
assert_eq!( assert_eq!(
claims_sum_vec.0 * claims_sum_vec.3 + claims_sum_vec.1 * claims_sum_vec.2, claims_sum_vec[0] * claims_sum_vec[3] + claims_sum_vec[1] * claims_sum_vec[2],
E::ZERO E::ZERO
); );
let data = vec![claims_sum_vec.0, claims_sum_vec.1, claims_sum_vec.2, claims_sum_vec.3]; let data = claims_sum_vec;
transcript.reseed(H::hash_elements(&data)); transcript.reseed(H::hash_elements(&data));
let r_cord = transcript.draw().unwrap(); let r_cord = transcript.draw().unwrap();
let p_poly_coef = vec![claims_sum_vec.0, claims_sum_vec.1]; let p_poly_coef = vec![claims_sum_vec[0], claims_sum_vec[1]];
let q_poly_coef = vec![claims_sum_vec.2, claims_sum_vec.3]; let q_poly_coef = vec![claims_sum_vec[2], claims_sum_vec[3]];
let p_poly = MultiLinear::new(p_poly_coef); let p_poly = MultiLinear::new(p_poly_coef);
let q_poly = MultiLinear::new(q_poly_coef); let q_poly = MultiLinear::new(q_poly_coef);
@@ -905,7 +905,7 @@ mod sum_circuit_tests {
let seed = [BaseElement::ZERO; 4]; let seed = [BaseElement::ZERO; 4];
let mut transcript = RpoRandomCoin::new(seed.into()); let mut transcript = RpoRandomCoin::new(seed.into());
let claims = (p0, p1, q0, q1); let claims = vec![p0, p1, q0, q1];
proof.verify(&claims, &mut transcript); proof.verify(&claims, &mut transcript);
} }
@@ -971,7 +971,7 @@ mod sum_circuit_tests {
let seed = [BaseElement::ZERO; 4]; let seed = [BaseElement::ZERO; 4];
let mut transcript = RpoRandomCoin::new(seed.into()); let mut transcript = RpoRandomCoin::new(seed.into());
let claims = (p0, p1, q0, q1); let claims = vec![p0, p1, q0, q1];
proof.verify(&claims, &mut transcript); proof.verify(&claims, &mut transcript);
} }
} }

10
src/gkr/sumcheck/tests.rs
View File

@@ -59,8 +59,6 @@ fn gkr_workflow() {
// 2. Randomness defining the Lagrange kernel in the final sum-check protocol. Note that this // 2. Randomness defining the Lagrange kernel in the final sum-check protocol. Note that this
// Lagrange kernel is different from the one used by the STARK (outer) prover to open the MLs // Lagrange kernel is different from the one used by the STARK (outer) prover to open the MLs
// at the evaluation point. // at the evaluation point.
let circuit_outputs =
(circuit_outputs[0], circuit_outputs[1], circuit_outputs[2], circuit_outputs[3]);
let (final_eval_claim, gkr_lagrange_kernel_rand) = gkr_before_last_proof.verify_virtual_bus( let (final_eval_claim, gkr_lagrange_kernel_rand) = gkr_before_last_proof.verify_virtual_bus(
composition_polys.clone(), composition_polys.clone(),
final_layer_proof, final_layer_proof,
@@ -101,7 +99,7 @@ fn gkr_workflow() {
let left_den_eval = mls[2].evaluate(&evaluation_point); let left_den_eval = mls[2].evaluate(&evaluation_point);
let right_den_eval = mls[3].evaluate(&evaluation_point); let right_den_eval = mls[3].evaluate(&evaluation_point);
// The verifier absorbs the claimed openings and generates batching randomness // The verifier absorbs the claimed openings and generates batching randomness lambda
let mut query = vec![left_num_eval, right_num_eval, left_den_eval, right_den_eval]; let mut query = vec![left_num_eval, right_num_eval, left_den_eval, right_den_eval];
transcript.reseed(Rpo256::hash_elements(&query)); transcript.reseed(Rpo256::hash_elements(&query));
let lambdas: Vec<BaseElement> = vec![ let lambdas: Vec<BaseElement> = vec![
@@ -112,17 +110,17 @@ fn gkr_workflow() {
let batched_query = let batched_query =
query[0] + query[1] * lambdas[0] + query[2] * lambdas[1] + query[3] * lambdas[2]; query[0] + query[1] * lambdas[0] + query[2] * lambdas[1] + query[3] * lambdas[2];
// The prover generates the Lagrange kernel // The prover generates the Lagrange kernel as an auxiliary column
let mut rev_evaluation_point = evaluation_point; let mut rev_evaluation_point = evaluation_point;
rev_evaluation_point.reverse(); rev_evaluation_point.reverse();
let lagrange_kernel = EqPolynomial::new(rev_evaluation_point).evaluations(); let lagrange_kernel = EqPolynomial::new(rev_evaluation_point).evaluations();
// The prover generates the additional auxiliary column for the inner product
let tmp_col: Vec<BaseElement> = (0..mls[0].len()) let tmp_col: Vec<BaseElement> = (0..mls[0].len())
.map(|i| { .map(|i| {
mls[0][i] + mls[1][i] * lambdas[0] + mls[2][i] * lambdas[1] + mls[3][i] * lambdas[2] mls[0][i] + mls[1][i] * lambdas[0] + mls[2][i] * lambdas[1] + mls[3][i] * lambdas[2]
}) })
.collect(); .collect();
// The prover generates the additional auxiliary column for the inner product
let mut running_sum_col = vec![BaseElement::ZERO; tmp_col.len() + 1]; let mut running_sum_col = vec![BaseElement::ZERO; tmp_col.len() + 1];
running_sum_col[0] = BaseElement::ZERO; running_sum_col[0] = BaseElement::ZERO;
for i in 1..(tmp_col.len() + 1) { for i in 1..(tmp_col.len() + 1) {