Feat: define objects over base fields

circ_blocks/Cargo.toml

@@ -29,6 +29,7 @@ thiserror = "1"
 bellman = { git = "https://github.com/alex-ozdemir/bellman.git", branch = "mirage", optional = true }
 rayon = { version = "1", optional = true }
 ff = { version = "0.12", optional = true }
+halo2curves = "0.1.0"
 fxhash = "0.2"
 good_lp = { version = "1.10", features = [
   "lp-solvers",

circ_blocks/examples/zxc.rs

@@ -12,6 +12,7 @@ use circ::target::r1cs::wit_comp::StagedWitCompEvaluator;
 use circ::target::r1cs::ProverData;
 use circ::target::r1cs::{Lc, VarType};
 use core::cmp::min;
+use halo2curves::serde::SerdeObject;
 use libspartan::scalar::{ScalarExt2, SpartanExtensionField};
 use rug::Integer;
 
@@ -33,7 +34,6 @@ use libspartan::{
 use merlin::Transcript;
 use serde::{Deserialize, Serialize};
 use std::time::*;
-use std::time::*;
 
 // How many reserved variables (EXCLUDING V) are in front of the actual input / output?
 // %BN, %RET, %TS, %AS, %SP, %BP
@@ -437,7 +437,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
             for exec in block {
                 writeln!(&mut f, "EXEC {}", exec_counter)?;
                 for assg in &exec.assignment {
-                    write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                    let mut padded = [0; 32];
+                    padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                    write!(&mut f, "{} ", bytes_to_integer(&padded))?;
                 }
                 writeln!(&mut f)?;
                 exec_counter += 1;
@@ -449,7 +452,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
         for exec in &self.exec_inputs {
             writeln!(&mut f, "EXEC {}", exec_counter)?;
             for assg in &exec.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                let mut padded = [0; 32];
+                padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                write!(&mut f, "{} ", bytes_to_integer(&padded))?;
             }
             writeln!(&mut f)?;
             exec_counter += 1;
@@ -459,7 +465,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
         for addr in &self.init_phy_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                let mut padded = [0; 32];
+                padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                write!(&mut f, "{} ", bytes_to_integer(&padded))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -469,7 +478,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
         for addr in &self.init_vir_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                let mut padded = [0; 32];
+                padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                write!(&mut f, "{} ", bytes_to_integer(&padded))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -479,7 +491,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
         for addr in &self.addr_phy_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                let mut padded = [0; 32];
+                padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                write!(&mut f, "{} ", bytes_to_integer(&padded))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -489,7 +504,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
         for addr in &self.addr_vir_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                let mut padded = [0; 32];
+                padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                write!(&mut f, "{} ", bytes_to_integer(&padded))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -499,7 +517,10 @@ impl<S: SpartanExtensionField> RunTimeKnowledge<S> {
         for addr in &self.addr_ts_bits_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                let mut padded = [0; 32];
+                padded[..8].copy_from_slice(&assg.to_raw_bytes());
+
+                write!(&mut f, "{} ", bytes_to_integer(&padded))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;

spartan_parallel/Cargo.toml

@@ -30,6 +30,7 @@ colored = { version = "2", default-features = false, optional = true }
 flate2 = { version = "1" }
 goldilocks = { git = "https://github.com/scroll-tech/ceno-Goldilocks" }
 ff = "0.13.0"
+halo2curves = "0.1.0"
 
 [dev-dependencies]
 criterion = "0.5"

spartan_parallel/src/custom_dense_mlpoly.rs

@@ -1,11 +1,11 @@
 #![allow(clippy::too_many_arguments)]
 use std::cmp::min;
 
+use super::math::Math;
 use crate::dense_mlpoly::DensePolynomial;
+use crate::mle::Ext;
 use crate::scalar::SpartanExtensionField;
 
-use super::math::Math;
-
 const MODE_P: usize = 1;
 const MODE_Q: usize = 2;
 const MODE_W: usize = 3;
@@ -328,7 +328,7 @@ impl<S: SpartanExtensionField> DensePolynomialPqx<S> {
   }
 
   // Convert to a (p, q_rev, x_rev) regular dense poly of form (p, q, x)
-  pub fn to_dense_poly(&self) -> DensePolynomial<S> {
+  pub fn to_dense_poly(&self) -> DensePolynomial<S, Ext> {
     let mut Z_poly =
       vec![
         S::field_zero();

spartan_parallel/src/dense_mlpoly.rs

@@ -1,23 +1,24 @@
 #![allow(clippy::too_many_arguments)]
-use crate::scalar::SpartanExtensionField;
-
 use super::errors::ProofVerifyError;
 use super::math::Math;
 use super::random::RandomTape;
 use super::transcript::ProofTranscript;
+use crate::mle::{Base, Ext, MLEType, MLE};
+use crate::scalar::SpartanExtensionField;
 use core::ops::Index;
+use ff::Field;
 use merlin::Transcript;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
+use std::{collections::HashMap, process::Output};
 
 #[cfg(feature = "multicore")]
 use rayon::prelude::*;
 
 #[derive(Debug, Clone)]
-pub struct DensePolynomial<S: SpartanExtensionField> {
+pub struct DensePolynomial<S: SpartanExtensionField, T: MLEType> {
   num_vars: usize, // the number of variables in the multilinear polynomial
   len: usize,
-  Z: Vec<S>, // evaluations of the polynomial in all the 2^num_vars Boolean inputs
+  Z: MLE<S, T>, // evaluations of the polynomial in all the 2^num_vars Boolean inputs
 }
 
 pub struct EqPolynomial<S: SpartanExtensionField> {
@@ -114,15 +115,15 @@ impl<S: SpartanExtensionField> IdentityPolynomial<S> {
   }
 }
 
-impl<S: SpartanExtensionField> DensePolynomial<S> {
+impl<S: SpartanExtensionField> DensePolynomial<S, Ext> {
   pub fn new(mut Z: Vec<S>) -> Self {
     // If length of Z is not a power of 2, append Z with 0
     let zero = S::field_zero();
     Z.extend(vec![zero; Z.len().next_power_of_two() - Z.len()]);
     DensePolynomial {
       num_vars: Z.len().log_2(),
       len: Z.len(),
-      Z,
+      Z: MLE::<S, Ext>::new(Z),
     }
   }
 
@@ -134,11 +135,7 @@ impl<S: SpartanExtensionField> DensePolynomial<S> {
     self.len
   }
 
-  pub fn clone(&self) -> DensePolynomial<S> {
-    DensePolynomial::new(self.Z[0..self.len].to_vec())
-  }
-
-  pub fn split(&self, idx: usize) -> (DensePolynomial<S>, DensePolynomial<S>) {
+  pub fn split(&self, idx: usize) -> (DensePolynomial<S, Ext>, DensePolynomial<S, Ext>) {
     assert!(idx < self.len());
     (
       DensePolynomial::new(self.Z[..idx].to_vec()),
@@ -253,7 +250,7 @@ impl<S: SpartanExtensionField> DensePolynomial<S> {
     assert_eq!(r.len(), self.get_num_vars());
     let chis = EqPolynomial::new(r.to_vec()).evals();
     assert_eq!(chis.len(), self.Z.len());
-    Self::compute_dotproduct(&self.Z, &chis)
+    Self::compute_dotproduct(&self.Z[0..], &chis)
   }
 
   fn compute_dotproduct(a: &[S], b: &[S]) -> S {
@@ -262,10 +259,10 @@ impl<S: SpartanExtensionField> DensePolynomial<S> {
   }
 
   fn vec(&self) -> &Vec<S> {
-    &self.Z
+    &self.Z.inner_ref()
   }
 
-  pub fn extend(&mut self, other: &DensePolynomial<S>) {
+  pub fn extend(&mut self, other: &DensePolynomial<S, Ext>) {
     // TODO: allow extension even when some vars are bound
     assert_eq!(self.Z.len(), self.len);
     let other_vec = other.vec();
@@ -276,9 +273,9 @@ impl<S: SpartanExtensionField> DensePolynomial<S> {
     assert_eq!(self.Z.len(), self.len);
   }
 
-  pub fn merge<'a, I>(polys: I) -> DensePolynomial<S>
+  pub fn merge<'a, I>(polys: I) -> DensePolynomial<S, Ext>
   where
-    I: IntoIterator<Item = DensePolynomial<S>>,
+    I: IntoIterator<Item = DensePolynomial<S, Ext>>,
   {
     let mut Z: Vec<S> = Vec::new();
     for poly in polys.into_iter() {
@@ -300,12 +297,34 @@ impl<S: SpartanExtensionField> DensePolynomial<S> {
   }
 }
 
-impl<S: SpartanExtensionField> Index<usize> for DensePolynomial<S> {
+impl<S: SpartanExtensionField> DensePolynomial<S, Base> {
+  pub fn new_from_base(mut Z: Vec<S::BaseField>) -> Self {
+    // If length of Z is not a power of 2, append Z with 0
+    let zero = S::BaseField::ZERO;
+    Z.extend(vec![zero; Z.len().next_power_of_two() - Z.len()]);
+    DensePolynomial {
+      num_vars: Z.len().log_2(),
+      len: Z.len(),
+      Z: MLE::<S, Base>::new(Z),
+    }
+  }
+}
+
+impl<S: SpartanExtensionField> Index<usize> for DensePolynomial<S, Ext> {
   type Output = S;
 
   #[inline(always)]
-  fn index(&self, _index: usize) -> &S {
-    &(self.Z[_index])
+  fn index(&self, index: usize) -> &Self::Output {
+    &(self.Z[index])
+  }
+}
+
+impl<S: SpartanExtensionField> Index<usize> for DensePolynomial<S, Base> {
+  type Output = S::BaseField;
+
+  #[inline(always)]
+  fn index(&self, index: usize) -> &Self::Output {
+    &(self.Z[index])
   }
 }
 
@@ -320,7 +339,7 @@ impl<S: SpartanExtensionField> PolyEvalProof<S> {
   }
 
   pub fn prove(
-    _poly: &DensePolynomial<S>,
+    _poly: &DensePolynomial<S, Ext>,
     _r: &[S], // point at which the polynomial is evaluated
     _Zr: &S,  // evaluation of \widetilde{Z}(r)
     _transcript: &mut Transcript,
@@ -352,7 +371,7 @@ impl<S: SpartanExtensionField> PolyEvalProof<S> {
 
   // Evaluation of multiple points on the same instance
   pub fn prove_batched_points(
-    _poly: &DensePolynomial<S>,
+    _poly: &DensePolynomial<S, Ext>,
     _r_list: Vec<Vec<S>>, // point at which the polynomial is evaluated
     _Zr_list: Vec<S>,     // evaluation of \widetilde{Z}(r) on each point
     _transcript: &mut Transcript,
@@ -375,9 +394,9 @@ impl<S: SpartanExtensionField> PolyEvalProof<S> {
   // Evaluation on multiple instances, each at different point
   // Size of each instance might be different, but all are larger than the evaluation point
   pub fn prove_batched_instances(
-    _poly_list: &Vec<DensePolynomial<S>>, // list of instances
-    _r_list: Vec<&Vec<S>>,                // point at which the polynomial is evaluated
-    _Zr_list: &Vec<S>,                    // evaluation of \widetilde{Z}(r) on each instance
+    _poly_list: &Vec<DensePolynomial<S, Ext>>, // list of instances
+    _r_list: Vec<&Vec<S>>,                     // point at which the polynomial is evaluated
+    _Zr_list: &Vec<S>,                         // evaluation of \widetilde{Z}(r) on each instance
     _transcript: &mut Transcript,
     _random_tape: &mut RandomTape<S>,
   ) -> Vec<PolyEvalProof<S>> {
@@ -399,7 +418,7 @@ impl<S: SpartanExtensionField> PolyEvalProof<S> {
   // Like prove_batched_instances, but r is divided into rq ++ ry
   // Each polynomial is supplemented with num_proofs and num_inputs
   pub fn prove_batched_instances_disjoint_rounds(
-    _poly_list: &Vec<&DensePolynomial<S>>,
+    _poly_list: &Vec<&DensePolynomial<S, Ext>>,
     _num_proofs_list: &Vec<usize>,
     _num_inputs_list: &Vec<usize>,
     _rq: &[S],
@@ -426,7 +445,7 @@ impl<S: SpartanExtensionField> PolyEvalProof<S> {
 
   // Treat the polynomial(s) as univariate and open on a single point
   pub fn prove_uni_batched_instances(
-    _poly_list: &Vec<&DensePolynomial<S>>,
+    _poly_list: &Vec<&DensePolynomial<S, Ext>>,
     _r: &S,       // point at which the polynomial is evaluated
     _Zr: &Vec<S>, // evaluation of \widetilde{Z}(r)
     _transcript: &mut Transcript,