Resolve Clippy findings (#45)

* Applied the Clippy-suggested idioms across the utils crate so the reported lints now build cleanly.

- `crates/utils/src/misc.rs:33` switched the even-length assertions in the left/right slice helpers to `.is_multiple_of(2)` so Clippy stops flagging the manual modulus checks.
- `crates/utils/src/univariate.rs:9` introduced `CacheValue`/`SelectorsCache` type aliases and reused them in the `SELECTORS_CACHE` static to tame the complex type signature.
- `crates/utils/src/multilinear.rs:24` replaced the raw `transmute` with a typed pointer cast, and in `:186` rewrote the recursion branch to drop needless returns while using `point.is_empty()`. Tests at `:280` and `:298` now iterate directly over mutable coefficients, removing the range-index loops.
- `crates/utils/src/display.rs:8` now relies on `.is_multiple_of(3)` for clarity in the thousands separator logic.

Checks: `cargo fmt`

`cargo clippy --workspace --all-targets -- -Dwarnings` now continues past `crates/utils`, but fails later with pre-existing lints in `crates/packed_pcs` and `crates/sumcheck` (multiple bound locations, unused type parameter, `map`+`flatten`, needless borrows, function argument count). Those remain to be addressed separately.

Next steps:
1. Tackle the newly surfaced Clippy findings in `crates/packed_pcs` and `crates/sumcheck`, or relax the lint levels for those items if appropriate.

* - Updated `compute_chunks` and `num_packed_vars_for_dims` to drop the redundant `EF` parameter and return constraints, and reworked `packed_pcs_commit`’s generics so all trait bounds live in the `where` clause (`crates/packed_pcs/src/lib.rs:149`, `:181`, `:196`).
- Replaced the `map(...).flatten()` pattern with `flat_map`, avoided needless reborrows when looking up chunks, and compared boolean prefixes directly rather than taking extra references (`crates/packed_pcs/src/lib.rs:299`, `:310`, `:352`, `:500`).
- Adjusted verifier-side lookups to use the new chunk access pattern and the simplified comparisons (`crates/packed_pcs/src/lib.rs:465`, `:487`, `:500`).
- Updated the two call sites that still referenced the old `num_packed_vars_for_dims::<EF, EF>` signature (`crates/lean_prover/src/prove_execution.rs:992`, `crates/lean_prover/src/verify_execution.rs:548`).

Checks: `cargo fmt`. `cargo clippy --workspace --all-targets -- -Dwarnings` still stops at the existing `sumcheck` lints (too many arguments); no new warnings from `packed_pcs`.

Next steps:
1. Resolve the `clippy::too_many_arguments` reports in `crates/sumcheck/src/mle.rs` or suppress them if that’s intentional.

* - Introduced the `Poseidon2Config` workflow and split the prover/verifier logic into reusable helpers, which shrank the main entry point and dropped the lossless cast in `src/examples/prove_poseidon2.rs:18-275`; updated the CLI entrypoint to build that config once and pass it by reference (`src/main.rs:5-19`).
- Cleaned up the PCS stack: `compute_chunks`/`num_packed_vars_for_dims` now avoid redundant generics, the commit/global-statement helpers use iterators instead of `map(...).flatten()`, and dictionary lookups no longer take needless borrows (`crates/packed_pcs/src/lib.rs:149-332`).
- Refactored sumcheck execution to accept parameter structs instead of long argument lists and reused those structs for both packed and unpacked flows (`crates/sumcheck/src/mle.rs:309-517`, `crates/sumcheck/src/prove.rs:149-186`).
- Converted numerous range-index loops to iterator-based updates (e.g. `crates/lean_vm/src/memory.rs:32-38`, `crates/lean_prover/witness_generation/src/execution_trace.rs:270-276`, `crates/lean_prover/src/prove_execution.rs:802-824`, `crates/lean_prover/src/verify_execution.rs:862-872`) and collapsed deep `if let` chains in the AIR/Lean compiler stack (`crates/air/src/prove.rs:118-182`, `crates/air/src/verify.rs:187-281`, `crates/lean_compiler/src/a_simplify_lang.rs:681-707`, `crates/lean_compiler/src/b_compile_intermediate.rs:50-79`, `crates/lean_compiler/src/c_compile_final.rs:152-175`).
- Simplified and renamed helpers across the Lean prover pipeline: `get_base_dims` now groups its inputs into tuples (`crates/lean_prover/src/common.rs:16-39`); the runner uses a params struct instead of nine loose arguments and avoids redundant pointer casts (`crates/lean_vm/src/runner.rs:149-285`); bitfield generation no longer performs a modulo-by-one (`crates/rec_aggregation/src/xmss_aggregate.rs:215-231`); miscellaneous utilities use the standard `.is_multiple_of()` idiom (`crates/utils/src/misc.rs:32-53`, `crates/utils/src/display.rs:7-11`) and clarified cache aliases in `crates/utils/src/univariate.rs:9-13`.

Clippy: `cargo clippy --workspace --all-targets -- -Dwarnings`

* - Reworked the row-filling loops in `crates/air/src/test.rs:101-152` to eliminate range indexing: both structured and unstructured trace generators now walk column iterators row-by-row, keeping per-column state where needed and breaking cleanly when the iterators exhaust. This removes the needless index loop flagged by Clippy.

Tests: `cargo clippy -p air --tests -- -Dwarnings`

Author: adust09

crates/air/src/prove.rs

@@ -122,7 +122,7 @@ impl<EF: ExtensionField<PF<EF>>, A: NormalAir<EF>, AP: PackedAir<EF>> AirTable<E
         univariate_skips: usize,
         witness: AirWitness<'a, PF<EF>>,
     ) -> Vec<Evaluation<EF>> {
-        prove_air::<PF<EF>, EF, A, AP>(prover_state, univariate_skips, &self, witness)
+        prove_air::<PF<EF>, EF, A, AP>(prover_state, univariate_skips, self, witness)
     }
 
     #[instrument(name = "air: prove in extension", skip_all)]
