Merge branch 'main' into opt/11-parallel-fri-fold

Author: MauroToscano

Cargo.lock

@@ -7,7 +7,6 @@ edition = "2024"
 executor = { path = "../../executor" }
 prover = { path = "../../prover", package = "lambda-vm-prover" }
 stark = { path = "../../crypto/stark" }
-crypto = { path = "../../crypto/crypto" }
 clap = { version = "4.3.10", features = ["derive"] }
 bincode = "1"
 tikv-jemallocator = "0.6"

bin/cli/Cargo.toml

@@ -10,7 +10,6 @@ edition = "2024"
 math = { path = "../math", features = ["alloc"] }
 digest = "0.10.7"
 sha3 = { version = "0.10.8", default-features = false }
-sha2 = { version = "0.10", default-features = false }
 # Optional
 serde = { version = "1.0", default-features = false, features = [
     "derive",
@@ -21,15 +20,15 @@ rand = { version = "0.8.5", default-features = false }
 rand_chacha = { version = "0.3.1", default-features = false }
 
 [dev-dependencies]
-criterion = "0.4"
-iai-callgrind = "0.3.1"
+math = { path = "../math", features = ["test-utils"] }
 rand = "0.8.5"
 rand_chacha = "0.3.1"
+sha2 = { version = "0.10", default-features = false }
 
 [features]
 default = ["asm", "std"]
 asm = ["sha3/asm"]
-std = ["math/std", "sha2/std", "sha3/std", "serde?/std"]
+std = ["math/std", "sha3/std", "serde?/std"]
 serde = ["dep:serde"]
 parallel = ["dep:rayon"]
 alloc = []

crypto/crypto/Cargo.toml

@@ -8,4 +8,4 @@ This folder contains hash functions that are typically used in non-interactive p
 
 Pedersen is based on elliptic curves, while [Monolith](https://eprint.iacr.org/2023/1025), [Poseidon](https://eprint.iacr.org/2019/458.pdf) and [Rescue Prime](https://eprint.iacr.org/2020/1143) are algebraic hash functions.
 
-For an introduction to hash functions, see [this intro](https://blog.alignedlayer.com/introduction-hash-functions-in-cryptography/) and [its follow-up](https://blog.alignedlayer.com/design-strategies-how-to-construct-a-hashing-mode-2/).
+For an introduction to hash functions, see [this intro](https://blog.alignedlayer.com/introduction-hash-functions-in-cryptography/) and [its follow-up](https://blog.alignedlayer.com/design-strategies-how-to-construct-a-hashing-mode-2/).

crypto/crypto/src/errors.rs

@@ -3,8 +3,6 @@
 #[macro_use]
 extern crate alloc;
 
-#[cfg(feature = "std")]
-pub mod errors;
 pub mod fiat_shamir;
 pub mod hash;
 pub mod merkle_tree;

crypto/crypto/src/hash/README.md

@@ -1,5 +1,4 @@
 use crate::hash::poseidon::Poseidon;
-
 use crate::merkle_tree::traits::IsMerkleTreeBackend;
 use core::marker::PhantomData;
 use digest::{Digest, Output};

crypto/crypto/src/lib.rs

@@ -1,38 +1,15 @@
-use sha2::{Sha256, Sha512};
-use sha3::{Keccak256, Keccak512, Sha3_256, Sha3_512};
+use sha3::Keccak256;
 
 use super::{
     field_element::FieldElementBackend,
     field_element_vector::{FieldElementPairBackend, FieldElementVectorBackend},
 };
 
 // Field element backend definitions
-
-// - With 256 bit
-pub type Sha3_256Backend<F> = FieldElementBackend<F, Sha3_256, 32>;
 pub type Keccak256Backend<F> = FieldElementBackend<F, Keccak256, 32>;
-pub type Sha2_256Backend<F> = FieldElementBackend<F, Sha256, 32>;
-
-// - With 512 bit
-pub type Sha3_512Backend<F> = FieldElementBackend<F, Sha3_512, 64>;
-pub type Keccak512Backend<F> = FieldElementBackend<F, Keccak512, 64>;
-pub type Sha2_512Backend<F> = FieldElementBackend<F, Sha512, 64>;
 
 // Vector of field elements backend definitions
-
-// - With 256 bit
-pub type BatchSha3_256Backend<F> = FieldElementVectorBackend<F, Sha3_256, 32>;
 pub type BatchKeccak256Backend<F> = FieldElementVectorBackend<F, Keccak256, 32>;
-pub type BatchSha2_256Backend<F> = FieldElementVectorBackend<F, Sha256, 32>;
-
-// - With 512 bit
-pub type BatchSha3_512Backend<F> = FieldElementVectorBackend<F, Sha3_512, 64>;
-pub type BatchKeccak512Backend<F> = FieldElementVectorBackend<F, Keccak512, 64>;
-pub type BatchSha2_512Backend<F> = FieldElementVectorBackend<F, Sha512, 64>;
 
 // Fixed-size pair backends (more efficient for FRI layers)
-
-// - With 256 bit
 pub type PairKeccak256Backend<F> = FieldElementPairBackend<F, Keccak256, 32>;
-pub type PairSha3_256Backend<F> = FieldElementPairBackend<F, Sha3_256, 32>;
-pub type PairSha2_256Backend<F> = FieldElementPairBackend<F, Sha256, 32>;

crypto/crypto/src/merkle_tree/backends/field_element.rs

@@ -25,10 +25,7 @@ num-traits = { version = "0.2.19", default-features = false }
 [dev-dependencies]
 rand_chacha = "0.3.1"
 criterion = "0.5.1"
-const-random = "0.1.15"
-iai-callgrind = "0.3.1"
 proptest = "1.1.0"
-pprof = { version = "0.13.0", features = ["criterion", "flamegraph"] }
 rand = { version = "0.8.5", features = ["std"] }
 
 [features]
@@ -40,6 +37,7 @@ lambdaworks-serde-binary = ["dep:serde", "alloc"]
 lambdaworks-serde-string = ["dep:serde", "dep:serde_json", "alloc"]
 proptest = ["dep:proptest"]
 instruments = []
+test-utils = []
 
 [target.wasm32-unknown-unknown.dependencies]
 getrandom = { version = "0.2.15", features = ["js"] }

crypto/crypto/src/merkle_tree/backends/types.rs

@@ -28,8 +28,6 @@
 //!
 //! Based on Plonky3's implementation and academic literature on FFT optimization.
 
-#[cfg(feature = "alloc")]
-use crate::fft::cpu::bit_reversing::in_place_bit_reverse_permute;
 #[cfg(feature = "alloc")]
 use crate::fft::errors::FFTError;
 #[cfg(feature = "alloc")]
@@ -53,98 +51,6 @@ const MAX_FFT_ORDER: u64 = 31;
 // STRUCTURE OF ARRAYS (SoA) FFT
 // =====================================================
 
-/// Matrix representation for batch FFT with Structure of Arrays layout
-///
-/// SoA layout stores multiple polynomials contiguously:
-/// ```text
-/// [poly0[0], poly0[1], ..., poly0[n-1], poly1[0], poly1[1], ..., poly1[n-1], ...]
-/// ```
-///
-/// This layout provides better cache utilization when processing multiple
-/// polynomials simultaneously.
-#[cfg(feature = "alloc")]
-pub struct FftMatrix<E: IsField> {
-    /// Flat storage for all polynomial coefficients
-    pub data: Vec<FieldElement<E>>,
-    /// Number of columns (polynomial length)
-    pub width: usize,
-    /// Number of rows (number of polynomials)
-    pub height: usize,
-}
-
-#[cfg(feature = "alloc")]
-impl<E: IsField> FftMatrix<E> {
-    /// Create a new FFT matrix from a list of polynomials
-    ///
-    /// # Panics
-    /// Panics if polynomials have different lengths.
-    pub fn from_polynomials(polys: Vec<Vec<FieldElement<E>>>) -> Self {
-        if polys.is_empty() {
-            return Self {
-                data: Vec::new(),
-                width: 0,
-                height: 0,
-            };
-        }
-
-        let height = polys.len();
-        let width = polys[0].len();
-
-        // Flatten in row-major order (SoA layout)
-        let mut data = Vec::with_capacity(height * width);
-        for poly in polys {
-            assert_eq!(poly.len(), width, "All polynomials must have same length");
-            data.extend(poly);
-        }
-
-        Self {
-            data,
-            width,
-            height,
-        }
-    }
-
-    /// Get a mutable slice for polynomial at index `row`
-    ///
-    /// # Panics
-    /// Panics if `row >= self.height`.
-    pub fn row_mut(&mut self, row: usize) -> &mut [FieldElement<E>] {
-        assert!(
-            row < self.height,
-            "Row index out of bounds: {} >= {}",
-            row,
-            self.height
-        );
-        let start = row.checked_mul(self.width).expect("Row index overflow");
-        let end = start + self.width;
-        &mut self.data[start..end]
-    }
-
-    /// Get an immutable slice for polynomial at index `row`
-    ///
-    /// # Panics
-    /// Panics if `row >= self.height`.
-    pub fn row(&self, row: usize) -> &[FieldElement<E>] {
-        assert!(
-            row < self.height,
-            "Row index out of bounds: {} >= {}",
-            row,
-            self.height
-        );
-        let start = row.checked_mul(self.width).expect("Row index overflow");
-        let end = start + self.width;
-        &self.data[start..end]
-    }
-
-    /// Convert back to list of polynomials
-    pub fn to_polynomials(self) -> Vec<Vec<FieldElement<E>>> {
-        self.data
-            .chunks(self.width)
-            .map(|chunk| chunk.to_vec())
-            .collect()
-    }
-}
-
 // =====================================================
 // PARALLEL BOWERS FFT
 // =====================================================
@@ -1185,29 +1091,3 @@ where
 
     Ok(())
 }
-
-/// Batch FFT using optimized Bowers algorithm with LayerTwiddles
-///
-/// # Errors
-/// Returns `FFTError::InputError` if polynomial width is not a power of two.
-#[cfg(feature = "alloc")]
-pub fn bowers_batch_fft_opt<F, E>(
-    matrix: &mut FftMatrix<E>,
-    layer_twiddles: &LayerTwiddles<F>,
-) -> Result<(), FFTError>
-where
-    F: IsFFTField + IsSubFieldOf<E>,
-    E: IsField,
-{
-    if matrix.height == 0 || matrix.width <= 1 {
-        return Ok(());
-    }
-
-    for row in 0..matrix.height {
-        let poly = matrix.row_mut(row);
-        bowers_fft_opt_fused(poly, layer_twiddles)?;
-        in_place_bit_reverse_permute(poly);
-    }
-
-    Ok(())
-}