removing one more iter_mut in the denominators

ipa-core/Cargo.toml

@@ -149,7 +149,7 @@ tower = { version = "0.4.13", optional = true }
 tower-http = { version = "0.4.0", optional = true, features = ["trace"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-typenum = "1.16"
+typenum = { version = "1.17", features = ["i128"] }
 # hpke is pinned to it
 x25519-dalek = "2.0.0-rc.3"
 

ipa-core/src/protocol/ipa_prf/malicious_security/lagrange.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use generic_array::{sequence::GenericSequence, ArrayLength, GenericArray};
+use generic_array::{ArrayLength, GenericArray};
 use typenum::{Unsigned, U1};
 
 use crate::ff::{Field, PrimeField, Serializable};
@@ -35,23 +35,26 @@
         // assertion that field is large enough
         // when it is large enough, `F::try_from().unwrap()` below does not panic
         assert!(
-            F::BITS > usize::BITS - N::USIZE.leading_zeros(),
+            N::U128 < F::PRIME.into(),
             "Field size {} is not large enough to hold {} points",
-            F::BITS,
-            N::USIZE
+            F::PRIME.into(),
+            N::U128
         );
 
         // assertion that table is not too large for the stack
         assert!(<F as Serializable>::Size::USIZE * N::USIZE < 2024);
 
-        let mut denominator = GenericArray::generate(|_| F::ONE);
-        for (d, i) in denominator.iter_mut().zip(0u64..) {
-            for j in (0..N::U64).filter(|&j| i != j) {
-                *d *= F::try_from(u128::from(i)).unwrap() - F::try_from(u128::from(j)).unwrap();
-            }
-            *d = d.invert();
+        Self {
+            denominator: (0..N::U128)
+                .map(|i| {
+                    (0..N::U128)
+                        .filter(|&j| i != j)
+                        .map(|j| F::try_from(i).unwrap() - F::try_from(j).unwrap())
+                        .fold(F::ONE, |acc, a| acc * a)
+                        .invert()
+                })
+                .collect(),
         }
-        Self { denominator }
     }
 }
 
@@ -79,12 +82,11 @@
 {
     /// generates a `CanonicalLagrangeTable` from `CanoncialLagrangeDenominators` for a single output point
     /// The "x coordinate" of the output point is `x_output`.
-    pub fn new(denominator: CanonicalLagrangeDenominator<F, N>, x_output: &F) -> Self {
+    pub fn new(denominator: &CanonicalLagrangeDenominator<F, N>, x_output: &F) -> Self {
         // assertion that table is not too large for the stack
         assert!(<F as Serializable>::Size::USIZE * N::USIZE < 2024);
 
-        let mut table = denominator.denominator;
-        Self::compute_table_row(x_output, &mut table);
+        let table = Self::compute_table_row(x_output, denominator);
         LagrangeTable::<F, N, U1> {
             table: GenericArray::from_array([table; 1]),
         }
@@ -115,46 +117,52 @@
     ///
     /// ## Panics
     /// When the field size is too small for `N` evaluation points
-    fn compute_table_row(x_output: &F, table_row: &mut GenericArray<F, N>)
+    fn compute_table_row(
+        x_output: &F,
+        denominator: &CanonicalLagrangeDenominator<F, N>,
+    ) -> GenericArray<F, N>
     where
         F: Field + TryFrom<u128>,
         <F as TryFrom<u128>>::Error: Debug,
         N: ArrayLength,
     {
-        for (entry, i) in table_row.iter_mut().zip(0u64..) {
-            for j in (0..N::U64).filter(|&j| j != i) {
-                *entry *= *x_output - F::try_from(u128::from(j)).unwrap();
-            }
-        }
+        (0..N::U128)
+            .map(|i| {
+                (0..N::U128)
+                    .filter(|&j| j != i)
+                    .fold(F::ONE, |acc, j| acc * (*x_output - F::try_from(j).unwrap()))
+            })
+            .zip(&denominator.denominator)
+            .map(|(numerator, denominator)| *denominator * numerator)
+            .collect()
     }
 }
 
 impl<F, N, M> From<CanonicalLagrangeDenominator<F, N>> for LagrangeTable<F, N, M>
 where
-    F: Field + TryFrom<u128>,
-    <F as TryFrom<u128>>::Error: Debug,
+    F: PrimeField,
     N: ArrayLength,
     M: ArrayLength,
 {
     fn from(value: CanonicalLagrangeDenominator<F, N>) -> Self {
         // assertion that field is large enough
         // when it is large enough, `F::try_from().unwrap()` below does not panic
         assert!(
-            F::BITS > usize::BITS - (N::USIZE + M::USIZE).leading_zeros(),
+            N::U128 + M::U128 < F::PRIME.into(),
             "Field size {} is not large enough to hold {} + {} points",
-            F::BITS,
-            N::USIZE,
-            M::USIZE
+            F::PRIME.into(),
+            N::U128,
+            M::U128
         );
 
         // assertion that table is not too large for the stack
         assert!(<F as Serializable>::Size::USIZE * N::USIZE * M::USIZE < 2024);
 
-        let mut table = GenericArray::generate(|_| value.denominator.clone());
-        table.iter_mut().zip(0u64..).for_each(|(row, i)| {
-            Self::compute_table_row(&F::try_from(u128::from(i + N::U64)).unwrap(), row);
-        });
-        LagrangeTable { table }
+        LagrangeTable {
+            table: (N::U128..(N::U128 + M::U128))
+                .map(|i| Self::compute_table_row(&F::try_from(i).unwrap(), &value))
+                .collect(),
+        }
     }
 }
 
@@ -236,7 +244,7 @@
         let polynomial = Polynomial::from(polynomial_monomial_form.clone());
         let denominator = CanonicalLagrangeDenominator::<TestField, U32>::new();
         // generate table using new
-        let lagrange_table = LagrangeTable::<TestField, U32, U1>::new(denominator, &output_point);
+        let lagrange_table = LagrangeTable::<TestField, U32, U1>::new(&denominator, &output_point);
         let output = lagrange_table.eval(&polynomial);
         assert_eq!(output, output_expected);
     }