Fix x to be reversed

src/core/prover.rs

@@ -84,7 +84,6 @@ impl<
         let sigma_polys = Self::sigma_polys(table, witness)?;
         end_timer(timer);
         // commit to sigma_polys, witness polys, table polys
-        // let table_poly_comm = Pcs::commit_and_write(pp, &table_poly, transcript)?;
         let witness_poly_comm = Pcs::commit_and_write(pp, &witness_poly, transcript)?;
         let sigma_polys_comms = Pcs::batch_commit_and_write(pp, &sigma_polys, transcript)?;
 
@@ -113,10 +112,15 @@ impl<
             .skip(1)
             .take(table_poly.num_vars())
             .collect_vec();
-
+        // Pcs::open(pp, &witness_poly, &witness_poly_comm, &x.iter().cloned().rev().collect_vec(), witness_poly_x, transcript)?;
+        // sigma_polys.iter().zip(sigma_polys_x.iter()).zip(sigma_polys_comms.iter()).for_each(|((p, sigma_x), comm)| {
+        //     let _ = Pcs::open(pp, &p, &comm, &x.iter().cloned().rev().collect_vec(), sigma_x, transcript);
+        // });
+        // Ok(())
+        let x_reversed = x.iter().cloned().rev().collect_vec();
         let polys = iter::once(&witness_poly).chain(sigma_polys.iter());
         let comms = iter::once(&witness_poly_comm).chain(sigma_polys_comms.iter());
-        let points = iter::repeat(x).take(1 + sigma_polys.len()).collect_vec();
+        let points = iter::repeat(x_reversed).take(1 + sigma_polys.len()).collect_vec();
         let evals = iter::once(witness_poly_x)
             .chain(sigma_polys_x)
             .enumerate()

src/core/verifier.rs

@@ -44,14 +44,17 @@ impl<
             ClassicSumcheck::verify(&svp, max_degree, F::ZERO, num_polys, transcript)?;
         let witness_poly_x = evals.first().unwrap();
         // let table_poly_x = evals.get(1).unwrap();
-        let sigma_poly_x = evals.iter().skip(2).take(table_dimension).collect_vec();
-        // Pcs::verify(vp, &table_comm, &x, table_poly_x, transcript)?;
-
+        let sigma_polys_x = evals.iter().skip(1).take(table_dimension).collect_vec();
+        // Pcs::verify(vp, &witness_comm, &x.iter().cloned().rev().collect_vec(), witness_poly_x, transcript)?;
+        // sigma_comm.iter().zip(sigma_polys_x).try_for_each(|(comm, sigma_x)| {
+        //     Pcs::verify(vp, &comm, &x.iter().cloned().rev().collect_vec(), sigma_x, transcript)
+        // })?;
+        let x_reversed = x.iter().cloned().rev().collect_vec();
         let comms = iter::once(&witness_comm).chain(sigma_comm.iter());
-        let points_vec = iter::repeat(x).take(1 + table_dimension).collect_vec();
+        let points_vec = iter::repeat(x_reversed).take(1 + table_dimension).collect_vec();
         let points = points_vec.as_slice();
         let evals_vec = iter::once(witness_poly_x)
-            .chain(sigma_poly_x)
+            .chain(sigma_polys_x)
             .enumerate()
             .map(|(poly, value)| Evaluation::new(poly, 0, *value))
             .collect_vec();

src/pcs/multilinear.rs

@@ -125,10 +125,16 @@ mod additive {
                 .skip(evals.len() - eq_size)
                 .take(eq_size)
                 .collect_vec();
-            info.iter()
+            let x = info
+                .iter()
                 .zip(evals.iter())
-                .map(|((idx, scalar, _), eval)| eval.clone() * (*scalar).clone() * eq_res[*idx])
-                .fold(F::ZERO, |acc, val| acc + val)
+                .map(|((idx, scalar, _), eval)| {
+                    // println!("for each f : {:?} // {:?}", eval.clone(), eq_res[*idx]);
+                    eval.clone() * (*scalar).clone() * eq_res[*idx]
+                })
+                .sum();
+            println!("eval = {:?}", x);
+            x
         }
     }
 
@@ -150,13 +156,17 @@ mod additive {
 
         let ell = evals.len().next_power_of_two().ilog2() as usize;
         let t = transcript.squeeze_challenges(ell);
-
+        println!("{:?}", polys.iter().map(|p| p.evals()).collect_vec());
+        println!("fg");
+        println!("{:?}", points[0]);
+        println!("{:?}", evals);
         let timer = start_timer(|| "merged_polys");
         let eq_xt = MultilinearPolynomial::eq_xy(&t);
+        println!("eq_xt = {:?}", eq_xt.evals());
         let merged_polys = evals.iter().zip(eq_xt.evals().iter()).fold(
             vec![(F::ONE, Cow::<MultilinearPolynomial<_>>::default()); points.len()],
             |mut merged_polys, (eval, eq_xt_i)| {
-                if merged_polys[eval.point()].1.is_zero() {
+                if merged_polys[eval.point()].1.is_empty() {
                     merged_polys[eval.point()] = (*eq_xt_i, Cow::Borrowed(polys[eval.poly()]));
                 } else {
                     let coeff = merged_polys[eval.point()].0;
@@ -186,12 +196,15 @@ mod additive {
         for p in eq_xys.iter() {
             virtual_polys.push(p);
         }
+        for p in virtual_polys.iter() {
+            println!("virtual polys eval : {:?}", p.evals());
+        }
         let virtual_poly = VirtualPolynomial::new(num_vars, virtual_polys.as_slice());
 
         let tilde_gs_sum =
             inner_product(evals.iter().map(Evaluation::value), &eq_xt[..evals.len()]);
         let spp = ClassicSumcheckProverParam::new(num_vars, 2);
-
+        println!("sum = {:?}", tilde_gs_sum);
         let (challenges, _) = SumCheck::prove(
             &spp,
             &combine_function,
@@ -256,8 +269,9 @@ mod additive {
         let eq_xt = MultilinearPolynomial::eq_xy(&t);
         let tilde_gs_sum =
             inner_product(evals.iter().map(Evaluation::value), &eq_xt[..evals.len()]);
+        // println!("verify sum {:?}", tilde_gs_sum);
         let svp = ClassicSumcheckVerifierParam::new(num_vars, 2);
-        let num_polys = 2;
+        let num_polys = points.len() + evals.len();
         let (g_prime_eval, _, challenges) =
             SumCheck::verify(&svp, 2, tilde_gs_sum, num_polys, transcript)?;
 
@@ -274,6 +288,7 @@ mod additive {
             let bases = evals.iter().map(|eval| comms[eval.poly()]);
             Pcs::Commitment::msm(&scalars, bases)
         };
+        println!("DFDF");
         Pcs::verify(vp, &g_prime_comm, &challenges, &g_prime_eval, transcript)
     }
 }

src/poly/multilinear.rs

@@ -62,7 +62,7 @@ impl<F: Field> MultilinearPolynomial<F> {
         )
     }
 
-    fn is_empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
         self.evals.is_empty()
     }