@@ -132,7 +132,7 @@ impl<EF: ExtensionField<PF<EF>>, A: NormalAir<EF>, AP: PackedAir<EF>> AirTable<E
         univariate_skips: usize,
         witness: AirWitness<'a, EF>,
     ) -> Vec<Evaluation<EF>> {
-        prove_air::<EF, EF, A, AP>(prover_state, univariate_skips, &self, witness)
+        prove_air::<EF, EF, A, AP>(prover_state, univariate_skips, self, witness)
     }
 }
 
@@ -224,9 +224,13 @@ fn open_structured_columns<'a, EF: ExtensionField<PF<EF>> + ExtensionField<IF>,
     let mut column_scalars = vec![];
     let mut index = 0;
     for group in &witness.column_groups {
-        for i in index..index + group.len() {
-            column_scalars.push(poly_eq_batching_scalars[i]);
-        }
+        column_scalars.extend(
+            poly_eq_batching_scalars
+                .iter()
+                .skip(index)
+                .take(group.len())
+                .copied(),
+        );
         index += witness.max_columns_per_group().next_power_of_two();
     }
 

crates/air/src/table.rs

@@ -81,18 +81,18 @@ impl<EF: ExtensionField<PF<EF>>, A: NormalAir<EF>, AP: PackedAir<EF>> AirTable<E
                 };
                 if TypeId::of::<IF>() == TypeId::of::<EF>() {
                     unsafe {
-                        self.air
-                            .eval(transmute::<_, &mut ConstraintChecker<'_, EF, EF>>(
-                                &mut constraints_checker,
-                            ));
+                        self.air.eval(transmute::<
+                            &mut ConstraintChecker<'_, IF, EF>,
+                            &mut ConstraintChecker<'_, EF, EF>,
+                        >(&mut constraints_checker));
                     }
                 } else {
                     assert_eq!(TypeId::of::<IF>(), TypeId::of::<PF<EF>>());
                     unsafe {
-                        self.air
-                            .eval(transmute::<_, &mut ConstraintChecker<'_, PF<EF>, EF>>(
-                                &mut constraints_checker,
-                            ));
+                        self.air.eval(transmute::<
+                            &mut ConstraintChecker<'_, IF, EF>,
+                            &mut ConstraintChecker<'_, PF<EF>, EF>,
+                        >(&mut constraints_checker));
                     }
                 }
                 handle_errors(row, &mut constraints_checker)?;
