integrate whir into Expander

Cargo.toml

@@ -25,35 +25,42 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
-ark-std = "0.4"
-ark-bn254 = "0.4.0"
-ark-ec = "0.4.0"
-ark-ff = { version = "0.4" }
+ark-std = { version = "0.5", features = ["std"] }
+ark-bn254 = "0.5.0"
+ark-ec = "0.5.0"
+ark-ff = { version = "0.5", features = ["asm", "std"] }
+
 bytes = "1.6.0"
 chrono = "0.4.38"
 clap = { version = "4.1", features = ["derive"] }
 cfg-if = "1.0"
 criterion = { version = "0.5", features = ["html_reports"] }
+derivative = "2.2.0"
 env_logger = "0.11.3"
+ethnum = "1.5.0"
 halo2curves = { git = "https://github.com/PolyhedraZK/halo2curves", default-features = false, features = [
     "bits",
 ] }
 syn = "2.0"       # For parsing Rust code
+spongefish = { git = "https://github.com/arkworks-rs/spongefish", features = [
+    "arkworks-algebra",
+] }
+spongefish-pow = { git = "https://github.com/arkworks-rs/spongefish" }
 quote = "1.0"     # For generating code
 proc-macro2 = "1.0"  # For working with tokens
 itertools = "0.13"
 log = "0.4"
 mpi = "0.8.0"
 rand = "0.8.5"
+rand_chacha = "0.3.1"
 raw-cpuid = "11.1.0"
 rayon = "1.10"
 sha2 = "0.10.8"
+thiserror = "1.0.63"
 tiny-keccak = { version = "2.0.2", features = [ "sha3", "keccak" ] }
 tokio = { version = "1.38.0", features = ["full"] }
+transpose = "0.2.3"
 tynm = { version = "0.1.6", default-features = false }
 warp = "0.3.7"
-thiserror = "1.0.63"
-ethnum = "1.5.0"
-rand_chacha = "0.3.1"
-derivative = "2.2.0"
-transpose = "0.2.3"
+# whir = { git = "https://github.com/WizardOfMenlo/whir", rev = "9d7a97b169542f8d0787db482ee58f7b9b660848" }
+ whir = { git = "https://github.com/zhenfeizhang/whir" }

arith/goldilocks/Cargo.toml

@@ -7,9 +7,11 @@ edition = "2021"
 arith = { path = ".." }
 serdes = { path = "../../serdes" }
 
+ark-ff.workspace = true
 ark-std.workspace = true
 ethnum.workspace = true
 rand.workspace = true
+whir.workspace = true
 
 [[bench]]
 name = "goldilocks"

arith/goldilocks/src/goldilocks.rs

@@ -5,9 +5,11 @@ use std::{
 };
 
 use arith::{field_common, FFTField, Field, SimdField};
+use ark_ff::{BigInteger64, PrimeField};
 use ethnum::U256;
 use rand::RngCore;
 use serdes::{ExpSerde, SerdeResult};
+use whir::crypto::fields::Field64;
 
 use crate::goldilocks::p2_instructions::{assume, branch_hint, reduce128, try_inverse_u64};
 
@@ -603,3 +605,34 @@ pub(crate) mod p2_instructions {
     //     )
     // }
 }
+
+impl From<Field64> for Goldilocks {
+    #[inline(always)]
+    fn from(x: Field64) -> Self {
+        Goldilocks {
+            v: x.into_bigint().0[0],
+        }
+    }
+}
+
+impl From<&Field64> for Goldilocks {
+    #[inline(always)]
+    fn from(x: &Field64) -> Self {
+        Goldilocks {
+            v: x.into_bigint().0[0],
+        }
+    }
+}
+
+impl From<Goldilocks> for Field64 {
+    #[inline(always)]
+    fn from(x: Goldilocks) -> Self {
+        Field64::from_bigint(BigInteger64::new([x.v])).unwrap()
+    }
+}
+impl From<&Goldilocks> for Field64 {
+    #[inline(always)]
+    fn from(x: &Goldilocks) -> Self {
+        Field64::from_bigint(BigInteger64::new([x.v])).unwrap()
+    }
+}

arith/goldilocks/src/goldilocks_ext.rs

@@ -7,6 +7,7 @@ use arith::{field_common, ExtensionField, FFTField, Field, SimdField};
 use ethnum::U256;
 use rand::RngCore;
 use serdes::ExpSerde;
+use whir::crypto::fields::Field64_2;
 
 use crate::{
     goldilocks::{mod_reduce_u64, Goldilocks},
@@ -412,3 +413,40 @@ impl Mul<Goldilocksx8> for GoldilocksExt2 {
         }
     }
 }
+
+impl From<Field64_2> for GoldilocksExt2 {
+    #[inline(always)]
+    fn from(x: Field64_2) -> Self {
+        GoldilocksExt2 {
+            v: [x.c0.into(), x.c1.into()],
+        }
+    }
+}
+
+impl From<&Field64_2> for GoldilocksExt2 {
+    #[inline(always)]
+    fn from(x: &Field64_2) -> Self {
+        GoldilocksExt2 {
+            v: [x.c0.into(), x.c1.into()],
+        }
+    }
+}
+
+impl From<GoldilocksExt2> for Field64_2 {
+    #[inline(always)]
+    fn from(x: GoldilocksExt2) -> Self {
+        Field64_2 {
+            c0: x.v[0].into(),
+            c1: x.v[1].into(),
+        }
+    }
+}
+impl From<&GoldilocksExt2> for Field64_2 {
+    #[inline(always)]
+    fn from(x: &GoldilocksExt2) -> Self {
+        Field64_2 {
+            c0: x.v[0].into(),
+            c1: x.v[1].into(),
+        }
+    }
+}

