10:42:39 <slave_blocker> hello good day :)
10:42:47 <slave_blocker> https://github.com/monero-project/monero/blob/master/src/ringct/bulletproofs.cc
10:43:36 <slave_blocker> i don't see G and H nowhere there.
10:44:38 <slave_blocker> i assume the "systemwide" G and H = H(g) is used, right?
10:48:21 <moneromooo> They are defined in src/ringct/rctTypes.h.
10:48:46 <moneromooo> A comment there also say how H is derived.
10:52:10 <slave_blocker> i have seen that before.
10:54:46 <slave_blocker> I'm just guessing that bulletproof_PROVE uses G and H; as defined in the rctTypes.h ?
11:07:50 <slave_blocker> i don't know what a[] and b[] are .
11:08:26 <moneromooo> Arrays (pointers really).
11:09:01 <moneromooo> f(int a[]) means f(int*) really. Just expected to point to more than one.
11:11:00 <slave_blocker> https://eprint.iacr.org/2017/1066.pdf
11:11:05 <slave_blocker> page 16
11:11:38 <slave_blocker> what is the a[] and b[] ?
11:12:14 <slave_blocker> where is G[n] calculated?
15:12:21 <UkoeHB> slave_blocker: they are in there: just search rct::H and rct::G
15:22:53 <slave_blocker>     const rct::key Gi = get_exponent(rct::H, i * 2 + 1);
15:23:07 <slave_blocker> nice
15:23:14 <slave_blocker> thanks
15:23:37 <slave_blocker> :)
15:28:37 <slave_blocker> so
15:28:41 <slave_blocker> The :: operator is called the scope-resolution operator and does just that, it resolves scope. So, by prefixing a type-name with this, it tells your compiler to look in the global namespace for the type.
15:29:01 <slave_blocker> rct::H
15:29:17 <slave_blocker> is therefore systemwide:)
15:29:38 <ooo123ooo1234567> slave_blocker: no, ::rct::H would be systemwide
15:33:19 <slave_blocker> so what does the syntax for rct::H mean?
15:34:07 <slave_blocker> rct is a struct ? and H is a part of the struct?
15:34:22 <slave_blocker> or rct is a class?
15:40:33 <ooo123ooo1234567> <slave_blocker> "so what does the syntax for rct:..." <- https://en.cppreference.com/w/cpp/language/qualified_lookup, ::rct::H is doing global lookup (avoids any ambiguity), rct::H may fail if there is some ambiguity
15:51:10 <UkoeHB> rct is a namespace, H is a static variable defined in a header rctOps.h in the rct namespace, when you include that header then your including file acquires rct::H as a file-scope static variable
15:51:55 <UkoeHB> the scope-resolution qualifier without any prefix is the global scope, if there is a prefix then it is a namespace or class
15:57:23 <slave_blocker> in ztm on page 137, the transaction has 7 entries for L and for R.
15:57:34 <slave_blocker> why is that?
15:58:09 <slave_blocker> is this size always the same for every type of tx?
15:59:39 <slave_blocker> does L and R receive 3 entries ++; for every output?
16:04:21 <UkoeHB> slave_blocker: section 5.5 footnote 11
16:15:57 <slave_blocker> log 2 (64 · p)
16:16:09 <slave_blocker> what does that mean ?
16:16:51 <slave_blocker> p stands for the output amount?
16:20:28 <slave_blocker> i mean the amount of outputs.
16:25:36 <slave_blocker> yes
16:25:38 <slave_blocker> i see
16:26:45 <slave_blocker> so on page 137, there are 2 outputs hence p=2, log(128) = 7...
16:28:43 <slave_blocker> ?
16:36:45 <slave_blocker> what ?
16:37:27 <slave_blocker> so having 5 outputs or 6 outputs leads to the same size in L and R of 9 elements ?
16:43:14 <slave_blocker> so when t(x) is calculated = l(x) * r(x), thats how much the expression evaluates to formally? how many elements are in t_0 t_1 and t_2 ? 
16:44:31 <slave_blocker> https://github.com/monero-project/monero/blob/master/src/ringct/bulletproofs.cc#L707
16:44:49 <slave_blocker>  aprime[i] = l[i];
16:44:49 <slave_blocker>     bprime[i] = r[i];
16:45:47 <slave_blocker> i don't see how l[i] and r[i], is filled?
16:48:16 <slave_blocker> but i < MN, so the number is static... that does not have to do with L and R...
17:00:40 <slave_blocker> UkoeHB, l[i] is different from L[i] right? l has the size MN and L has the size log(64 * p)?
17:01:33 <slave_blocker> but the proof leads to the verification itself, because of the fiat-shamir ...
17:02:38 <slave_blocker> ah !
17:04:03 <slave_blocker> so in the case of ztm v2, there are 7 "proofs" being done! and each proof is one element in each L and R ???
17:16:20 <UkoeHB> slave_blocker: idk much about the inner workings of BP
17:25:12 <slave_blocker> :|
17:26:22 <slave_blocker> noooo
17:26:42 <slave_blocker> :(...
17:44:23 <slave_blocker> oh my
19:33:32 <kayabanerve[m]> <slave_blocker> "    const rct::key Gi = get_expo..." <- Right, yet this doesn't actually return an exponent. Instead it returns hash_to_point(H || i) or so