Simplify insert and rotate gadgets, and check that we don't overrotate.

src/gadgets/insert.rs

@@ -14,15 +14,9 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         element: ExtensionTarget<D>,
         mut v: Vec<ExtensionTarget<D>>,
     ) -> Vec<ExtensionTarget<D>> {
-        let len = v.len();
+        let mut v = self.rotate_left(index, &v);
-        let len_bits = bits_u64(len as u64);
-
-        let mut v = self.rotate_left(index, &v, len_bits);
-
         v.insert(0, element);
-
+        self.rotate_right(index, &v)
-        let len_bits = bits_u64(len as u64 + 1);
-        self.rotate_right(index, &v, len_bits)
     }
 }
 #[cfg(test)]

src/gadgets/rotate.rs

@@ -2,7 +2,7 @@ use crate::circuit_builder::CircuitBuilder;
 use crate::field::extension_field::target::ExtensionTarget;
 use crate::field::extension_field::Extendable;
 use crate::target::Target;
-use crate::util::bits_u64;
+use crate::util::log2_ceil;
 
 impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
     /// Selects `x` or `y` based on `b`, which is assumed to be binary.
@@ -29,6 +29,7 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         v: &[ExtensionTarget<D>],
     ) -> Vec<ExtensionTarget<D>> {
         let len = v.len();
+        debug_assert!(k < len, "Trying to rotate by more than the vector length.");
         let mut res = Vec::new();
 
         for i in 0..len {
@@ -46,6 +47,7 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         v: &[ExtensionTarget<D>],
     ) -> Vec<ExtensionTarget<D>> {
         let len = v.len();
+        debug_assert!(k < len, "Trying to rotate by more than the vector length.");
         let mut res = Vec::new();
 
         for i in 0..len {
@@ -90,9 +92,8 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         &mut self,
         num_rotation: Target,
         v: &[ExtensionTarget<D>],
-        len_bits: usize,
     ) -> Vec<ExtensionTarget<D>> {
-        debug_assert_eq!(bits_u64(v.len() as u64), len_bits);
+        let len_bits = log2_ceil(v.len());
         let bits = self.split_le(num_rotation, len_bits);
 
         self.rotate_left_from_bits(&bits, v)
@@ -102,9 +103,8 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         &mut self,
         num_rotation: Target,
         v: &[ExtensionTarget<D>],
-        len_bits: usize,
     ) -> Vec<ExtensionTarget<D>> {
-        debug_assert_eq!(bits_u64(v.len() as u64), len_bits);
+        let len_bits = log2_ceil(v.len());
         let bits = self.split_le(num_rotation, len_bits);
 
         self.rotate_right_from_bits(&bits, v)
@@ -141,7 +141,7 @@ mod tests {
         for i in 0..len {
             let it = builder.constant(F::from_canonical_usize(i));
             let rotated = real_rotate(i, &v);
-            let purported_rotated = builder.rotate_left(it, &v, bits_u64(len as u64));
+            let purported_rotated = builder.rotate_left(it, &v);
 
             for (x, y) in rotated.into_iter().zip(purported_rotated) {
                 builder.assert_equal_extension(x, y);
@@ -154,7 +154,7 @@ mod tests {
 
     #[test]
     fn test_rotate() {
-        for len in 1..6 {
+        for len in 1..5 {
             test_rotate_given_len(len);
         }
     }

src/gadgets/split_join.rs

@@ -29,6 +29,9 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
     /// Verifies that the decomposition is correct by using `k` `BaseSum<2>` gates
     /// with `k` such that `k*num_routed_wires>=num_bits`.
     pub(crate) fn split_le(&mut self, integer: Target, num_bits: usize) -> Vec<Target> {
+        if num_bits == 0 {
+            return Vec::new();
+        }
         let num_limbs = self.config.num_routed_wires - BaseSumGate::<2>::START_LIMBS;
         let k = ceil_div_usize(num_bits, num_limbs);
         let gates = (0..k)