Rename max_log_size to lifting_log_size.

Author: leo-starkware

crates/stwo/src/core/pcs/utils.rs

@@ -177,20 +177,20 @@ impl<T> TreeVec<ColumnVec<Vec<T>>> {
 
 pub fn prepare_preprocessed_query_positions(
     query_positions: &[usize],
-    max_log_size: u32,
+    lifting_log_size: u32,
     pp_max_log_size: u32,
 ) -> Vec<usize> {
     if pp_max_log_size == 0 {
         return vec![];
     };
-    if max_log_size < pp_max_log_size {
+    if lifting_log_size < pp_max_log_size {
         return query_positions
             .iter()
-            .map(|pos| (pos >> 1 << (pp_max_log_size - max_log_size + 1)) + (pos & 1))
+            .map(|pos| (pos >> 1 << (pp_max_log_size - lifting_log_size + 1)) + (pos & 1))
             .collect();
     }
     query_positions
         .iter()
-        .map(|pos| (pos >> (max_log_size - pp_max_log_size + 1) << 1) + (pos & 1))
+        .map(|pos| (pos >> (lifting_log_size - pp_max_log_size + 1) << 1) + (pos & 1))
         .collect()
 }

crates/stwo/src/prover/backend/cpu/quotients.rs

@@ -49,26 +49,26 @@ impl QuotientOps for CpuBackend {
     fn compute_quotients_and_combine(
         accumulations: Vec<AccumulatedNumerators<Self>>,
     ) -> SecureEvaluation<Self, BitReversedOrder> {
-        let max_log_size = accumulations
+        let lifting_log_size = accumulations
             .iter()
             .map(|x| x.partial_numerators_acc.len())
             .max()
             .unwrap()
             .ilog2();
 
-        let domain = CanonicCoset::new(max_log_size).circle_domain();
+        let domain = CanonicCoset::new(lifting_log_size).circle_domain();
         let mut quotients: SecureColumnByCoords<CpuBackend> =
-            unsafe { SecureColumnByCoords::uninitialized(1 << max_log_size) };
+            unsafe { SecureColumnByCoords::uninitialized(1 << lifting_log_size) };
         let sample_points: Vec<CirclePoint<SecureField>> =
             accumulations.iter().map(|x| x.sample_point).collect();
         // Populate `quotients`.
         for row in 0..quotients.len() {
-            let domain_point = domain.at(bit_reverse_index(row, max_log_size));
+            let domain_point = domain.at(bit_reverse_index(row, lifting_log_size));
             let inverses = denominator_inverses(&sample_points, domain_point);
             let mut quotient = SecureField::zero();
             for (acc, den_inv) in accumulations.iter().zip_eq(inverses) {
                 let mut full_numerator = SecureField::zero();
-                let log_ratio = max_log_size - acc.partial_numerators_acc.len().ilog2();
+                let log_ratio = lifting_log_size - acc.partial_numerators_acc.len().ilog2();
                 let lifted_idx = (row >> (log_ratio + 1) << 1) + (row & 1);
 
                 full_numerator += acc.partial_numerators_acc.at(lifted_idx)

crates/stwo/src/prover/backend/simd/quotients.rs

@@ -74,18 +74,18 @@ impl QuotientOps for SimdBackend {
     fn compute_quotients_and_combine(
         accumulations: Vec<AccumulatedNumerators<Self>>,
     ) -> SecureEvaluation<Self, BitReversedOrder> {
-        let max_log_size = accumulations
+        let lifting_log_size = accumulations
             .iter()
             .map(|x| x.partial_numerators_acc.len())
             .max()
             .unwrap()
             .ilog2();
 
-        let domain = CanonicCoset::new(max_log_size).circle_domain();
+        let domain = CanonicCoset::new(lifting_log_size).circle_domain();
         let domain_points: Vec<CirclePoint<PackedBaseField>> =
             CircleDomainBitRevIterator::new(domain).collect();
         let mut quotients: SecureColumnByCoords<SimdBackend> =
-            unsafe { SecureColumnByCoords::uninitialized(1 << max_log_size) };
+            unsafe { SecureColumnByCoords::uninitialized(1 << lifting_log_size) };
         let sample_points: Vec<CirclePoint<SecureField>> =
             accumulations.iter().map(|x| x.sample_point).collect();
         let denominators_inverses = denominator_inverses(&sample_points, domain);
@@ -103,7 +103,7 @@ impl QuotientOps for SimdBackend {
             for (acc, den_inv) in accumulations.iter().zip_eq(denominators_inverses.iter()) {
                 let mut full_numerator = PackedSecureField::zero();
 
-                let log_ratio = max_log_size - acc.partial_numerators_acc.len().ilog2();
+                let log_ratio = lifting_log_size - acc.partial_numerators_acc.len().ilog2();
                 let lifted_partial_numerator =
                     PackedSecureField::from_packed_m31s(std::array::from_fn(|j| {
                         let lifted_simd = to_lifted_simd(

crates/stwo/src/prover/pcs/mod.rs

@@ -101,7 +101,7 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
     pub fn build_weights_hash_map(
         &self,
         sampled_points: &TreeVec<ColumnVec<Vec<CirclePoint<SecureField>>>>,
-        max_log_size: u32,
+        lifting_log_size: u32,
     ) -> WeightsHashMap<B>
     where
         Col<B, SecureField>: Send + Sync,
@@ -123,17 +123,17 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
                 let log_size = poly.evals.domain.log_size();
                 // For each sample point, compute the weights needed to evaluate the polynomial at
                 // the folded sample point.
-                // TODO(Leo): the computation `point.repeated_double(max_log_size - log_size)` is
-                // likely repeated a bunch of times in a typical flat air. Consider moving it
-                // outside the loop.
+                // TODO(Leo): the computation `point.repeated_double(lifting_log_size - log_size)`
+                // is likely repeated a bunch of times in a typical flat air.
+                // Consider moving it outside the loop.
                 #[cfg(not(feature = "parallel"))]
                 points.iter().for_each(|&point| {
-                    compute_weights((log_size, point.repeated_double(max_log_size - log_size)))
+                    compute_weights((log_size, point.repeated_double(lifting_log_size - log_size)))
                 });
 
                 #[cfg(feature = "parallel")]
                 points.par_iter().for_each(|&point| {
-                    compute_weights((log_size, point.repeated_double(max_log_size - log_size)))
+                    compute_weights((log_size, point.repeated_double(lifting_log_size - log_size)))
                 });
             });
 
@@ -153,11 +153,11 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
         )
         .entered();
 
-        let max_log_size = self.trees.last().unwrap().commitment.layers.len() as u32 - 1;
+        let lifting_log_size = self.trees.last().unwrap().commitment.layers.len() as u32 - 1;
         let weights_hash_map = if self.store_polynomials_coefficients {
             None
         } else {
-            Some(self.build_weights_hash_map(&sampled_points, max_log_size))
+            Some(self.build_weights_hash_map(&sampled_points, lifting_log_size))
         };
         let samples: TreeVec<Vec<Vec<PointSample>>> = self
             .polynomials()
@@ -168,7 +168,7 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
                     .map(|&point| PointSample {
                         point,
                         value: poly.eval_at_point(
-                            point.repeated_double(max_log_size - poly.evals.domain.log_size()),
+                            point.repeated_double(lifting_log_size - poly.evals.domain.log_size()),
                             weights_hash_map.as_ref(),
                         ),
                     })
@@ -209,7 +209,7 @@ impl<'a, B: BackendForChannel<MC>, MC: MerkleChannel> CommitmentSchemeProver<'a,
         // Build the query position tree.
         let preprocessed_query_positions = prepare_preprocessed_query_positions(
             &query_positions,
-            max_log_size,
+            lifting_log_size,
             self.trees[0].commitment.layers.len() as u32 - 1,
         );
         let query_positions_tree = TreeVec::new(