@@ -110,18 +110,18 @@ impl<EF: ExtensionField<PF<EF>>, A: NormalAir<EF>, AP: PackedAir<EF>> AirTable<E
                 };
                 if TypeId::of::<IF>() == TypeId::of::<EF>() {
                     unsafe {
-                        self.air
-                            .eval(transmute::<_, &mut ConstraintChecker<'_, EF, EF>>(
-                                &mut constraints_checker,
-                            ));
+                        self.air.eval(transmute::<
+                            &mut ConstraintChecker<'_, IF, EF>,
+                            &mut ConstraintChecker<'_, EF, EF>,
+                        >(&mut constraints_checker));
                     }
                 } else {
                     assert_eq!(TypeId::of::<IF>(), TypeId::of::<PF<EF>>());
                     unsafe {
-                        self.air
-                            .eval(transmute::<_, &mut ConstraintChecker<'_, PF<EF>, EF>>(
-                                &mut constraints_checker,
-                            ));
+                        self.air.eval(transmute::<
+                            &mut ConstraintChecker<'_, IF, EF>,
+                            &mut ConstraintChecker<'_, PF<EF>, EF>,
+                        >(&mut constraints_checker));
                     }
                 }
                 handle_errors(row, &mut constraints_checker)?;

crates/air/src/test.rs

@@ -105,16 +105,41 @@ fn generate_structured_trace<const N_COLUMNS: usize, const N_PREPROCESSED_COLUMN
         trace.push((0..n_rows).map(|_| rng.random()).collect::<Vec<F>>());
     }
     let mut witness_cols = vec![vec![F::ZERO]; N_COLUMNS - N_PREPROCESSED_COLUMNS];
