wip

Author: zac-williamson

out.txt

@@ -10,6 +10,8 @@ use crate::redux_tables::{
     BEGIN_ARRAY_TOKEN, ASCII_TO_NUMBER
 };
 use crate::keyhash::get_keyhash;
+use crate::keyhash::get_keyhash_old;
+
 use crate::keymap::KeyLen; // todo make param
 
 struct KeySearchResult {

src/checkpoint

@@ -164,17 +164,15 @@ unconstrained fn __slice_200_bits_from_field(f: Field) -> (Field, Field, bool) {
 }
 
 fn slice_200_bits_from_field(f: Field) -> Field {
-    f * f
-    //  let (lo, hi, borrow) = __slice_200_bits_from_field(f);
-    // assert(hi * TWO_POW_200 + lo == f);
-    // lo.assert_max_bit_size(200);
-    // hi.assert_max_bit_size(56);
-    //  let lo_diff = PLO_200_felt - lo + (borrow as Field * TWO_POW_200);
-    //  let hi_diff = PHI_54_felt - hi - borrow as Field;
-    //  println(f"{lo_diff}, {hi_diff}");
-    // lo_diff.assert_max_bit_size(200);
-    // hi_diff.assert_max_bit_size(56);
-    // lo
+    let (lo, hi, borrow) = __slice_200_bits_from_field(f);
+    assert(hi * TWO_POW_200 + lo == f);
+    lo.assert_max_bit_size(200);
+    hi.assert_max_bit_size(56);
+    let lo_diff = PLO_200_felt - lo + (borrow as Field * TWO_POW_200);
+    let hi_diff = PHI_54_felt - hi - borrow as Field;
+    lo_diff.assert_max_bit_size(200);
+    hi_diff.assert_max_bit_size(56);
+    lo
 }
 // TESTS PASS WITH THIS ONE, NEED TO CHANGE TEST EXPECTS TO MATCH NEW REORDERING
 fn get_keyhash_old<let N: u32>(body_text: [u8; N], body_index: u16, key_length: u16) -> Field {
@@ -374,29 +372,29 @@ fn sum_var_bytes_into_field<let N: u32>(
     chunks[0] = body_text[idx] as Field;
     idx += path_f[0];
 
-    // chunks[1] = body_text[idx] as Field * 0x100 + body_text[idx + 1] as Field;
-    // idx += path_f[1] * 2;
-
-    // chunks[2] = body_text[idx] as Field * 0x1000000 + body_text[idx + 1] as Field * 0x10000
-    // + body_text[idx + 2] as Field * 0x100 + body_text[idx + 3] as Field;
-    // idx += path_f[2] * 4;
-
-    // chunks[3] = body_text[idx] as Field * 0x100000000000000 + body_text[idx + 1] as Field * 0x100000000000
-    // + body_text[idx + 2] as Field * 0x10000000000 + body_text[idx + 3] as Field * 0x100000000
-    // + body_text[idx + 4] as Field * 0x1000000 + body_text[idx + 5] as Field * 0x10000
-    // + body_text[idx + 6] as Field * 0x100 + body_text[idx + 7] as Field;
-    // idx += path_f[3] * 8;
-
-    // chunks[4] = body_text[idx] as Field * 0x1000000000000000000000000000000 + body_text[idx + 1] as Field * 0x1000000000000000000000000000
-    // + body_text[idx + 2] as Field * 0x100000000000000000000000000 + body_text[idx + 3] as Field * 0x1000000000000000000000000 
-    // + body_text[idx + 4] as Field * 0x10000000000000000000000 + body_text[idx + 5] as Field * 0x100000000000000000000
-    // + body_text[idx + 6] as Field * 0x1000000000000000000 + body_text[idx + 7] as Field * 0000000000000000
-    // + body_text[idx + 8] as Field * 0x100000000000000 + body_text[idx + 9] as Field * 0x100000000000
-    // + body_text[idx + 10] as Field * 0x10000000000 + body_text[idx + 11] as Field * 0x100000000
-    // + body_text[idx + 12] as Field * 0x1000000 + body_text[idx + 13] as Field * 0x10000
-    // + body_text[idx + 14] as Field * 0x100 + body_text[idx + 15] as Field;
-
-    // chunks[4] = chunks[3] * chunks[3];
+    chunks[1] = body_text[idx] as Field * 0x100 + body_text[idx + 1] as Field;
+    idx += path_f[1] * 2;
+
+    chunks[2] = body_text[idx] as Field * 0x1000000 + body_text[idx + 1] as Field * 0x10000
+    + body_text[idx + 2] as Field * 0x100 + body_text[idx + 3] as Field;
+    idx += path_f[2] * 4;
+
+    chunks[3] = body_text[idx] as Field * 0x100000000000000 + body_text[idx + 1] as Field * 0x100000000000
+    + body_text[idx + 2] as Field * 0x10000000000 + body_text[idx + 3] as Field * 0x100000000
+    + body_text[idx + 4] as Field * 0x1000000 + body_text[idx + 5] as Field * 0x10000
+    + body_text[idx + 6] as Field * 0x100 + body_text[idx + 7] as Field;
+    idx += path_f[3] * 8;
+
+    chunks[4] = body_text[idx] as Field * 0x1000000000000000000000000000000 + body_text[idx + 1] as Field * 0x1000000000000000000000000000
+    + body_text[idx + 2] as Field * 0x100000000000000000000000000 + body_text[idx + 3] as Field * 0x1000000000000000000000000 
+    + body_text[idx + 4] as Field * 0x10000000000000000000000 + body_text[idx + 5] as Field * 0x100000000000000000000
+    + body_text[idx + 6] as Field * 0x1000000000000000000 + body_text[idx + 7] as Field * 0000000000000000
+    + body_text[idx + 8] as Field * 0x100000000000000 + body_text[idx + 9] as Field * 0x100000000000
+    + body_text[idx + 10] as Field * 0x10000000000 + body_text[idx + 11] as Field * 0x100000000
+    + body_text[idx + 12] as Field * 0x1000000 + body_text[idx + 13] as Field * 0x10000
+    + body_text[idx + 14] as Field * 0x100 + body_text[idx + 15] as Field;
+
+    //chunks[4] = chunks[3] * chunks[3];
     chunks[0] *= path_f[0];
     chunks[1] *= path_f[1];
     chunks[2] *= path_f[2];
@@ -486,15 +484,15 @@ fn get_keyhash_chunky<let N: u32>(body_text: [u8; N], body_index: u16, key_lengt
     // poseidon2 has t=4. 1 permutation should cover 3 fields
     // TGODO replace with cheaper hash!
     //  println(f"KEYS BEING HASHED = {key_fields}");
-    //  let hashed_full = dep::std::hash::poseidon2::Poseidon2::hash(key_fields, num_limbs as u32);
-    let hashed_full = key_fields[0] + key_fields[1];
+    let hashed_full = dep::std::hash::poseidon2::Poseidon2::hash(key_fields, num_limbs as u32);
+    //let hashed_full = key_fields[0] + key_fields[1];
     // println(f"{hashed_full}");
     // hashed_full
     // hashed_full
-    let uv = hashed_full * hashed_full;
-    println(f"{uv}");
-    hashed_full
-    //  slice_200_bits_from_field(hashed_full)
+    //let uv = hashed_full * hashed_full;
+    //println(f"{uv}");
+    //hashed_full
+    slice_200_bits_from_field(hashed_full)
     // let hashed_bytes= dep::std::hash::blake2s(result);
     //    let hashed = fakehash(result); // dep::std::hash::blake2s(result);
     //let hashed_full = limb;

src/getters.nr

@@ -5,6 +5,7 @@ use crate::lt::lte_field_240_bit;
 use crate::lt::assert_lte_240_bit;
 use crate::redux::BEGIN_OBJECT_TOKEN;
 use crate::redux::BEGIN_ARRAY_TOKEN;
+use crate::keyhash::get_keyhash_old;
 use crate::keyhash::get_keyhash;
 use crate::keyhash::get_keyhash_chunky;
 
@@ -93,7 +94,7 @@ impl<let NumBytes: u32, let TranscriptEntries: u32> JSON<NumBytes, TranscriptEnt
         // if I know that parent id 5 maps to idx 19 that is important
         // ok so now we have, for ONE child, the location of the parent
         //
-        /*
+
         let sort_result = noir_sort::sort_advanced(hashlist, lte_field_240_bit, assert_lte_240_bit);
         let mut sorted_entries: [Field; TranscriptEntries] = [0; TranscriptEntries];
 
@@ -155,7 +156,6 @@ impl<let NumBytes: u32, let TranscriptEntries: u32> JSON<NumBytes, TranscriptEnt
         self.packed_json_entries = sorted_entries;
 
         self.key_hashes = sort_result.sorted;
-        */
     }
 }
 

src/keyhash.nr

@@ -21,7 +21,7 @@ mod getters;
 mod keyhash;
 mod slice_field;
 use crate::redux::JSON;
-use crate::slice_field::slice_field;
+use crate::slice_field::{slice_fields, slice_field};
 use crate::keyhash::{slice_200_bits_from_field, get_keyhash_chunky, sum_var_bytes_into_field};
 use crate::lt::lt_field_16_bit;
 global LEN = 10000;
@@ -66,11 +66,208 @@ unconstrained fn preamble(_json: JSON<1024, 64>) -> JSON<1024, 64> {
 // diff = 15? that can't be right
 // wo range check 128. 5012 vs 5021 = 9
 
+// slice limbs
+// 99 = 37955
+// 100 = 38283
+// delta = 283 + 45 = 328 lol fuck
+
+// size 1 slice limbs
+// 99 = 28303
+// 100 = 28533
+// delta = 230 man painful
+
+// size 2
+// 99 = 33227
+// 100 = 33508
+// delta = 285 pain
+
+// size 5 slice limbs
+// 99 =  48103
+// 100 = 48533
+// delta = 430
+
+// 607
+// 601 6
+// 595 6
+// 589  6
+
+// 645
+// 640
+
+// 606
+// 600
+
+// 6006
+// 5145
+// 150?
+global TEST1: [Field; 35] = [
+0x000000000, // 0 0 0 0 0 0 0 0 0
+0x000000001, // 0 0 0 0 0 0 0 0 1
+0x000000002, // 0 0 0 0 0 0 0 1 0
+0x000000004, // 0 0 0 0 0 0 1 0 0
+0x000000008, // 0 0 0 0 0 1 0 0 0
+0x000000010, // 0 0 0 0 1 0 0 0 0
+0x000000020, // 0 0 0 1 0 0 0 0 0
+0x000000040, // 0 0 1 0 0 0 0 0 0
+0x000000080, // 0 1 0 0 0 0 0 0 0
+0x000000100, // 1 0 0 0 0 0 0 0 0
+0x000000000, // 0 0 0 0 0 0 0 0 0
+0x000000001, // 0 0 0 0 0 0 0 0 1
+0x000000002, // 0 0 0 0 0 0 0 1 0
+0x000000004, // 0 0 0 0 0 0 1 0 0
+0x000000008, // 0 0 0 0 0 1 0 0 0
+0x000000010, // 0 0 0 0 1 0 0 0 0
+0x000000020, // 0 0 0 1 0 0 0 0 0
+0x000000040, // 0 0 1 0 0 0 0 0 0
+0x000000080, // 0 1 0 0 0 0 0 0 0
+0x000000100, // 1 0 0 0 0 0 0 0 0
+0x000000000, // 0 0 0 0 0 0 0 0 0
+0x000000001, // 0 0 0 0 0 0 0 0 1
+0x000000002, // 0 0 0 0 0 0 0 1 0
+0x000000004, // 0 0 0 0 0 0 1 0 0
+0x000000008, // 0 0 0 0 0 1 0 0 0
+0x000000010, // 0 0 0 0 1 0 0 0 0
+0x000000020, // 0 0 0 1 0 0 0 0 0
+0x000000040, // 0 0 1 0 0 0 0 0 0
+0x000000080, // 0 1 0 0 0 0 0 0 0
+0x000000100, // 1 0 0 0 0 0 0 0 0
+0x000000010, // 0 0 0 0 1 0 0 0 0
+0x000000020, // 0 0 0 1 0 0 0 0 0
+0x000000040, // 0 0 1 0 0 0 0 0 0
+0x000000080, // 0 1 0 0 0 0 0 0 0
+0x000000100, // 1 0 0 0 0 0 0 0 0
+];
+
+global FOO: [Field; 4] = [0, 1, 2, 3];
+fn maiff(p: Field) {
+    // let k = LAST_LIMB_PATH[p[0]];
+    // println(f"{k}");
+    // let q = TEST1[p[0]];
+    // println(f"{q}"); // 47
+    // let k = LAST_LIMB_PATH[lhs[0]];
+    // println(f"{k}");
+    // let k = FOO[p];
+    // println(f"{k}");
+    // let k = LAST_LIMB_PATH[p];
+    //  let k: [Field; 2] = get_last_limb_path(p);
+    //  println(f"{k}");
+    // reading array = 147 gates
+    // get_last_limb_path =150 gates
+    // init = 145 - 8 = 137
+    // 35 * 3 = 105 . + 32?
+    // 35 range check...
+    // 6 bit = 64 / 3 values = 22 values
+    // 4 3 3 3 3 3 3 - = 8 gates padding * 2 = 16 gates padding
+    // hmm hmm hmm hmm
+    // OK so we save 1 gate per call to keyfind.
+    // We have 64 keys max per 1kb json = save 64. cost is quite a bit higher. blah
+    // we save 3? gates if key len is 3 fields
+    // 8 -> 17 = 9 gates
+    // 4 gates to make
+    // 2 gates to read
+    // 17 gates = 2 9 gates init
+    // 20 gate = size 3 12 gates init
+    // 23 gates = size 4 hmm? 15 gates init
+    // 3 gates + (3 * size) boo
+    // 35 * 3 = 105 + 3 = 108 + 8 = 116 + 5 = 121
+    // cost = 140 gates
+    // where are the 3 gates coming from?
+    // 122 -> 220 = 100. why not 70?
+    // for i in 0..1 {
+    //     let k0: Field = (i as Field == p[i]) as Field;
+    //     let k1 = (i as Field == lhs[i]) as Field;
+    //     println(f"{k0}{k1}");
+    //     //let k: [Field; 2] = get_last_limb_path(p[i]);
+    //     //  println(f"{k}");
+    //     // let is_last = (i as Field == p[i]) as Field; // 3 gates
+    //     // let new = (rhs[i] - lhs[i]) * is_last + lhs[i]; // 2 gates
+    //     // assert(new == r[i]); // 1 gate
+    // }
+}
+// hmm something weird here
+fn main(foo: [Field; 100], bar: [u8; 1000], num_bytes: [u16; 100], start_bytes: [u16; 100]) {
+    // 3,621 for 100
+    // 3,613 for 99 = 8 which is expected
+    // 54 bits
+
+    // 3,726 for 100
+    // 3,723 for 99 = 3 gates = expected
+
+    // slice 200 bits
+    // 100 = 6181
+    // 99  = 6154
+    // 27 gates ok expected
+    // so something squiffy is happening
+    // aaaah the cost of an extr arange table was glomming things
+
+    // 5,871
+    // 28600 28055 26669 24689 24540
+    // 28833 28283 26883 24883 24733
+
+    // current 27834 with path valid via lookups
+    // now 27184 without "no data" (via field padding)
+    // and 26987 after tweaking with path stuff
+    // and 26837 after removing u16 cast
+
+    // more lookup messiness 28700 vs 28471 = 229 erm regression?
+    // ok fixed. 24997 vs 24805 = 192? wow? 
+
+    // 25349 vs 25153 = 150 + 46 = 196 hmmmm
+    // 24749 vs 24559 = 190 lol a bit better
+    // 45 * 3 = 135 => extra = 55 gates hmm
+
+    // 26987 vs 26773 delta = 214
+    // 26900 vs 26687 delta = 213?
+    // 26837 vs 26624 delta = 213? hmm
+    // hmm 
+    // 27433 if we can remove no data
+    // 26483 if we can remove slice_valid somehow = 10 gates hmm hmm
+    // 233 hmmmmm this beats original version
+    // 228
+    // 214
+    // 194 (we need to remove that damn write-at-arb-index)
+    // 193
+    // 45 * 3 = 135
+
+    // num_whole_limbs => path for slice valid
+    // 0 = 0 0 0 0 0
+    // 1 = 0 0 0 0 1
+    // 2 = 0 0 0 1 1
+    // 3 = 0 0 1 1 1
+    // etc etc
+    // nice! let's do that!
+
+    // e.g. if outputfields = 2
+    // 3 gates to sort out
+    // 2 gates to read
+    // 5 gates total
+    // 1: 18499 18630 -> 131
+    // how to remove arb index
+    // say we compute idx of final limb
+    // we say if (i == idx) set value we write to last limb
+    for i in 0..100 {
+        let x: [Field; 2] = slice_fields(foo, start_bytes[i], num_bytes[i]);
+        println(f"{x}");
+        //    assert(x.0 == x.1);
+    }
+    // for i in 0..99 {
+    //     let x = sum_var_bytes_into_field(bar, 10, 10);
+    //     println(f"{x}");
+    // }
+}
+// 27983
+// 27759
+// 224
+// vs
+// 27883
+// 27659
+// 224
+// wat?
 // 10,285 (10,087)
 // 10,344 (10,144)
 // diff = 44 + 15 = 59 (diff = 57)
 // maybe 58 gates all in?
-fn main(foo: [Field; 100], bar: [u8; 1000], num_bytes: [u16; 100]) {
+fn mainddddold(foo: [Field; 100], bar: [u8; 1000], num_bytes: [u16; 100]) {
     // 3,621 for 100
     // 3,613 for 99 = 8 which is expected
     println(f"{bar}");
@@ -105,11 +302,23 @@ fn main(foo: [Field; 100], bar: [u8; 1000], num_bytes: [u16; 100]) {
 // w/o range checks its 27,902 still crazy
 // 27965 with fn shell
 // ok something squiffy was getting masked away - constraining the input adds the gates
-fn makkkkin(body_text: [u8; 1024], body_indices: [u16; 64], key_lengths: [u16; 64], dd: Field) {
+
+// 63 = 10953
+// 64 = 11010
+// diff = 57
+
+// 63 = 12590
+// 64 = 12674
+// diff = 84 ? for 64 byte eh oh most commented out
+
+// 34392
+// 34821
+// 429 per key painful (poseidon hash is squiffy though)
+fn mainkkkk(body_text: [u8; 1024], body_indices: [u16; 64], key_lengths: [u16; 64], dd: Field) {
     println(f"{body_text} {body_indices} {key_lengths}");
     let kk = slice_200_bits_from_field(dd);
     println(f"{kk}");
-    for i in 0..63 {
+    for i in 0..64 {
         let x = get_keyhash_chunky(body_text, body_indices[i], key_lengths[i]);
         println(f"{x}");
     }
@@ -226,11 +435,13 @@ expectations:
 
 // chunks 1 removal cuts from 8.779 to 8.275 = 504 / 63 = 8
 */
-fn maikn(body_text: [u8; 1024], body_indices: [u16; 64], key_lengths: [u16; 64], dd: Field) {
+// 63: 8275
+// 64: 8290
+fn mainkjghg(body_text: [u8; 1024], body_indices: [u16; 64], key_lengths: [u16; 64], dd: Field) {
     println(f"{body_text} {body_indices} {key_lengths}");
     let kk = slice_200_bits_from_field(dd);
     println(f"{kk}");
-    for i in 0..63 {
+    for i in 0..64 {
         let x = sum_var_bytes_into_field(body_text, body_indices[i] as Field, key_lengths[i] as Field);
         //   let x = get_keyhash_chunky(body_text, body_indices[i], key_lengths[i]);
         println(f"{x}");