chore: fix typos

src/algebraic_props/sponge.rs

@@ -60,7 +60,7 @@ impl<
 
     pub fn absorb(&mut self, values: &[F]) {
         let mut rest = values;
-        // quickly fill the unfilled, then do full absorbtion rounds, then save the rest
+        // quickly fill the unfilled, then do full absorption rounds, then save the rest
         if rest.len() > AW - self.filled {
             self.filled = 0;
             let (to_use, other) = rest.split_at(AW - self.filled);

src/cs/gates/constants_allocator_as_explicit_constraint.rs

@@ -6,7 +6,7 @@ use super::*;
 // Even though it can be achieved by manual crafting of quotient terms,
 // we would like to make our lives easier. This gate ALWAYS adds 0, 1 and -1 as
 // constants, and can add an arbitrary set. Largely powers of two would be a good case,
-// even though they can be produced by just having FMA gate (that also shares coeffients) like 2 * 1 * 1 -> 2,
+// even though they can be produced by just having FMA gate (that also shares coefficients) like 2 * 1 * 1 -> 2,
 // 2 * 2 * 1 -> 4, etc
 
 #[derive(Derivative)]

src/cs/gates/uintx_add.rs

@@ -6,7 +6,7 @@ use crate::{
 use super::*;
 
 // a + b + carry_in = c + 2^N * carry_out,
-// `carry_out` is boolean constrainted
+// `carry_out` is boolean constrained
 // but `c` is NOT. We will use reduction gate to perform decomposition of `c`, and separate range checks
 
 const UNIQUE_IDENTIFIER: &str = "a + b + carry_in = c + 2^N * carry_out";

src/cs/implementations/fri/mod.rs

@@ -12,7 +12,7 @@ use std::mem::MaybeUninit;
 // Unfortunately we can not do it (unless we prove the opposite later on) due to e.g. https://www.youtube.com/watch?v=0DHoxCAsick - parallel repetition
 
 // So when we get presumably RS codes from quotening operation (f(x) - f(z))/(x - z) and linear combination of such terms,
-// we immediatelly pull challenges for such linear combination from quadratic extension, so our initial oracle for FRI containes Fp2 elements in the leafs.
+// we immediately pull challenges for such linear combination from quadratic extension, so our initial oracle for FRI containes Fp2 elements in the leafs.
 // Then on every step of interpolation we will take another challenge from Fp2 and continue
 
 // Another things is FRI soundness bound. FRI (not DEEP-FRI) is sound up to Johnson bound IF code size is much smaller

src/cs/implementations/lookup_argument.rs

@@ -218,7 +218,7 @@ pub(crate) fn compute_lookup_poly_pairs_over_general_purpose_columns<
         let aggregated_lookup_columns_inversed =
             P::vec_from_base_vec(aggregated_lookup_columns_inversed);
 
-        // we follow the same aproach as above - first prepare chunks, and then work over them
+        // we follow the same approach as above - first prepare chunks, and then work over them
 
         assert_eq!(
             variables_columns

src/cs/implementations/witness.rs

@@ -210,7 +210,7 @@ impl<
                             if var.is_placeholder() == false {
                                 *dst = witness_ref[var.0 as usize];
                             } else {
-                                // we can use 0 as a substitue for all undefined variables,
+                                // we can use 0 as a substitute for all undefined variables,
                                 // or add ZK into them
                             }
                         }