feat: refactor uint

singer-pro/src/instructions/mstore.rs

@@ -4,13 +4,13 @@ use gkr_graph::structs::{CircuitGraphBuilder, NodeOutputType, PredType};
 use itertools::Itertools;
 use paste::paste;
 use simple_frontend::structs::CircuitBuilder;
-use singer_utils::uint::constants::AddSubConstants;
 use singer_utils::{
     chip_handler::{MemoryChipOperations, ROMOperations, RangeChipOperations},
     chips::{IntoEnumIterator, SingerChipBuilder},
     constants::{OpcodeType, EVM_STACK_BYTE_WIDTH},
     register_witness,
     structs::{ChipChallenges, InstOutChipType, RAMHandler, ROMHandler, StackUInt, TSUInt},
+    uint::constants::AddSubConstants,
 };
 use std::{mem, sync::Arc};
 
@@ -219,7 +219,7 @@ register_witness!(
     },
     phase0 {
         old_memory_ts => TSUInt::N_OPERAND_CELLS,
-        old_memory_ts_lt => AddSubConstants::<TSUInt>::N_WITNESS_CELLS_NO_CARRY_OVERFLOW,
+        old_memory_ts_lt => AddSubConstants::<TSUInt>::N_WITNESS_CELLS,
 
         offset_add_delta => AddSubConstants::<StackUInt>::N_WITNESS_CELLS,
         prev_mem_byte => 1

singer-utils/src/structs.rs

@@ -50,5 +50,5 @@ pub struct ROMHandler<Ext: ExtensionField> {
 
 pub type UInt64 = UInt<64, VALUE_BIT_WIDTH>;
 pub type PCUInt = UInt64;
-pub type TSUInt = UInt<56, 56>;
+pub type TSUInt = UInt<48, 48>;
 pub type StackUInt = UInt<{ EVM_STACK_BIT_WIDTH as usize }, { VALUE_BIT_WIDTH as usize }>;

singer-utils/src/uint/arithmetic.rs

@@ -1,6 +1,4 @@
-use crate::chip_handler::RangeChipOperations;
-use crate::error::UtilError;
-use crate::uint::uint::UInt;
+use crate::{chip_handler::RangeChipOperations, error::UtilError, uint::uint::UInt};
 use ff::Field;
 use ff_ext::ExtensionField;
 use simple_frontend::structs::{Cell, CellId, CircuitBuilder};
@@ -294,8 +292,7 @@ impl<const M: usize, const C: usize> UInt<M, C> {
 
 #[cfg(test)]
 mod tests {
-    use crate::uint::constants::AddSubConstants;
-    use crate::uint::UInt;
+    use crate::uint::{constants::AddSubConstants, UInt};
     use gkr::structs::{Circuit, CircuitWitness};
     use goldilocks::{Goldilocks, GoldilocksExt2};
     use itertools::Itertools;

singer-utils/src/uint/cmp.rs

@@ -1,7 +1,8 @@
-use crate::chip_handler::RangeChipOperations;
-use crate::error::UtilError;
-use crate::uint::constants::AddSubConstants;
-use crate::uint::uint::UInt;
+use crate::{
+    chip_handler::RangeChipOperations,
+    error::UtilError,
+    uint::{constants::AddSubConstants, uint::UInt},
+};
 use ff::Field;
 use ff_ext::ExtensionField;
 use simple_frontend::structs::{CellId, CircuitBuilder, MixedCell};

singer-utils/src/uint/uint.rs

@@ -1,6 +1,8 @@
-use crate::constants::{BYTE_BIT_WIDTH, RANGE_CHIP_BIT_WIDTH};
-use crate::error::UtilError;
-use crate::uint::util::{add_one_to_big_num, convert_decomp, pad_cells};
+use crate::{
+    constants::{BYTE_BIT_WIDTH, RANGE_CHIP_BIT_WIDTH},
+    error::UtilError,
+    uint::util::{add_one_to_big_num, convert_decomp, pad_cells},
+};
 use ff_ext::ExtensionField;
 use goldilocks::SmallField;
 use itertools::Itertools;
@@ -80,6 +82,7 @@ impl<const M: usize, const C: usize> UInt<M, C> {
             Self::MAX_CELL_BIT_WIDTH,
             is_little_endian,
         )?;
+        debug_assert!(values.len() <= Self::N_OPERAND_CELLS);
         // TODO: is this safe, do we need to ensure that the padded cells are always 0?
         pad_cells(circuit_builder, &mut values, Self::N_OPERAND_CELLS);
         values.try_into()
@@ -170,8 +173,8 @@ mod tests {
         // since total bit = 30 then expect 5 cells ( 30 / 6)
         // since we have 3 cells, we need to pad with 2 more
         // hence expected output:
-        // 110010 110110 010100 000000 000000(bit representation)
-        //     50     54     20      0      0
+        // 100011 100111 000101 000000 000000(bit representation)
+        //     35     39      5      0      0
 
         let witness_values = vec![3, 0, 2, 3, 1, 2, 1, 1]
             .into_iter()
@@ -188,7 +191,7 @@ mod tests {
         let output = circuit_witness.output_layer_witness_ref().instances[0].to_vec();
         assert_eq!(
             &output[..5],
-            vec![50, 54, 20, 0, 0]
+            vec![35, 39, 5, 0, 0]
                 .into_iter()
                 .map(|v| Goldilocks::from(v))
                 .collect_vec()

singer-utils/src/uint/util.rs

@@ -49,8 +49,7 @@ pub fn convert_decomp<E: ExtensionField>(
     for values in small_cells.chunks(small_cell_count_per_big_cell) {
         let big_cell = circuit_builder.create_cell();
         for (small_chunk_index, small_bit_cell) in values.iter().enumerate() {
-            let shift_size =
-                (small_cell_count_per_big_cell - small_chunk_index - 1) * small_cell_bit_width;
+            let shift_size = small_chunk_index * small_cell_bit_width;
             circuit_builder.add(
                 big_cell,
                 *small_bit_cell,
@@ -153,7 +152,7 @@ mod tests {
         let mut circuit_builder = CircuitBuilder::<GoldilocksExt2>::new();
         let (_, small_values) = circuit_builder.create_witness_in(9);
         let small_bit_width = 2;
-        let big_bit_width = 5;
+        let big_bit_width = 6;
         let big_values = convert_decomp(
             &mut circuit_builder,
             &small_values,
@@ -162,7 +161,8 @@ mod tests {
             true,
         )
         .unwrap();
-        assert_eq!(big_values.len(), 5);
+        assert_eq!(big_values.len(), 3);
+        circuit_builder.create_witness_out_from_cells(&big_values);
 
         // verify construction against concrete witness values
         circuit_builder.configure();
@@ -174,18 +174,17 @@ mod tests {
         //  3  0  2  3  1  2  1  1  3 (field representation)
         //
         // expected output
-        // repacking into cells of bit width 5
-        // we can only fit two 2-bit cells into a 5 bit cell
-        // 1100 1011 0110 0101 1100 (bit representation)
-        //   12   11    6    5   12 (field representation)
+        // repacking into cells of bit width 6
+        // we can only fit three 2-bit cells into a 6 bit cell
+        // 100011 100111 110101 (bit representation)
+        // 35     39     53     (field representation)
 
         let witness_values = vec![3, 0, 2, 3, 1, 2, 1, 1, 3]
             .into_iter()
             .map(|v| Goldilocks::from(v))
             .collect::<Vec<_>>();
         let circuit_witness = {
-            let challenges = vec![GoldilocksExt2::from(2)];
-            let mut circuit_witness = CircuitWitness::new(&circuit, challenges);
+            let mut circuit_witness = CircuitWitness::new(&circuit, vec![]);
             circuit_witness.add_instance(&circuit, vec![witness_values]);
             circuit_witness
         };
@@ -195,17 +194,17 @@ mod tests {
         let output = circuit_witness.output_layer_witness_ref().instances[0].to_vec();
 
         assert_eq!(
-            &output[..5],
-            vec![12, 11, 6, 5, 12]
+            &output[..3],
+            vec![35, 39, 53]
                 .into_iter()
                 .map(|v| Goldilocks::from(v))
                 .collect::<Vec<_>>()
         );
 
         // padding to power of 2
         assert_eq!(
-            &output[5..],
-            vec![0, 0, 0]
+            &output[3..],
+            vec![0]
                 .into_iter()
                 .map(|v| Goldilocks::from(v))
                 .collect_vec()

singer-utils/src/uint/witness_extractors.rs

@@ -13,7 +13,7 @@ impl<const M: usize, const C: usize> UInt<M, C> {
     }
 
     pub fn extract_carry_no_overflow_add_sub(witness: &[CellId]) -> &[CellId] {
-        &witness[AddSubConstants::<Self>::N_RANGE_CELLS_IN_CARRY_NO_OVERFLOW..]
+        &witness[AddSubConstants::<Self>::N_RANGE_CELLS_NO_OVERFLOW..]
     }
 
     // TODO: why do we need this
@@ -35,6 +35,6 @@ impl<const M: usize, const C: usize> UInt<M, C> {
     }
 
     pub fn extract_range_values_no_overflow(witness: &[CellId]) -> &[CellId] {
-        &witness[..AddSubConstants::<Self>::N_RANGE_CELLS_IN_CARRY_NO_OVERFLOW]
+        &witness[..AddSubConstants::<Self>::N_RANGE_CELLS_NO_OVERFLOW]
     }
 }

singer/src/instructions/add.rs

@@ -3,7 +3,6 @@ use ff_ext::ExtensionField;
 use gkr::structs::Circuit;
 use paste::paste;
 use simple_frontend::structs::{CircuitBuilder, MixedCell};
-use singer_utils::uint::constants::AddSubConstants;
 use singer_utils::{
     chip_handler::{
         BytecodeChipOperations, GlobalStateChipOperations, OAMOperations, ROMOperations,
@@ -12,6 +11,7 @@ use singer_utils::{
     constants::OpcodeType,
     register_witness,
     structs::{PCUInt, RAMHandler, ROMHandler, StackUInt, TSUInt},
+    uint::constants::AddSubConstants,
 };
 use std::sync::Arc;
 
@@ -38,9 +38,9 @@ register_witness!(
         stack_ts_add => AddSubConstants::<TSUInt>::N_WITNESS_CELLS_NO_CARRY_OVERFLOW,
 
         old_stack_ts0 => TSUInt::N_OPERAND_CELLS,
-        old_stack_ts_lt0 => AddSubConstants::<TSUInt>::N_WITNESS_CELLS_NO_CARRY_OVERFLOW,
+        old_stack_ts_lt0 => AddSubConstants::<TSUInt>::N_WITNESS_CELLS,
         old_stack_ts1 => TSUInt::N_OPERAND_CELLS,
-        old_stack_ts_lt1 => AddSubConstants::<TSUInt>::N_WITNESS_CELLS_NO_CARRY_OVERFLOW,
+        old_stack_ts_lt1 => AddSubConstants::<TSUInt>::N_WITNESS_CELLS,
 
         addend_0 => StackUInt::N_OPERAND_CELLS,
         addend_1 => StackUInt::N_OPERAND_CELLS,
@@ -187,19 +187,22 @@ mod test {
     use goldilocks::{Goldilocks, GoldilocksExt2};
     use itertools::Itertools;
     use simple_frontend::structs::CellId;
-    use singer_utils::constants::RANGE_CHIP_BIT_WIDTH;
-    use singer_utils::structs::{StackUInt, TSUInt};
-    use singer_utils::uint::constants::AddSubConstants;
-    use std::collections::BTreeMap;
-    use std::time::Instant;
+    use singer_utils::{
+        constants::RANGE_CHIP_BIT_WIDTH,
+        structs::{StackUInt, TSUInt},
+        uint::constants::AddSubConstants,
+    };
+    use std::{collections::BTreeMap, time::Instant};
     use transcript::Transcript;
 
-    use crate::instructions::{
-        AddInstruction, ChipChallenges, Instruction, InstructionGraph, SingerCircuitBuilder,
+    use crate::{
+        instructions::{
+            AddInstruction, ChipChallenges, Instruction, InstructionGraph, SingerCircuitBuilder,
+        },
+        scheme::GKRGraphProverState,
+        test::{get_uint_params, test_opcode_circuit, u2vec},
+        CircuitWiresIn, SingerGraphBuilder, SingerParams,
     };
-    use crate::scheme::GKRGraphProverState;
-    use crate::test::{get_uint_params, test_opcode_circuit, u2vec};
-    use crate::{CircuitWiresIn, SingerGraphBuilder, SingerParams};
 
     impl AddInstruction {
         #[inline]
@@ -277,8 +280,8 @@ mod test {
         phase0_values_map.insert(
             "phase0_stack_ts_add".to_string(),
             vec![
-                Goldilocks::from(4u64), // first TSUInt::N_RANGE_CELLS = 1*(56/16) = 4 cells are range values, stack_ts + 1 = 4
-                Goldilocks::from(0u64),
+                Goldilocks::from(4u64), /* first TSUInt::N_RANGE_CELLS = 1*(48/16) = 3 cells are
+                                         * range values, stack_ts + 1 = 4 */
                 Goldilocks::from(0u64),
                 Goldilocks::from(0u64),
                 // no place for carry
@@ -296,8 +299,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
-                Goldilocks::from(1u64), // borrow
+                Goldilocks::from(1u64),
             ],
         );
         phase0_values_map.insert(
@@ -312,8 +314,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
-                Goldilocks::from(1u64), // borrow
+                Goldilocks::from(1u64),
             ],
         );
         let m: u64 = (1 << get_uint_params::<StackUInt>().1) - 1;

singer/src/instructions/calldataload.rs

@@ -258,7 +258,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
+                // Goldilocks::from(range_values[3]),
                 Goldilocks::from(1u64), // borrow
             ],
         );

singer/src/instructions/dup.rs

@@ -279,7 +279,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
+                // Goldilocks::from(range_values[3]),
                 Goldilocks::from(1u64),
             ],
         );

singer/src/instructions/gt.rs

@@ -291,7 +291,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
+                // Goldilocks::from(range_values[3]),
                 Goldilocks::from(1u64),
             ],
         );
@@ -307,7 +307,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
+                // Goldilocks::from(range_values[3]),
                 Goldilocks::from(1u64),
             ],
         );

singer/src/instructions/jump.rs

@@ -212,7 +212,7 @@ mod test {
                 Goldilocks::from(range_values[0]),
                 Goldilocks::from(range_values[1]),
                 Goldilocks::from(range_values[2]),
-                Goldilocks::from(range_values[3]),
+                // Goldilocks::from(range_values[3]),
                 Goldilocks::from(1u64), // current length has no cells for borrow
             ],
         );

singer/src/instructions/jumpi.rs

@@ -4,7 +4,6 @@ use gkr::structs::Circuit;
 use itertools::izip;
 use paste::paste;
 use simple_frontend::structs::{CircuitBuilder, MixedCell};
-use singer_utils::uint::constants::AddSubConstants;
 use singer_utils::{
     chip_handler::{
         BytecodeChipOperations, GlobalStateChipOperations, OAMOperations, ROMOperations,
@@ -13,6 +12,7 @@ use singer_utils::{
     constants::OpcodeType,
     register_witness,
     structs::{PCUInt, RAMHandler, ROMHandler, StackUInt, TSUInt},
+    uint::constants::AddSubConstants,
 };
 use std::sync::Arc;
 
@@ -36,9 +36,9 @@ register_witness!(
         clk => 1,
 
         old_stack_ts_dest => TSUInt::N_OPERAND_CELLS,
-        old_stack_ts_dest_lt => AddSubConstants::<TSUInt>::N_WITNESS_CELLS_NO_CARRY_OVERFLOW,
+        old_stack_ts_dest_lt => AddSubConstants::<TSUInt>::N_WITNESS_CELLS,
         old_stack_ts_cond => TSUInt::N_OPERAND_CELLS,
-        old_stack_ts_cond_lt => AddSubConstants::<TSUInt>::N_WITNESS_CELLS_NO_CARRY_OVERFLOW,
+        old_stack_ts_cond_lt => AddSubConstants::<TSUInt>::N_WITNESS_CELLS,
 
         dest_values => StackUInt::N_OPERAND_CELLS,
         cond_values => StackUInt::N_OPERAND_CELLS,