arith/goldilocks/src/tests.rs

@@ -7,6 +7,7 @@ use ark_std::test_rng;
 use ethnum::U256;
 use rand::thread_rng;
 use serdes::ExpSerde;
+use whir::crypto::fields::{Field64, Field64_2};
 
 use crate::{
     goldilocks::mod_reduce_u64, Goldilocks, GoldilocksExt2, GoldilocksExt2x8, Goldilocksx8,
@@ -239,3 +240,34 @@ fn test_edge_cases() {
     let x = GoldilocksExt2::X;
     assert_eq!(x * x, GoldilocksExt2::from(Goldilocks::from(7u32)));
 }
+
+#[test]
+fn convert_from_and_to_arkworks() {
+    let mut rng = thread_rng();
+
+    let one = Goldilocks::one();
+    let ark_one = Field64::from(1u32);
+
+    assert_eq!(one, Goldilocks::from(ark_one));
+    assert_eq!(Field64::from(one), ark_one);
+
+    for _ in 0..100 {
+        let x = Goldilocks::random_unsafe(&mut rng);
+        let ark_x = Field64::from(x);
+        assert_eq!(x, Goldilocks::from(ark_x));
+        assert_eq!(Field64::from(x), ark_x);
+    }
+
+    let one = GoldilocksExt2::one();
+    let ark_one = Field64_2::from(1u32);
+
+    assert_eq!(one, GoldilocksExt2::from(ark_one));
+    assert_eq!(Field64_2::from(one), ark_one);
+
+    for _ in 0..100 {
+        let x = GoldilocksExt2::random_unsafe(&mut rng);
+        let ark_x = Field64_2::from(x);
+        assert_eq!(x, GoldilocksExt2::from(ark_x));
+        assert_eq!(Field64_2::from(x), ark_x);
+    }
+}

poly_commit/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 arith = { path = "../arith" }
 gf2 = { path = "../arith/gf2" }
 gkr_engine = { path = "../gkr_engine" }
+goldilocks = { path = "../arith/goldilocks" }
 polynomials = { path = "../arith/polynomials"}
 serdes = { path = "../serdes" }
 transcript = { path = "../transcript" }
@@ -21,8 +22,11 @@ halo2curves.workspace = true
 itertools.workspace = true
 rand.workspace = true
 rayon.workspace = true
+spongefish.workspace = true
+spongefish-pow.workspace = true
 transpose.workspace = true
 thiserror.workspace = true
+whir.workspace = true
 
 [dev-dependencies]
 gf2_128 = { path = "../arith/gf2_128" }

poly_commit/benches/hyrax.rs

@@ -64,7 +64,7 @@ fn hyrax_opening_benchmark_helper(
         let (srs, _) = HyraxPCS::<G1Affine>::gen_srs_for_testing(&num_vars, &mut rng);
         let eval_point: Vec<_> = (0..num_vars).map(|_| Fr::random_unsafe(&mut rng)).collect();
 
-        let _ = HyraxPCS::<G1Affine>::commit(&num_vars, &srs, &poly, &mut scratch_pad);
+        let com = HyraxPCS::<G1Affine>::commit(&num_vars, &srs, &poly, &mut scratch_pad);
 
         group
             .bench_function(
@@ -73,10 +73,11 @@ fn hyrax_opening_benchmark_helper(
                     b.iter(|| {
                         _ = black_box(HyraxPCS::<G1Affine>::open(
                             &num_vars,
+                            &com,
                             &srs,
                             &poly,
                             &eval_point,
-                            &scratch_pad,
+                            &mut scratch_pad,
                             &mut transcript,
                         ))
                     })

poly_commit/benches/kzg.rs

@@ -64,7 +64,7 @@ fn hyperkzg_opening_benchmark_helper(
         let (srs, _) = HyperBiKZGPCS::<Bn256>::gen_srs_for_testing(&num_vars, &mut rng);
         let eval_point: Vec<_> = (0..num_vars).map(|_| Fr::random_unsafe(&mut rng)).collect();
 
-        let _ = HyperBiKZGPCS::<Bn256>::commit(&num_vars, &srs, &poly, &mut scratch_pad);
+        let com = HyperBiKZGPCS::<Bn256>::commit(&num_vars, &srs, &poly, &mut scratch_pad);
 
         group
             .bench_function(
@@ -73,10 +73,11 @@ fn hyperkzg_opening_benchmark_helper(
                     b.iter(|| {
                         _ = black_box(HyperBiKZGPCS::<Bn256>::open(
                             &num_vars,
+                            &com,
                             &srs,
                             &poly,
                             &eval_point,
-                            &scratch_pad,
+                            &mut scratch_pad,
                             &mut transcript,
                         ))
                     })