Reorder R1CS constraints + CompactPolynomial refactor

common/src/lib.rs

@@ -1,4 +1,3 @@
 pub mod attributes;
 pub mod constants;
 pub mod rv_trace;
-pub mod serializable;

jolt-core/Cargo.toml

@@ -27,9 +27,16 @@ default = [
     "ark-ff/asm",
     "host",
     "rayon",
+    "reorder",
 ]
 host = ["dep:reqwest", "dep:tokio"]
-icicle = ["default", "dep:icicle-runtime", "dep:icicle-core", "dep:icicle-bn254"]
+icicle = [
+    "default",
+    "dep:icicle-runtime",
+    "dep:icicle-core",
+    "dep:icicle-bn254",
+]
+reorder = []
 
 [dependencies]
 ark-bn254 = "0.4.0"
@@ -119,9 +126,13 @@ name = "jolt_core"
 path = "src/lib.rs"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-icicle-runtime = { git = "https://github.com/ingonyama-zk/icicle-jolt.git", features = ["cuda_backend"], rev = "ed93e21", optional = true }
+icicle-runtime = { git = "https://github.com/ingonyama-zk/icicle-jolt.git", features = [
+    "cuda_backend",
+], rev = "ed93e21", optional = true }
 icicle-core = { git = "https://github.com/ingonyama-zk/icicle-jolt.git", rev = "ed93e21", optional = true }
-icicle-bn254 = { git = "https://github.com/ingonyama-zk/icicle-jolt.git", features = ["cuda_backend"], rev = "ed93e21", optional = true }
+icicle-bn254 = { git = "https://github.com/ingonyama-zk/icicle-jolt.git", features = [
+    "cuda_backend",
+], rev = "ed93e21", optional = true }
 memory-stats = "1.0.0"
 sys-info = "0.9.1"
 tokio = { version = "1.38.0", optional = true, features = ["rt-multi-thread"] }

jolt-core/benches/binding.rs

@@ -49,7 +49,7 @@ fn benchmark_dense<F: JoltField>(c: &mut Criterion, num_vars: usize) {
                 },
                 |(mut poly, r)| {
                     for i in 0..num_vars {
-                        criterion::black_box(poly.bound_poly_var_top_par(&r[i]));
+                        criterion::black_box(poly.bound_poly_var_top(&r[i]));
                     }
                 },
             );
@@ -157,19 +157,19 @@ fn main() {
     benchmark_sparse_interleaved::<Fr>(&mut criterion, 64, 21, 0.1);
     benchmark_sparse_interleaved::<Fr>(&mut criterion, 128, 21, 0.1);
 
-    // benchmark_dense::<Fr>(&mut criterion, 20);
-    // benchmark_dense::<Fr>(&mut criterion, 22);
-    // benchmark_dense::<Fr>(&mut criterion, 24);
+    benchmark_dense::<Fr>(&mut criterion, 20);
+    benchmark_dense::<Fr>(&mut criterion, 22);
+    benchmark_dense::<Fr>(&mut criterion, 24);
 
-    // benchmark_dense_interleaved::<Fr>(&mut criterion, 22);
+    benchmark_dense_interleaved::<Fr>(&mut criterion, 22);
     // benchmark_dense_interleaved::<Fr>(&mut criterion, 23);
-    // benchmark_dense_interleaved::<Fr>(&mut criterion, 24);
+    benchmark_dense_interleaved::<Fr>(&mut criterion, 24);
     // benchmark_dense_interleaved::<Fr>(&mut criterion, 25);
 
-    // benchmark_dense_batch::<Fr>(&mut criterion, 20, 4);
-    // benchmark_dense_batch::<Fr>(&mut criterion, 20, 8);
-    // benchmark_dense_batch::<Fr>(&mut criterion, 20, 16);
-    // benchmark_dense_batch::<Fr>(&mut criterion, 20, 32);
+    benchmark_dense_batch::<Fr>(&mut criterion, 20, 4);
+    benchmark_dense_batch::<Fr>(&mut criterion, 20, 8);
+    benchmark_dense_batch::<Fr>(&mut criterion, 20, 16);
+    benchmark_dense_batch::<Fr>(&mut criterion, 20, 32);
 
     criterion.final_summary();
 }

jolt-core/benches/commit.rs

