merge

Author: jialinli98

src/_string_tools/slice_packed_field.nr

@@ -594,37 +594,11 @@ fn divmod_31(numerator: u16) -> (u16, u16) {
     (quotient, remainder)
 }
 
-/**
- * @brief converts a 16 bit value into 16 fake bools (Field elements that are 0 or 1)
- **/
-unconstrained fn decompose(val: Field) -> [Field; 16] {
-    let mut r: [Field; 16] = [0; 16];
-
-    let mut it = val as u32;
-    for i in 0..16 {
-        r[i] = (it & 1) as Field;
-        it >>= 1;
-    }
-    r
-}
-
 // 5 gates?
-pub fn get_last_limb_path<let OutputFields: u32>(last_limb_index: Field) -> [Field; OutputFields] {
+pub fn get_last_limb_path<let OutputFields: u32>(last_limb_index: Field) -> [u1; OutputFields] {
     // TODO we offset by 1 explain why (0 byte length produces 0 - 1 which = invalid array index. we just add 1 and increase array length by 1 to compensate)
     let path = LAST_LIMB_PATH[cast_num_to_u32(last_limb_index + 1)]; // 2
-    // Safety: check the comments below
-    let path_valid_bits = unsafe { decompose(path) };
-    let mut path_valid_sum: Field = 0;
-    let mut path_valid_output: [Field; OutputFields] = [0; OutputFields];
-    for i in 0..OutputFields {
-        // we check that the path valid bits are binary
-        assert(path_valid_bits[i] * path_valid_bits[i] - path_valid_bits[i] == 0);
-        path_valid_sum += (path_valid_bits[i] * (1 << i as u8) as Field);
-        path_valid_output[i] = path_valid_bits[i];
-    }
-    // we check that the path valid bits sum to the path
-    assert(path_valid_sum == path);
-    path_valid_output
+    path.to_le_bits::<OutputFields>()
 }
 
 /**
@@ -728,13 +702,13 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
     // 1, 70.5
     let index_of_output_limb: Field = (num_bytes_div_31 as Field - num_bytes_mod_31_is_0 as Field);
     // 5, 75.5
-    let path_valid_output: [Field; OutputFields] = get_last_limb_path(index_of_output_limb);
+    let path_valid_output: [u1; OutputFields] = get_last_limb_path(index_of_output_limb);
 
     // 2, 77.5
     let tail_shift = BYTE_SHIFT[cast_num_to_u32(num_unused_bytes_in_start_limb)];
 
     // 51, 128.5
-    let mut result = [0; OutputFields];
+    let mut result: [Field; OutputFields] = [0; OutputFields];
     let mut previous = tail;
     for i in 0..(OutputFields - 1) {
         // 0
@@ -748,9 +722,9 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
         // 1, 48
         let combined = previous * tail_shift + head;
         // 1, 49
-        result[i] = combined * slice_valid;
+        result[i] = combined * (slice_valid as Field);
         // 2, 51
-        previous = (tail - previous) * slice_valid + previous;
+        previous = (tail - previous) * (slice_valid as Field) + previous;
     }
 
     // 2, 130.5
@@ -787,9 +761,10 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
     std::as_witness(last_limb);
 
     let mut path: [Field; OutputFields] = [0; OutputFields];
-    path[0] = (1 - path_valid_output[0]);
+    path[0] = (1 - path_valid_output[0] as Field);
     for i in 1..OutputFields {
-        path[i] = path_valid_output[i] * -path_valid_output[i - 1] + path_valid_output[i - 1];
+        path[i] = path_valid_output[i - 1] as Field
+            - path_valid_output[i] as Field * path_valid_output[i - 1] as Field;
     }
 
     for i in 0..OutputFields {

src/_table_generation/make_tables.nr

@@ -1,6 +1,6 @@
 //! Contains methods used to generate tables in `json_tables.nr`. These table generation methods shouldn't be used inside of actual circuits.
 use crate::enums::CaptureMode::STRING_CAPTURE;
-use crate::enums::Layer::{ARRAY_LAYER, OBJECT_LAYER, SINGLE_VALUE_LAYER};
+use crate::enums::Layer::{ARRAY_LAYER, OBJECT_LAYER};
 use crate::enums::Token::{
     BEGIN_ARRAY_TOKEN, BEGIN_OBJECT_TOKEN, END_ARRAY_TOKEN, END_OBJECT_TOKEN, KEY_SEPARATOR_TOKEN,
     KEY_TOKEN, LITERAL_TOKEN, NO_TOKEN, NUM_TOKENS, NUMERIC_TOKEN, STRING_TOKEN,
@@ -60,32 +60,32 @@ unconstrained fn make_ascii_to_token_table() -> [Field; 1024] {
     result
 }
 
-unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKENS * 3] {
+unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKENS * 2] {
     // index = layer type, current token and next token
     // output is layer type
-    // 11 tokens , 3 layers = 11 * 11 * 3 = 121 * 3 = 343
+    // 11 tokens , 2 layers = 11 * 11 * 2 = 121 * 2 = 242
     // object contexts
-    let no_change = ValidationFlags { push_layer: 0, push_layer_type_of_root: 0, pop_layer: 0 };
-    let error_flags =
-        ValidationFlags { push_layer: 0x1000000, push_layer_type_of_root: 0, pop_layer: 0 };
+    let no_change =
+        ValidationFlags { push_layer: false, push_layer_type_of_root: false, pop_layer: false };
+    let error_flags_field = 0x1000000;
     let begin_new_object_flags = ValidationFlags {
-        push_layer: 1,
-        push_layer_type_of_root: OBJECT_LAYER as Field,
-        pop_layer: 0,
+        push_layer: true,
+        push_layer_type_of_root: OBJECT_LAYER != 0,
+        pop_layer: false,
     };
     let begin_new_array_flags = ValidationFlags {
-        push_layer: 1,
-        push_layer_type_of_root: ARRAY_LAYER as Field,
-        pop_layer: 0,
+        push_layer: true,
+        push_layer_type_of_root: ARRAY_LAYER != 0,
+        pop_layer: false,
     };
     let end_object_or_array_flags: ValidationFlags =
-        ValidationFlags { push_layer: 0, push_layer_type_of_root: 0, pop_layer: 1 };
+        ValidationFlags { push_layer: false, push_layer_type_of_root: false, pop_layer: true };
 
     let token_ids: [u32; NUM_TOKENS] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
-    let error_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|_| error_flags.to_field());
+    let error_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|_| error_flags_field);
     let object_layer_begin_object_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == KEY_TOKEN) {
             result = no_change.to_field();
         }
@@ -98,13 +98,13 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     let object_layer_key_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
         let mut result = no_change.to_field();
         if (token != KEY_SEPARATOR_TOKEN) {
-            result = error_flags.to_field();
+            result = error_flags_field;
         }
         result
     });
 
     let object_layer_key_separator_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == STRING_TOKEN) | (token == LITERAL_TOKEN) | (token == NUMERIC_TOKEN) {
             result = no_change.to_field();
         }
@@ -118,7 +118,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     });
 
     let object_layer_value_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == VALUE_SEPARATOR_TOKEN) {
             result = no_change.to_field();
         }
@@ -129,7 +129,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     });
 
     let object_layer_end_object_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == VALUE_SEPARATOR_TOKEN) {
             result = no_change.to_field();
         }
@@ -144,7 +144,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     });
 
     let object_layer_value_separator_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == KEY_TOKEN) {
             result = no_change.to_field();
         }
@@ -153,11 +153,8 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
 
     let mut object_layer_flags: [[Field; NUM_TOKENS]; NUM_TOKENS] = [[0; NUM_TOKENS]; NUM_TOKENS];
     let mut array_layer_flags: [[Field; NUM_TOKENS]; NUM_TOKENS] = [[0; NUM_TOKENS]; NUM_TOKENS];
-    let mut single_value_layer_flags: [[Field; NUM_TOKENS]; NUM_TOKENS] =
-        [[0; NUM_TOKENS]; NUM_TOKENS];
-
     let no_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == NO_TOKEN) {
             result = no_change.to_field();
         }
@@ -177,7 +174,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     object_layer_flags[KEY_TOKEN] = object_layer_key_token_outcomes;
 
     let array_layer_begin_array_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token: u32| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == STRING_TOKEN) | (token == LITERAL_TOKEN) | (token == NUMERIC_TOKEN) {
             result = no_change.to_field();
         }
@@ -194,7 +191,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     });
 
     let array_layer_value_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == VALUE_SEPARATOR_TOKEN) {
             result = no_change.to_field();
         }
@@ -205,7 +202,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     });
 
     let array_layer_value_separator_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == STRING_TOKEN) | (token == LITERAL_TOKEN) | (token == NUMERIC_TOKEN) {
             result = no_change.to_field();
         }
@@ -219,7 +216,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     });
 
     let array_layer_value_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == VALUE_SEPARATOR_TOKEN) {
             result = no_change.to_field();
         }
@@ -229,7 +226,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
         result
     });
     let array_layer_end_array_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == VALUE_SEPARATOR_TOKEN) {
             result = no_change.to_field();
         }
@@ -243,7 +240,7 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
         result
     });
     let array_layer_end_object_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
+        let mut result = error_flags_field;
         if (token == VALUE_SEPARATOR_TOKEN) {
             result = no_change.to_field();
         }
@@ -264,36 +261,13 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     array_layer_flags[NUMERIC_TOKEN] = array_layer_value_token_outcomes;
     array_layer_flags[LITERAL_TOKEN] = array_layer_value_token_outcomes;
     array_layer_flags[KEY_TOKEN] = error_token_outcomes;
-
-    let single_value_layer_value_token_outcomes: [Field; NUM_TOKENS] = token_ids.map(|token| {
-        let mut result = error_flags.to_field();
-        // we have reached the end of json
-        if (token == NO_TOKEN) {
-            result = no_change.to_field();
-        }
-        result
-    });
-    single_value_layer_flags[NO_TOKEN] = no_token_outcomes;
-    single_value_layer_flags[BEGIN_OBJECT_TOKEN] = error_token_outcomes;
-    single_value_layer_flags[END_OBJECT_TOKEN] = single_value_layer_value_token_outcomes;
-    single_value_layer_flags[BEGIN_ARRAY_TOKEN] = error_token_outcomes;
-    single_value_layer_flags[END_ARRAY_TOKEN] = single_value_layer_value_token_outcomes;
-    single_value_layer_flags[KEY_SEPARATOR_TOKEN] = object_layer_key_separator_token_outcomes;
-    single_value_layer_flags[VALUE_SEPARATOR_TOKEN] = error_token_outcomes;
-    single_value_layer_flags[STRING_TOKEN] = single_value_layer_value_token_outcomes;
-    single_value_layer_flags[NUMERIC_TOKEN] = single_value_layer_value_token_outcomes;
-    single_value_layer_flags[LITERAL_TOKEN] = single_value_layer_value_token_outcomes;
-    single_value_layer_flags[KEY_TOKEN] = no_token_outcomes;
-
-    let mut flattened_flags: [Field; NUM_TOKENS * NUM_TOKENS * 3] =
-        [0; NUM_TOKENS * NUM_TOKENS * 3];
+    let mut flattened_flags: [Field; NUM_TOKENS * NUM_TOKENS * 2] =
+        [0; NUM_TOKENS * NUM_TOKENS * 2];
     let NN = (NUM_TOKENS * NUM_TOKENS);
     for j in 0..NUM_TOKENS {
         for k in 0..NUM_TOKENS {
             flattened_flags[OBJECT_LAYER * NN + j * NUM_TOKENS + k] = object_layer_flags[j][k];
             flattened_flags[ARRAY_LAYER * NN + j * NUM_TOKENS + k] = array_layer_flags[j][k];
-            flattened_flags[SINGLE_VALUE_LAYER * NN + j * NUM_TOKENS + k] =
-                single_value_layer_flags[j][k];
         }
     }
     flattened_flags

src/enums.nr

@@ -25,5 +25,4 @@ pub(crate) mod Token {
 pub(crate) mod Layer {
     pub(crate) global OBJECT_LAYER: u32 = 0;
     pub(crate) global ARRAY_LAYER: u32 = 1;
-    pub(crate) global SINGLE_VALUE_LAYER: u32 = 2;
 }