02:01:53 <cargodog[m]> I hope it proves useful :)
02:02:03 <cargodog[m]> You are welcome to use it as you see fit, and you'll find all related work licensed very permissively (mostly MIT license). Any citation may simply refer to my pseudonym.
02:03:30 <cargodog[m]> Hopefully I can get around to implementing the generalized `n`-ary Gray encoding scheme in my Arcturus implementation soon.
21:57:49 <sarang> cargodog[m]: you might have to write your own (n,k) Gray encoding
21:57:56 <sarang> Fun times!
21:58:20 <sarang> I have a method from a paper
21:58:29 <sarang> but have yet to integrate it into the scalar product computation
21:58:58 <sarang> The method I've seen linked to is C code from a wikipedia entry, but it appears to be incorrect and doesn't actually generate a Gray code at all
21:59:22 <sarang> Or rather, not the Gray code it claims (and not one that would be useful here anyway)
23:23:59 <sarang> cargodog[m]: it would be interesting to know the benefits you see from the Gray code method for varying `N`
23:25:13 <sarang> You're replacing a larger number of scalar-scalar multiplications by a much smaller number of them, but are including inversions instead... and those inversions are internally computed using optimized chains
23:25:59 <sarang> So you have a fixed number of multiplications per inversion (something like 20 each)
23:26:19 <selsta> Does this potential optimization help with verification time?
23:26:27 <sarang> In theory yes
23:26:47 <sarang> but I think it will depend highly on `N`
23:27:30 <sarang> and for smaller `N` I expect the benefits are only negligible because of the reliance on inversions
23:27:41 <selsta> N.. is the number of?
23:27:57 <sarang> Group elements in the proof, corresponding to the anon set size
23:28:10 <selsta> So larger ring size -> better speedup?
23:28:50 <sarang> Well, I need to verify some initial results that cargodog[m] found with a related proving system
23:29:10 <sarang> The issue is that scalar-scalar operations are _so_ much faster than scalar-group operations
23:29:24 <sarang> and so you need to get rid of a _lot_ of scalar-only operations to make a difference
23:29:30 <sarang> and inversions aren't free
23:29:31 <selsta> sounds promising, even if the speedup is not confirmed yet
23:29:42 <sarang> Yeah, it's a really clever idea, don't get me wrong :)
23:29:52 <sarang> But I'm super curious to know how the benefit changes with `N`
23:31:32 <sarang> I have code that will generate the underlying Gray codes, and now need to implement this into the Arcturus verifier
23:31:45 <sarang> (it would also apply to Triptych)
23:32:33 <sarang> It would apply to these scalar computations: https://github.com/SarangNoether/skunkworks/blob/arcturus/arcturus/arcturus.py#L375-L388
23:33:00 <sarang> Replacing the n-ary decomposition with an iterative Gray n-code
23:33:26 <sarang> And there would be a few additional optimizations related to scalar squarings too