@@ -5,6 +5,7 @@ use jolt_core::poly::commitment::commitment_scheme::{BatchType, CommitShape, Com
 use jolt_core::poly::commitment::hyperkzg::HyperKZG;
 use jolt_core::poly::commitment::kzg::CommitMode;
 use jolt_core::poly::commitment::zeromorph::Zeromorph;
+use jolt_core::poly::multilinear_polynomial::MultilinearPolynomial;
 use jolt_core::utils::transcript::{KeccakTranscript, Transcript};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -77,8 +78,8 @@ fn benchmark_commit<PCS, F, ProofTranscript>(
     let (leaves, setup, _) =
         setup_bench::<PCS, F, ProofTranscript>(num_layer, layer_size, threshold);
     let leaves = leaves
-        .iter()
-        .map(|layer| layer.as_slice())
+        .into_iter()
+        .map(|layer| MultilinearPolynomial::from(layer))
         .collect::<Vec<_>>();
     let mode = match batch_type {
         BatchType::GrandProduct => CommitMode::GrandProduct,
@@ -88,7 +89,11 @@ fn benchmark_commit<PCS, F, ProofTranscript>(
         &format!("{} Commit(mode:{:?}): {}% Ones", name, mode, threshold),
         |b| {
             b.iter(|| {
-                PCS::batch_commit(&leaves, &setup, batch_type.clone());
+                PCS::batch_commit(
+                    &leaves.iter().collect::<Vec<_>>(),
+                    &setup,
+                    batch_type.clone(),
+                );
             });
         },
     );

jolt-core/benches/compute_cubic.rs

@@ -3,13 +3,11 @@ use ark_std::{rand::Rng, test_rng};
 use criterion::Criterion;
 use jolt_core::field::JoltField;
 use jolt_core::poly::dense_interleaved_poly::DenseInterleavedPolynomial;
-use jolt_core::poly::dense_mlpoly::DensePolynomial;
 use jolt_core::poly::sparse_interleaved_poly::{SparseCoefficient, SparseInterleavedPolynomial};
 use jolt_core::poly::split_eq_poly::SplitEqPolynomial;
-use jolt_core::subprotocols::sumcheck::{BatchedCubicSumcheck, Bindable};
+use jolt_core::subprotocols::sumcheck::BatchedCubicSumcheck;
 use jolt_core::utils::math::Math;
 use jolt_core::utils::transcript::KeccakTranscript;
-use rayon::prelude::*;
 
 fn random_dense_coeffs<F: JoltField>(rng: &mut impl Rng, num_vars: usize) -> Vec<F> {
     std::iter::repeat_with(|| F::random(rng))
@@ -110,11 +108,11 @@ fn main() {
         .configure_from_args()
         .warm_up_time(std::time::Duration::from_secs(5));
 
-    // benchmark_dense_interleaved::<Fr>(&mut criterion, 20);
+    benchmark_dense_interleaved::<Fr>(&mut criterion, 20);
     // benchmark_dense_interleaved::<Fr>(&mut criterion, 21);
-    // benchmark_dense_interleaved::<Fr>(&mut criterion, 22);
+    benchmark_dense_interleaved::<Fr>(&mut criterion, 22);
     // benchmark_dense_interleaved::<Fr>(&mut criterion, 23);
-    // benchmark_dense_interleaved::<Fr>(&mut criterion, 24);
+    benchmark_dense_interleaved::<Fr>(&mut criterion, 24);
     // benchmark_dense_interleaved::<Fr>(&mut criterion, 25);
 
     benchmark_sparse_interleaved::<Fr>(&mut criterion, 64, 20, 0.1);

jolt-core/benches/iai.rs

@@ -1,20 +1,9 @@
-use ark_bn254::{Fr, G1Projective};
-use ark_ec::CurveGroup;
-use ark_std::{test_rng, UniformRand};
+use ark_bn254::Fr;
+use ark_std::test_rng;
 use iai_callgrind::{library_benchmark, library_benchmark_group, main};
-use jolt_core::{field::JoltField, msm::VariableBaseMSM, poly::dense_mlpoly::DensePolynomial};
+use jolt_core::{field::JoltField, poly::dense_mlpoly::DensePolynomial};
 use std::hint::black_box;
 
-fn msm_setup<G: CurveGroup>(num_points: usize) -> (Vec<G>, Vec<G::ScalarField>) {
-    let mut rng = test_rng();
-
-    // Generate a vector of random affine points on the curve.
-    (
-        vec![G::rand(&mut rng); num_points],
-        vec![G::ScalarField::rand(&mut rng); num_points],
-    )
-}
-
 fn bound_poly_setup<F: JoltField>(size: usize) -> (DensePolynomial<F>, F) {
     let mut rng = test_rng();
 
@@ -32,12 +21,6 @@ fn eval_poly_setup<F: JoltField>(size: usize) -> (DensePolynomial<F>, Vec<F>) {
     (poly, points)
 }
 
-#[library_benchmark]
-#[bench::long(msm_setup::<G1Projective>(4096))]
-fn bench_msm<G: CurveGroup>(input: (Vec<G>, Vec<G::ScalarField>)) -> G {
-    black_box(VariableBaseMSM::msm(&G::normalize_batch(&input.0), None, &input.1).unwrap())
-}
-
 #[library_benchmark]
 #[bench::long(bound_poly_setup::<Fr>(4096))]
 fn bench_polynomial_binding<F: JoltField>(input: (DensePolynomial<F>, F)) {
@@ -54,7 +37,7 @@ fn bench_polynomial_evaluate<F: JoltField>(input: (DensePolynomial<F>, Vec<F>))
 
 library_benchmark_group!(
     name = jolt_core_ops;
-    benchmarks = bench_msm, bench_polynomial_binding, bench_polynomial_evaluate
+    benchmarks = bench_polynomial_binding, bench_polynomial_evaluate
 );
 
 main!(library_benchmark_groups = jolt_core_ops);