-    for i in 1..n_rows {
-        for j in 0..N_COLUMNS - N_PREPROCESSED_COLUMNS {
-            let witness_cols_j_i_min_1 = witness_cols[j][i - 1];
-            witness_cols[j].push(
-                witness_cols_j_i_min_1
-                    + F::from_usize(j + N_PREPROCESSED_COLUMNS)
-                    + (0..N_PREPROCESSED_COLUMNS)
-                        .map(|k| trace[k][i])
-                        .product::<F>(),
-            );
+    let mut prev_values = vec![F::ZERO; N_COLUMNS - N_PREPROCESSED_COLUMNS];
+    let mut column_iters = trace[..N_PREPROCESSED_COLUMNS]
+        .iter()
+        .map(|col| col.iter())
+        .collect::<Vec<_>>();
+    if column_iters.is_empty() {
+        trace.extend(witness_cols);
+        return trace;
+    }
+    for iter in &mut column_iters {
+        iter.next(); // skip first row, already initialised
+    }
+    loop {
+        let mut row_product = F::ONE;
+        let mut progressed = true;
+        for iter in &mut column_iters {
+            match iter.next() {
+                Some(value) => row_product *= *value,
+                None => {
+                    progressed = false;
+                    break;
+                }
+            }
+        }
+        if !progressed {
+            break;
+        }
+        for (j, (witness_col, prev)) in witness_cols
+            .iter_mut()
+            .zip(prev_values.iter_mut())
+            .enumerate()
+        {
+            let next_val = *prev + F::from_usize(j + N_PREPROCESSED_COLUMNS) + row_product;
+            witness_col.push(next_val);
+            *prev = next_val;
         }
     }
     trace.extend(witness_cols);
@@ -131,14 +156,31 @@ fn generate_unstructured_trace<const N_COLUMNS: usize, const N_PREPROCESSED_COLU
         trace.push((0..n_rows).map(|_| rng.random()).collect::<Vec<F>>());
     }
     let mut witness_cols = vec![vec![]; N_COLUMNS - N_PREPROCESSED_COLUMNS];
-    for i in 0..n_rows {
-        for j in 0..N_COLUMNS - N_PREPROCESSED_COLUMNS {
-            witness_cols[j].push(
-                F::from_usize(j + N_PREPROCESSED_COLUMNS)
-                    + (0..N_PREPROCESSED_COLUMNS)
-                        .map(|k| trace[k][i])
-                        .product::<F>(),
-            );
+    let mut column_iters = trace[..N_PREPROCESSED_COLUMNS]
+        .iter()
+        .map(|col| col.iter())
+        .collect::<Vec<_>>();
+    if column_iters.is_empty() {
+        trace.extend(witness_cols);
+        return trace;
+    }
+    loop {
+        let mut row_product = F::ONE;
+        let mut progressed = true;
+        for iter in &mut column_iters {
+            match iter.next() {
+                Some(value) => row_product *= *value,
+                None => {
+                    progressed = false;
+                    break;
+                }
+            }
+        }
+        if !progressed {
+            break;
+        }
+        for (j, witness_col) in witness_cols.iter_mut().enumerate() {
+            witness_col.push(F::from_usize(j + N_PREPROCESSED_COLUMNS) + row_product);
         }
     }
     trace.extend(witness_cols);

crates/air/src/verify.rs

@@ -84,16 +84,18 @@ fn verify_air<EF: ExtensionField<PF<EF>>, A: NormalAir<EF>, AP: PackedAir<EF>>(
     if structured_air {
         verify_structured_columns(
             verifier_state,
-            table.n_columns(),
-            univariate_skips,
-            &inner_sums,
-            &column_groups,
-            &Evaluation::new(
-                outer_statement.point[1..log_length - univariate_skips + 1].to_vec(),
-                outer_statement.value,
-            ),
-            &outer_selector_evals,
-            log_length,
+            StructuredColumnsArgs {
+                n_columns: table.n_columns(),
+                univariate_skips,
+                all_inner_sums: &inner_sums,
+                column_groups,
+                outer_sumcheck_challenge: &Evaluation::new(
+                    outer_statement.point[1..log_length - univariate_skips + 1].to_vec(),
+                    outer_statement.value,
+                ),
+                outer_selector_evals: &outer_selector_evals,
+                log_n_rows: log_length,
+            },
         )
     } else {
         verify_many_unstructured_columns(
@@ -181,16 +183,30 @@ fn verify_many_unstructured_columns<EF: ExtensionField<PF<EF>>>(
     Ok(evaluations_remaining_to_verify)
 }
 
-fn verify_structured_columns<EF: ExtensionField<PF<EF>>>(
-    verifier_state: &mut FSVerifier<EF, impl FSChallenger<EF>>,
+#[derive(Debug)]
+struct StructuredColumnsArgs<'a, EF> {
     n_columns: usize,
     univariate_skips: usize,
-    all_inner_sums: &[EF],
-    column_groups: &[Range<usize>],
-    outer_sumcheck_challenge: &Evaluation<EF>,
-    outer_selector_evals: &[EF],
+    all_inner_sums: &'a [EF],
+    column_groups: &'a [Range<usize>],
+    outer_sumcheck_challenge: &'a Evaluation<EF>,
+    outer_selector_evals: &'a [EF],
     log_n_rows: usize,
+}
+
+fn verify_structured_columns<EF: ExtensionField<PF<EF>>>(
+    verifier_state: &mut FSVerifier<EF, impl FSChallenger<EF>>,
+    args: StructuredColumnsArgs<'_, EF>,
 ) -> Result<Vec<Evaluation<EF>>, ProofError> {
+    let StructuredColumnsArgs {
+        n_columns,
+        univariate_skips,
+        all_inner_sums,
+        column_groups,
+        outer_sumcheck_challenge,
+        outer_selector_evals,
+        log_n_rows,
+    } = args;
     let log_n_groups = log2_ceil_usize(column_groups.len());
     let max_columns_per_group = Iterator::max(column_groups.iter().map(|g| g.len())).unwrap();
     let log_max_columns_per_group = log2_ceil_usize(max_columns_per_group);
@@ -201,9 +217,13 @@ fn verify_structured_columns<EF: ExtensionField<PF<EF>>>(
     let mut column_scalars = vec![];
     let mut index = 0;
     for group in column_groups {
-        for i in index..index + group.len() {
-            column_scalars.push(poly_eq_batching_scalars[i]);
-        }
+        column_scalars.extend(
+            poly_eq_batching_scalars
+                .iter()
+                .skip(index)
+                .take(group.len())
+                .copied(),
+        );
         index += max_columns_per_group.next_power_of_two();
     }
 

crates/lean_compiler/src/a_simplify_lang.rs

@@ -460,8 +460,10 @@ fn simplify_lines(
                     unimplemented!("Reverse for non-unrolled loops are not implemented yet");
                 }
 
-                let mut loop_const_malloc = ConstMalloc::default();
-                loop_const_malloc.counter = const_malloc.counter;
+                let mut loop_const_malloc = ConstMalloc {
+                    counter: const_malloc.counter,
+                    ..ConstMalloc::default()
+                };
                 let valid_aux_vars_in_array_manager_before = array_manager.valid.clone();
                 array_manager.valid.clear();
                 let simplified_body = simplify_lines(
@@ -678,16 +680,15 @@ fn simplify_expr(
     match expr {
         Expression::Value(value) => value.simplify_if_const(),
         Expression::ArrayAccess { array, index } => {
-            if let SimpleExpr::Var(array_var) = array {
-                if let Some(label) = const_malloc.map.get(array_var) {
-                    if let Ok(mut offset) = ConstExpression::try_from(*index.clone()) {
-                        offset = offset.try_naive_simplification();
-                        return SimpleExpr::ConstMallocAccess {
-                            malloc_label: *label,
-                            offset,
-                        };
-                    }
-                }
+            if let SimpleExpr::Var(array_var) = array
+                && let Some(label) = const_malloc.map.get(array_var)
+                && let Ok(mut offset) = ConstExpression::try_from(*index.clone())
+            {
+                offset = offset.try_naive_simplification();
+                return SimpleExpr::ConstMallocAccess {
+                    malloc_label: *label,
+                    offset,
+                };
             }
 
             let aux_arr = array_manager.get_aux_var(array, index); // auxiliary var to store m[array + index]
@@ -1082,30 +1083,27 @@ fn handle_array_assignment(
 ) {
     let simplified_index = simplify_expr(index, res, counters, array_manager, const_malloc);
 
-    if let SimpleExpr::Constant(offset) = simplified_index.clone() {
-        if let SimpleExpr::Var(array_var) = &array {
-            if let Some(label) = const_malloc.map.get(array_var) {
-                if let ArrayAccessType::ArrayIsAssigned(Expression::Binary {
-                    left,
-                    operation,
-                    right,
-                }) = access_type
-                {
-                    let arg0 = simplify_expr(&left, res, counters, array_manager, const_malloc);
-                    let arg1 = simplify_expr(&right, res, counters, array_manager, const_malloc);
-                    res.push(SimpleLine::Assignment {
-                        var: VarOrConstMallocAccess::ConstMallocAccess {
-                            malloc_label: *label,
-                            offset,
-                        },
-                        operation,
-                        arg0,
-                        arg1,
-                    });
-                    return;
-                }
-            }
-        }
+    if let SimpleExpr::Constant(offset) = simplified_index.clone()
+        && let SimpleExpr::Var(array_var) = &array
+        && let Some(label) = const_malloc.map.get(array_var)
+        && let ArrayAccessType::ArrayIsAssigned(Expression::Binary {
+            left,
+            operation,
+            right,
+        }) = &access_type
+    {
+        let arg0 = simplify_expr(left, res, counters, array_manager, const_malloc);
+        let arg1 = simplify_expr(right, res, counters, array_manager, const_malloc);
+        res.push(SimpleLine::Assignment {
+            var: VarOrConstMallocAccess::ConstMallocAccess {
+                malloc_label: *label,
+                offset,
+            },
+            operation: *operation,
+            arg0,
+            arg1,
+        });
+        return;
     }
 
     let value_simplified = match access_type {