Alright, so:

- `text{kl}` didn't show up in the 3-chunk results, because it's a 4-chunker: gpf itself, the l weight, the lb, and the k.
- `text{laj}` shouldn't really be a 3-chunk metric either, by our newly shared understanding re: logarithms; we need to lock the base from 4/3 to 2 and then use a coefficient to correct.

I didn't realise how many 4-chunk metrics you were examining. I figure it can't be more than 25x24x23x22 = 303600. And 57 h 10 min is 205900 s. So that's an average of 678 ms per metric, which is faster than Excel. Well done.

I'll work out the total metrics it considered for 4 chunks:

It's

**126 + 5600 + 61425 + 140400 = 207551.** So just about 1 second per metric on average.

** 126 + **

all combinations of 4 submetrics = 6 choose 4 w/ repeated elements = ((4+6-1)!)/((4!)((6-1)!)) = 126

but that times all combinations of 0 parameters = 25 choose 0 w/ repeated elements = ((0+25-1)!)/((0!)((25-1)!)) = 1

so 126 * 1 = 126, but then that times 1 b/c for each one you can distribute the parameters across the submetrics 5^0 ways

so 126 * 1 = 126

** 5600 + **

all combinations of 3 submetrics = 6 choose 3 w/ repeated elements = ((3+6-1)!)/((3!)((6-1)!)) = 56

but that times all combinations of 1 parameters = 25 choose 1 w/ repeated elements = ((1+25-1)!)/((1!)((25-1)!)) = 25

so 56 * 25 = 1400, but then that times 4 b/c for each one you can distribute the parameters across the submetrics 4^1 ways

so 1400 * 4 = 5600

** 61425 + **

all combinations of 2 submetrics = 6 choose 2 w/ repeated elements = ((2+6-1)!)/((2!)((6-1)!)) = 21, but that times all combinations of 2 parameters = 15 choose 2 w/ repeated elements = ((2+25-1)!)/((2!)((25-1)!)) = 325, so 21 * 325 = 6825, but then that times 9 b/c for each one you can distribute the parameters across the submetrics 3^2 ways, so 6825 * 9 = 61425

** 140400**

all combinations of 1 submetric = 6 choose 1 w/ repeated elements = ((1+6-1)!)/((1!)((6-1)!)) = 6, but that times all combinations of 3 parameters = 15 choose 3 w/ repeated elements = ((3+25-1)!)/((3!)((25-1)!)) = 2925, so 6 * 2925 = 17550, but then that times 8 b/c for each one you can distribute the parameters across the submetrics 2^3 ways, so 17550 * 8 = 140400

I'm not sure how you came up with that 25x24x23x22 = 303600 estimate, but it wasn't far off!

------

For 4 chunk metrics, the maximum count of samples for a scope (which is the term for a metric but where each dynamic parameter hasn't resolved to a specific value yet but is instead a range of values to sample from a min to a max) is currently 600

^{3} = 216,000,000, since there are a few parameters which check every value in a range that is 6 wide and they check every 0.01. The smallest count of samples for a scope would be 1, since there are some parameters which are not dynamic (e.g. using numinator instead of numerator, or your modified count trick, or using the prime index instead of the prime itself, etc...), i.e. they are either present or not. And I'm going to very roughly guestimate then, based on the proportions and the different submetric count phase breakdowns detailed above, that there's an average of 10,000,000 samples it checks per sample. So I'm checking about 2 trillion possibilities for 4 chunks, in the first pass.

Since I changed it to not recursively search during the first pass, it doesn't actually hit blue threads of death anymore. So it's never hitting the 10s timeout for the vast majority of the time it runs. It's only at the very tail end step, where it runs that recursive mode for the winners (which is only like 15 thousand scopes, each with an average of more like 200 samples each since it starts out way more focused, all within one step of the first run's resolution but with an order of magnitude in increased resolution) where it'll hit blue threads of death and time out.