Fix linting errors

Author: ThomasdenH

src/keys.rs

@@ -73,7 +73,7 @@ impl<F: Field> PublicKey<F> for RadicalPublicKey<F> {
     type CheckingRandomness = ();
     const CHECKING_RANDOMNESS_SIZE: usize = 0;
     fn challenge_randomness(
-        verifier_state: &mut VerifierState,
+        _verifier_state: &mut VerifierState,
     ) -> Result<Self::CheckingRandomness, ProofError> {
         Ok(())
     }
@@ -100,9 +100,9 @@ impl<F: Field> PublicKey<F> for RadicalPublicKey<F> {
     }
     fn direct_evaluate_constraints(
         &self,
-        x: F,
-        randomness: &Self::CheckingRandomness,
-        openings: &[<Self::Checker as Checker<F>>::Openings; 2],
+        _x: F,
+        _randomness: &Self::CheckingRandomness,
+        _openings: &[<Self::Checker as Checker<F>>::Openings; 2],
     ) -> F {
         F::ZERO
     }
@@ -344,35 +344,36 @@ pub fn expand_keys<const PATH_LENGTH_DIV_64: usize, F: Field>(
     )
 }
 
+#[inline]
 pub fn starting_curve<F: Field>() -> (F, F) {
     (F::from(0), F::from(251948161))
 }
 
+#[inline]
 pub fn starting_j_invariant<F: Field>() -> F {
     let (a_start, c_start) = starting_curve();
     compute_j_invariant(a_start, c_start)
 }
 
+#[inline]
 pub fn build_path<F: Field>(key: &[OneOrMinusOne]) -> (Vec<F>, Vec<F>) {
     let mut a: Vec<F> = Vec::with_capacity(key.len());
     let mut c: Vec<F> = Vec::with_capacity(key.len());
     let (a_start, c_start) = starting_curve();
     a.push(a_start);
     c.push(c_start);
 
-    let mut a_curr = a[0];
-    let mut c_curr = c[0];
+    let mut a_curr = a_start;
+    let mut c_curr = c_start;
     for k in key.iter() {
         let c_sqrt = k.into_field::<F>()
             * (c_curr
                 .sqrt()
                 .expect("could not follow path - C_i is not a square residue"));
-        let a_next = F::from(6) * c_sqrt + a_curr;
-        let c_next = F::from(4) * c_sqrt * a_curr + F::from(8) * c_curr;
-        a.push(a_next);
-        c.push(c_next);
-        a_curr = a_next;
-        c_curr = c_next;
+        c_curr = (c_curr + c_curr + c_sqrt * a_curr) * F::from(4);
+        a_curr = a_curr + F::from(6) * c_sqrt;
+        a.push(a_curr);
+        c.push(c_curr);
     }
 
     (a, c)

src/polynomials/piop_polynomials.rs

@@ -56,7 +56,6 @@ pub trait Checker<F: Field> {
 #[derive(Default)]
 pub struct ACChecker<F: Field> {
     _a: PhantomData<F>,
-    variables: usize
 }
 impl<F: Field> Checker<F> for ACChecker<F> {
     const OPENING_LEN: usize = 0;

src/polynomials/piop_polynomials/j_invariant_checking.rs

@@ -106,12 +106,15 @@ impl<F: Field> JInvariantChecker<F> {
 
     pub fn eval_then_sum_hypercube(&self, val: F) -> F {
         assert!(self.num_variables > 0);
-        if !self.has_first_variable_been_fixed() {
-            self.eval_at_x(val) * F::from(2u32.pow((self.num_variables - 1) as u32))
-        } else if self.num_variables == 1 {
+        if self.num_variables == 1 {
             self.value()
         } else {
-            self.value() * F::from(2u32.pow((self.num_variables - 1) as u32))
+            let factor = F::from(2u32.pow((self.num_variables - 1) as u32));
+            if !self.has_first_variable_been_fixed() {
+                factor * self.eval_at_x(val)
+            } else {
+                factor * self.value()
+            }
         }
     }
 
@@ -171,9 +174,8 @@ impl<F: Field> JInvariantChecker<F> {
         let mut val = d5 * (F::from(4) * c - d1) - F::ONE;
         val = val * h + c * d4 - F::ONE;
         val = val * h + j * d2 * (F::from(4) * c - d1)
-            - F::from(256)
-                * (-d1 * d3 + F::from(3 * 3) * c * d3 - F::from(9 * 3) * d2 * d1
-                    + F::from(27) * d2 * c);
+            + F::from(-256)
+                * (d3 * (F::from(9) * c - d1) + F::from(27) * d2 * (d1 - c));
         val = val * h + d3 - d1.pow([2]);
         val = val * h + d2 - c.pow([2]);
         val = val * h + d1 - a.pow([2]);

src/src.rs

@@ -1,7 +1,7 @@
 use std::error::Error;
 
 use polynomial_proving::{
-    run_for_params, JInvariantPublicKeyConfig, MaskCheckMode, PublicKey, RadicalPublicKey,
+    run_for_params, JInvariantPublicKeyConfig, MaskCheckMode,
     RadicalPublicKeyConfig, RunForParamsConfig, RunForParamsPublicKey,
 };
 use util::algebra::field::{p434, p503, p610, p751, sqisign};

tests/prove_and_verify.rs

@@ -1,6 +1,6 @@
 use std::error::Error;
 
-use polynomial_proving::{RadicalPublicKey, RadicalPublicKeyConfig, RunForParamsConfig, run_for_params};
+use polynomial_proving::{RadicalPublicKeyConfig, RunForParamsConfig, run_for_params};
 use util::algebra::field::{arkfield::Fp2256, p434};
 
 #[test]