refactor(math): dead-code & structural cleanup of the math crate

crypto/crypto/src/merkle_tree/proof.rs

@@ -1,7 +1,4 @@
 use alloc::{collections::BTreeMap, vec::Vec};
-#[cfg(feature = "alloc")]
-use math::traits::Serializable;
-use math::{errors::DeserializationError, traits::Deserializable};
 
 use super::{
     traits::IsMerkleTreeBackend,
@@ -41,36 +38,6 @@ impl<T: PartialEq + Eq> Proof<T> {
     }
 }
 
-#[cfg(feature = "alloc")]
-impl<T> Serializable for Proof<T>
-where
-    T: Serializable + PartialEq + Eq,
-{
-    fn serialize(&self) -> Vec<u8> {
-        self.merkle_path
-            .iter()
-            .flat_map(|node| node.serialize())
-            .collect()
-    }
-}
-
-impl<T> Deserializable for Proof<T>
-where
-    T: Deserializable + PartialEq + Eq,
-{
-    fn deserialize(bytes: &[u8]) -> Result<Self, DeserializationError>
-    where
-        Self: Sized,
-    {
-        let mut merkle_path = Vec::new();
-        for elem in bytes[0..].chunks(8) {
-            let node = T::deserialize(elem)?;
-            merkle_path.push(node);
-        }
-        Ok(Self { merkle_path })
-    }
-}
-
 /// Stores all the nodes needed to prove the inclusion of multiple leaves.
 ///
 /// # Proof Ordering

crypto/math-cuda/tests/bench_quick.rs

@@ -3,7 +3,7 @@
 
 use std::time::Instant;
 
-use math::fft::cpu::bowers_fft::LayerTwiddles;
+use math::fft::bowers_fft::LayerTwiddles;
 use math::field::element::FieldElement;
 use math::field::goldilocks::GoldilocksField;
 use math::field::traits::IsField;

crypto/math-cuda/tests/lde.rs

@@ -2,7 +2,7 @@
 //! `Polynomial::coset_lde_full_expand` for a sweep of realistic sizes and
 //! blowup factors.
 
-use math::fft::cpu::bowers_fft::LayerTwiddles;
+use math::fft::bowers_fft::LayerTwiddles;
 use math::field::element::FieldElement;
 use math::field::goldilocks::GoldilocksField;
 use math::field::traits::{IsField, IsPrimeField};

crypto/math-cuda/tests/lde_batch.rs

@@ -1,7 +1,7 @@
 //! Batched coset LDE must agree with running the CPU single-column LDE on
 //! each column independently. Sweeps a few realistic (n, blowup, m) tuples.
 
-use math::fft::cpu::bowers_fft::LayerTwiddles;
+use math::fft::bowers_fft::LayerTwiddles;
 use math::field::element::FieldElement;
 use math::field::goldilocks::GoldilocksField;
 use math::field::traits::{IsField, IsPrimeField};

crypto/math-cuda/tests/lde_batch_ext3.rs

@@ -1,7 +1,7 @@
 //! Ext3 batched coset LDE must agree with the CPU `coset_lde_full_expand`
 //! on each column independently when run over `FieldElement<Ext3>`.
 
-use math::fft::cpu::bowers_fft::LayerTwiddles;
+use math::fft::bowers_fft::LayerTwiddles;
 use math::field::element::FieldElement;
 use math::field::extensions_goldilocks::Degree3GoldilocksExtensionField;
 use math::field::goldilocks::GoldilocksField;

crypto/math/src/errors.rs

@@ -2,41 +2,13 @@
 pub enum ByteConversionError {
     FromBEBytesError,
     FromLEBytesError,
-    InvalidValue,
-    PointNotInSubgroup,
-    ValueNotCompressed,
     ValueNotReduced,
 }
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum CreationError {
     InvalidHexString,
-    InvalidDecString,
     HexStringIsTooBig,
     CanonicalOutOfRange,
     EmptyString,
 }
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum DeserializationError {
-    InvalidAmountOfBytes,
-    FieldFromBytesError,
-    PointerSizeError,
-    InvalidValue,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum PairingError {
-    PointNotInSubgroup,
-    DivisionByZero,
-}
-
-impl From<ByteConversionError> for DeserializationError {
-    fn from(error: ByteConversionError) -> Self {
-        match error {
-            ByteConversionError::FromBEBytesError => DeserializationError::FieldFromBytesError,
-            ByteConversionError::FromLEBytesError => DeserializationError::FieldFromBytesError,
-            _ => DeserializationError::InvalidValue,
-        }
-    }
-}

crypto/math/src/fft/bit_reversing.rs

@@ -0,0 +1,18 @@
+/// In-place bit-reverse permutation algorithm. Requires input length to be a power of two.
+pub fn in_place_bit_reverse_permute<E>(input: &mut [E]) {
+    for i in 0..input.len() {
+        let bit_reversed_index = reverse_index(i, input.len() as u64);
+        if bit_reversed_index > i {
+            input.swap(i, bit_reversed_index);
+        }
+    }
+}
+
+/// Reverses the `log2(size)` first bits of `i`
+pub fn reverse_index(i: usize, size: u64) -> usize {
+    if size == 1 {
+        i
+    } else {
+        i.reverse_bits() >> (usize::BITS - size.trailing_zeros())
+    }
+}

crypto/math/src/fft/cpu/bowers_fft.rs → crypto/math/src/fft/bowers_fft.rs

@@ -16,7 +16,7 @@
 //! # Usage
 //!
 //! ```ignore
-//! use math::fft::cpu::bowers_fft::{LayerTwiddles, bowers_fft_opt_fused};
+//! use math::fft::bowers_fft::{LayerTwiddles, bowers_fft_opt_fused};
 //!
 //! let order = 10u64; // FFT size = 2^10 = 1024
 //! let layer_twiddles = LayerTwiddles::<F>::new(order).unwrap();

crypto/math/src/fft/errors.rs

@@ -8,6 +8,8 @@ pub enum FFTError {
     InputError(usize),
     OrderError(u64),
     DomainSizeError(usize),
+    /// A coset offset of zero was supplied; it has no multiplicative inverse.
+    InvalidCosetOffset,
 }
 
 impl Display for FFTError {
@@ -23,6 +25,9 @@ impl Display for FFTError {
             FFTError::DomainSizeError(_) => {
                 write!(f, "Domain size exceeds two adicity of the field")
             }
+            FFTError::InvalidCosetOffset => {
+                write!(f, "Coset offset is zero, which is not invertible")
+            }
         }
     }
 }

crypto/math/src/fft/mod.rs

@@ -1,7 +1,9 @@
-pub mod cpu;
+pub mod bit_reversing;
+#[cfg(feature = "alloc")]
+pub mod bowers_fft;
 pub mod errors;
 #[cfg(feature = "alloc")]
-pub mod polynomial;
+pub mod roots_of_unity;
 
 #[cfg(all(test, feature = "alloc"))]
 pub(crate) mod test_helpers;