style: pr comments

Author: markosg04

jolt-optimizations/src/fq12_poly.rs

@@ -2,8 +2,6 @@
 use ark_bn254::{Fq, Fq12};
 use ark_ff::{Field, One, Zero};
 
-const NINE: u64 = 9;
-
 /// Convert Fq12 to polynomial representation using tower basis mapping
 ///
 /// Maps Fq12 basis elements to powers of w:
@@ -20,7 +18,7 @@ pub fn fq12_to_poly12_coeffs(a: &Fq12) -> [Fq; 12] {
         (1, 2, 5), // a.c1.c2 → w^5
     ];
 
-    let nine = Fq::from(NINE);
+    let nine = Fq::from(9);
     let mut coeffs = [Fq::zero(); 12];
 
     for &(outer, inner, w_power) in &MAPPINGS {
@@ -111,7 +109,6 @@ pub fn eval_multilinear(evals: &[Fq], point: &[Fq]) -> Fq {
 }
 
 /// Compute equality function weights eq(z, x) for all x ∈ {0,1}^4
-/// Helper for testing in arkworks
 pub fn eq_weights(z: &[Fq]) -> Vec<Fq> {
     assert_eq!(z.len(), 4, "Point z must be 4-dimensional");
     let mut w = vec![Fq::zero(); 16];

jolt-optimizations/src/lib.rs

@@ -58,8 +58,8 @@ pub use dory_g2::{
 pub use batch_addition::{batch_g1_additions, batch_g1_additions_multi};
 
 pub use fq12_poly::{
-    eval_multilinear, fq12_to_multilinear_evals, fq12_to_poly12_coeffs, g_coeffs, g_eval,
-    to_multilinear_evals,
+    eq_weights, eval_multilinear, fq12_to_multilinear_evals, fq12_to_poly12_coeffs, g_coeffs,
+    g_eval, to_multilinear_evals,
 };
 
-pub use witness_gen::ExponentiationSteps;
+pub use witness_gen::{get_g_mle, h_tilde_at_point, ExponentiationSteps};

jolt-optimizations/src/witness_gen.rs

@@ -1,6 +1,4 @@
-use crate::fq12_poly::{
-    eq_weights, eval_multilinear, fq12_to_multilinear_evals, g_coeffs, to_multilinear_evals,
-};
+use crate::fq12_poly::{eq_weights, eval_multilinear, fq12_to_multilinear_evals, g_coeffs};
 use ark_bn254::{Fq, Fq12, Fr};
 use ark_ff::{BigInteger, Field, One, PrimeField, Zero};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
@@ -82,15 +80,13 @@ impl ExponentiationSteps {
         }
     }
 
-    /// Verify that the final result matches base^exponent,
-    /// Used for testing
+    /// Verify that the final result matches base^exponent
     pub fn verify_result(&self) -> bool {
         self.result == self.base.pow(self.exponent.into_bigint())
     }
 
     /// Verify constraint at a Boolean cube point
     /// Checks that the constraint holds at cube vertices where it was constructed to be zero
-    /// Used for testing
     pub fn verify_constraint_at_cube_point(&self, step: usize, cube_index: usize) -> bool {
         if step == 0 || step > self.quotient_mles.len() || cube_index >= 16 {
             return false;
@@ -144,23 +140,20 @@ fn compute_step_quotient_msb(rho_prev: Fq12, rho_i: Fq12, base: Fq12, bit: bool)
 }
 
 /// Get g as MLE evaluations over the Boolean cube {0,1}^4
-/// Used for testing
 pub fn get_g_mle() -> Vec<Fq> {
-    // Use the same encoding as fq12_to_multilinear_evals
-    // g(X) = X^12 - 18X^6 + 82 as coefficient array
+    use crate::fq12_poly::eval_poly_vec;
     let g_vec = g_coeffs();
-    let mut g_array = [Fq::zero(); 12];
-    for i in 0..12 {
-        if i < g_vec.len() {
-            g_array[i] = g_vec[i];
-        }
-    }
-    to_multilinear_evals(&g_array)
+
+    (0..16)
+        .map(|i| {
+            let x = Fq::from(i as u64);
+            eval_poly_vec(&g_vec[..], &x)
+        })
+        .collect()
 }
 
 /// Convert a cube index (0..15) to a Boolean point in {0,1}^4
-/// Used for testing
-pub fn index_to_boolean_point(index: usize) -> Vec<Fq> {
+pub(crate) fn index_to_boolean_point(index: usize) -> Vec<Fq> {
     vec![
         Fq::from((index & 1) as u64),        // bit 0
         Fq::from(((index >> 1) & 1) as u64), // bit 1
@@ -171,7 +164,6 @@ pub fn index_to_boolean_point(index: usize) -> Vec<Fq> {
 
 /// Evaluate an MLE at a Boolean cube point
 /// For Boolean points, this is equivalent to indexing but makes the evaluation explicit
-/// Used for testing
 fn eval_mle_at_boolean_point(mle: &[Fq], point: &[Fq]) -> Fq {
     // For Boolean points, we could just index, but using eval_multilinear
     // makes it clear we're doing MLE evaluation
@@ -180,7 +172,6 @@ fn eval_mle_at_boolean_point(mle: &[Fq], point: &[Fq]) -> Fq {
 
 /// H(x) = ρᵢ(x) - ρᵢ₋₁(x)² · A(x)^{bᵢ} - Qᵢ(x) · g(x) for x ∈ {0,1}^4
 /// H̃(z) = Σ_{x∈{0,1}^4} eq(z,x) · H(x)
-/// Used for testing
 pub fn h_tilde_at_point(
     rho_prev_mle: &[Fq],
     rho_curr_mle: &[Fq],

jolt-optimizations/tests/mle_tests.rs

@@ -1,7 +1,10 @@
 use ark_bn254::Fq;
 use ark_ff::{Field, One, UniformRand, Zero};
 use ark_std::test_rng;
-use jolt_optimizations::fq12_poly::{eval_multilinear, eval_poly_vec, to_multilinear_evals};
+use jolt_optimizations::{
+    eval_multilinear,
+    fq12_poly::{eval_poly_vec, to_multilinear_evals},
+};
 
 /// Generate random polynomial coefficients for testing
 fn random_poly12_coeffs() -> [Fq; 12] {

jolt-optimizations/tests/witness_test.rs

@@ -1,10 +1,8 @@
 use ark_bn254::{Fq, Fq12, Fr};
-use ark_ff::{Field, One, UniformRand, Zero};
+use ark_ff::{One, UniformRand, Zero};
 use ark_std::test_rng;
 use jolt_optimizations::{
-    eval_multilinear, fq12_to_multilinear_evals, g_coeffs, to_multilinear_evals,
-    witness_gen::{get_g_mle, h_tilde_at_point},
-    ExponentiationSteps,
+    fq12_to_multilinear_evals, get_g_mle, h_tilde_at_point, ExponentiationSteps,
 };
 
 #[test]
@@ -90,7 +88,7 @@ fn test_trivial_cases() {
 fn test_witness_soundness() {
     let mut rng = test_rng();
 
-    // Test soundness: tampering with witness should be detected
+    // Test soundness: tampering with witness
     for test_idx in 0..20 {
         let base = Fq12::rand(&mut rng);
         let exponent = if test_idx == 0 {
@@ -113,7 +111,7 @@ fn test_witness_soundness() {
         }
         assert!(all_valid, "Original witness should be valid");
 
-        // Test 1: Tampering with ρ values breaks soundness
+        // Test 1: Tampering with ρ values
         if witness.rho_mles.len() > 1 {
             let tamper_idx = 1 + (test_idx % (witness.rho_mles.len() - 1));
             let point_idx = test_idx % 16;
@@ -141,7 +139,7 @@ fn test_witness_soundness() {
             witness.rho_mles[tamper_idx][point_idx] = original;
         }
 
-        // Test 2: Tampering with quotient values breaks soundness
+        // Test 2: Tampering with quotient
         if !witness.quotient_mles.is_empty() {
             let q_idx = test_idx % witness.quotient_mles.len();
             let point_idx = (test_idx * 7) % 16;
@@ -158,7 +156,7 @@ fn test_witness_soundness() {
             witness.quotient_mles[q_idx][point_idx] = original;
         }
 
-        // Test 3: Flipping bits breaks soundness
+        // Test 3: Flipping bits
         if !witness.bits.is_empty() {
             let bit_idx = test_idx % witness.bits.len();
             witness.bits[bit_idx] = !witness.bits[bit_idx];
@@ -175,7 +173,7 @@ fn test_witness_soundness() {
             witness.bits[bit_idx] = !witness.bits[bit_idx];
         }
 
-        // Test 4: Tampering with final result breaks verification
+        // Test 4: Tampering with final result
         let original_result = witness.result;
         witness.result = witness.result + Fq12::one();
         assert!(
@@ -233,8 +231,6 @@ fn test_constraint_at_random_field_element() {
         );
     }
 
-    println!("✓ Verified: H̃(z) = 0 at 20 random field elements (Sumcheck correct)");
-
     for step in 1..=witness.num_steps() {
         for cube_idx in 0..16 {
             assert!(