Remove rev in computation of the reversed sum in BaseSplitGenerator.

src/gadgets/split_base.rs

@@ -82,10 +82,13 @@ mod tests {
         let two = builder.two();
         let three = builder.constant(F::from_canonical_u64(3));
         let five = builder.constant(F::from_canonical_u64(5));
-        builder.assert_equal(limbs[0], two);
+        builder.route(limbs[0], two);
-        builder.assert_equal(limbs[1], three);
+        builder.route(limbs[1], three);
-        builder.assert_equal(limbs[2], five);
+        builder.route(limbs[2], five);
-        builder.assert_equal(limbs[3], one);
+        builder.route(limbs[3], one);
+        let rev = builder.constant(F::from_canonical_u64(11));
+        let revt = builder.reverse_bits::<2>(xt, 9);
+        builder.route(revt, rev);
 
         builder.assert_trailing_zeros::<6>(xt, 4);
         builder.assert_trailing_zeros::<4>(xt, 5);

src/gates/base_sum.rs

@@ -145,19 +145,22 @@ impl<F: Field, const B: usize> SimpleGenerator<F> for BaseSplitGenerator<B> {
             .scan(sum_value, |acc, _| {
                 let tmp = *acc % B;
                 *acc /= B;
-                Some(tmp)
+                Some(F::from_canonical_usize(tmp))
             })
             .collect::<Vec<_>>();
 
-        let reversed_sum = limbs_value.iter().rev().fold(0, |acc, &x| acc * B + x);
+        let b_field = F::from_canonical_usize(B);
+        let reversed_sum = limbs_value
+            .iter()
+            .fold(F::ZERO, |acc, &x| acc * b_field + x);
 
         let mut result = PartialWitness::new();
         result.set_target(
             Target::wire(self.gate_index, BaseSumGate::<B>::WIRE_REVERSED_SUM),
-            F::from_canonical_usize(reversed_sum),
+            reversed_sum,
         );
         for (b, b_value) in limbs.zip(limbs_value) {
-            result.set_target(b, F::from_canonical_usize(b_value));
+            result.set_target(b, b_value);
         }
 
         result