For those of you unfortunate enough to have attempted Indigon builds in the past, there is an interesting idea that's probably popped up into your head: is it possible to permanently sustain Indigon, such that you receive both little-to-no downtime and near-maximum uptime on the Indigon buffs? After all, that 2000% increased Spell Damage looks mighty tasty. But trying to figure out the mathematics behind this seems daunting. Many decided it wasn't worth the effort. It's said that Sirus attempted to figure it out, but as he said, his Indigon build's damage was "BORING and SMALL". However, as someone who hopelessly enjoys math as a hobby, I decided to try and figure out this riddle, and here I have the results of my labor.

The conclusion/tl;dr is at the very end; what follows is a look into the reasoning behind the conclusion.

---

Mathematics

The formula for these Mana costs:

>Mana_Cost = Base_Mana_Cost*(1 + 0.5*floor(Total_Mana_Spent_Past_Four_Seconds/200))

We create a sequence from this: suppose the skill triggers k times in four seconds.

>M_i = Base_Mana_Cost*(1 + 0.5*floor(sum (n=i-k to n=i-1) M_n/200))

Now, for those who don't recall much about Calculus: infinite sequences are said to converge if they approach a specific number (for example, the infinite sequence 1/x converges to zero, as you can see: 1, 1/2, 1/3, 1/4, 1/5, ...). Other sequences are said to diverge to infinity if the sequence climbs without stopping (the simple sequence x does this: 1, 2, 3, 4, 5, ...). And some neither converge nor diverge (such as sine and cosine: they infinitely go between 1 and -1).

We are interested in knowing whether our Indigon Mana Sequence either converges to some specific Mana cost or diverges to infinity. In the former case, we can set up our variables (pre-Indigon Mana cost, cast speed, etc.) to attain convergence to around a number we like; in the latter case, we are doomed to never have a stable Indigon build in this manner.

So let's get cracking at the math! (Again, skip to the Conclusion if you aren't interested in a more thorough examination of the problem.)

For Wolfram Alpha, given Base_Mana_Cost = 100 that triggers 4 previous times in the past 4 seconds, this is referenced by:

>a(n) = 50 floor(( sum_(k=n - 4)^(n - 1) a(k))/200) + 100

Now, when M_i > Unreserved_Max_Mana, M_i = 0.

If we include this for a maximum unreserved mana of 10,000, we get a bit of a monster of a piecewise function:

>a(n) = Piecewise[{{50 floor(( sum_(k=n - 4)^(n - 1) a(k))/200) + 100,50 floor(( sum_(k=n - 4)^(n - 1) a(k))/200) + 100 < 1000},{0,50 floor(( sum_(k=n - 4)^(n - 1) a(k))/200) + 100 >= 1000}}]

Now, this works whenever we fill our mana back to Unreserved_Max_Mana in between our cast times, but when that's not the case, we will need to adjust the above model to work with our current mana pool instead.

But for now, let's focus on the first case, just to see if it's possible for this to stabilize at all.

Wolfram Alpha was a pain, so I moved to Mathematica. And I found two interesting results running these two queries:

For once per second:

>RecurrenceTable[{l[x] == Piecewise[{{50 Floor[Sum[l[k], {k, x - 4, x - 1}]/200] + 100, 50 Floor[Sum[l[k], {k, x - 4, x - 1}]/200] + 100 < 1000}, {0, 50 Floor[Sum[l[k], {k, x - 4, x - 1}]/200] + 100 >= 1000}}], l[1] == 0, l[2] == 0, l[3] == 0, l[4] == 0}, l, {x, 5, 175}]

We get:

>{100, 100, 150, 150, 200, 250, 250, 300, 350, 350, 400, 450, 450, 500, 550, 550, 600, 650, 650, 700, 750, 750, 800, 850, 850, 900, 950, 950, 0, 800, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900, 950, 0, 750, 750, 700, 650, 800, 800, 800, 850, 900, 900}

For four times a second:

>RecurrenceTable[{l[x] == Piecewise[{{50 Floor[Sum[l[k], {k, x - 16, x - 1}]/200] + 100, 50 Floor[Sum[l[k], {k, x - 16, x - 1}]/200] + 100 < 1000}, {0, 50 Floor[Sum[l[k], {k, x - 16, x - 1}]/200] + 100 >= 1000}}], l[1] == 0, l[2] == 0, l[3] == 0, l[4] == 0, l[5] == 0, l[6] == 0, l[7] == 0, l[8] == 0, l[9] == 0, l[10] == 0, l[11] == 0, l[12] == 0, l[13] == 0, l[14] == 0, l[15] == 0, l[16] == 0}, l, {x, 5, 175}]

We get:

>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 100, 150, 150, 200, 250, 300, 400, 500, 600, 750, 950, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 950, 0, 0, 900, 950, 0, 800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 750, 950, 0, 950, 950, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 800, 750, 950, 950, 950, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 800, 750, 700, 650, 800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 800, 800, 850, 900, 900, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 950, 0, 750, 750, 700, 850, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 850, 0, 850, 900, 950, 950, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 800, 750, 700, 650, 800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

You can see a pattern here. The rate of growth of the mana costs is actually pretty low, and since the maximum mana is, percentage wise, so much higher than the base mana cost, the scaling mana cost drives right up to the maximum mana.

If we take another scenario, say, with an Archmage build, where the base mana cost is closer to 25% of maximum mana:

>RecurrenceTable[{l[x] == Piecewise[{{125 Floor[Sum[l[k], {k, x - 4, x - 1}]/200] + 250, 125 Floor[Sum[l[k], {k, x - 4, x - 1}]/200] + 250 < 1000}, {0, 125 Floor[Sum[l[k], {k, x - 4, x - 1}]/200] + 250 >= 1000}}], l[1] == 0, l[2] == 0, l[3] == 0, l[4] == 0}, l, {x, 5, 175}]

Results:

>{250, 375, 625, 0, 0, 875, 0, 750, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625, 0, 625, 0, 0, 625}

So you can see it did stabilize, only this time with plenty of interruptions. The question, then, is whether we can ensure permanent stability or not.

We can see some cases where this clearly does stabilize, such as:

>{l[x] == Piecewise[{{15 Floor[Sum[l[k], {k, x - 8, x - 1}]/200] + 30, 15 Floor[Sum[l[k], {k, x - 8, x - 1}]/200] + 30 < 20000}, {0, 15 Floor[Sum[l[k], {k, x - 8, x - 1}]/200] + 30 >= 20000}}], l[1] == 50, l[2] == 50, l[3] == 50, l[4] == 50, l[5] == 50, l[6] == 50, l[7] == 50, l[8] == 50}, l, {x, 1, 175}]

Which yields:

>{50, 50, 50, 50, 50, 50, 50, 50, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60}

This is because the ratio of the base mana cost (30) to n=8. Interestingly, the same is true but for different values if we change the starting conditions to all zero:

>{0, 0, 0, 0, 0, 0, 0, 0, 30, 30, 30, 30, 30, 30, 30, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45}

The key is the ratio with 200 and the base mana cost: if the ratio goes too high, it diverges to infinity.

The mana cost increases by half the base mana * the floor of the sum/200.

To think about an extreme case, if the base mana cost is 400, then we would have 200 * Floor + 400. Let's say x_i-8 is at least 200 greater than x_i-9. Then Floor must increase by at least 1 in the calculation for x_i compared to x_i-1.

This guarantees infinite growth.

So we can only ensure stability iff we show stability for any given k+1 size Indigon mana growth sequence.

We have stability if and only if, for any given x_i for high enough n, x_i = x_i-1 for all i > n, which implies that 0.5*Base_Mana_Cost*Float(Sum of x_i-k to x_i-1/200) + Base_Mana_Cost = 0.5*Base_Mana_Cost*Float(Sum of x_i-k-1 to x_i-2/200) + Base_Mana_Cost -> Float(Sum of x_i-k to x_i-1/200) = Float(Sum of x_i-k-1 to x_i-2/200) for all i > n. We can narrow this further: the aforementioned holds if and only if there are k+1 (non-starting) x_i through x_i+k that are all equal, since x_i+k+1 must equal x_i+k since Float(Sum of x_i to x_i+k-1/200) must equal Float(Sum of x_i+1 to x_i+k/200) since x_i = x_i+1 and x_i+k-1 = x_i+k and the two sums share the other elements. This then holds for all x_j where j > i by induction, proving stability.

Thus, we do not have stability if and only if there do not exist any i > k where x_i = x_i+k, which is equivalent to Float(Sum of x_i-k to x_i-1/200) = Float(Sum of x_i to x_i+k-1/200).

These only differ if the difference in the sums crossed a Float threshold.

Let's take Sum_A = Sum of x_i-k to x_i-1 and Sum_B = Sum of x_i to x_i+k-1.

If we take A mod 200, then we can determine whether these sums cross the threshold by the following:

>Sum_Diff = Sum_A mod 200 + (Sum_B - Sum_A)

If Sum_Diff >= 200, then Float(A/200) < Float(B/200). Else, Float(A/200) = Float(B/200)

The Float changes iff the elements change, and the elements change iff their own Floats change. Those Floats only change by whole number amounts, which change those elements by that whole number change multiplied to half of the base mana cost. So sums can only change by some integer multiplied to half the base mana cost; hence why the base mana cost is essential.

If the base mana cost is greater than 400 mana, then it's trivial to prove that it will grow: if a single element grows, then the sequence will diverge to infinity.

If the base mana cost is less than 200/k, then it is impossible for it to converge to infinity; it is guaranteed to converge to some number.

Overall, though, we don't really care if a particular instance of Sum_Diff increases, but if it continues to increase infinitely, diverging. So let's calculate what the average Float increase will be, and perhaps we can move forward from there.

Each element x_n from n=i+1 to n=i+k can increase the Sum value by 0.5*Base_Mana_Cost; then the average contribution of the Float is 0.5*Base_Mana_Cost*k*Average_Element_Increase, where Average_Element_Increase is Ceiling[0.5*Base_Mana_Cost*k/200]. If the average contribution of the Float is less than 200, then it should converge; otherwise, it should diverge.

This is a relationship between our number 200, half of our Base_Mana_Cost (i.e. the number by which our sum grows per increase in an element's Float), and the number of elements k.

>Base_Mana_Cost = 50 and k = 8 -> diverges to infinity (25*8 = 200)
>
>Base_Mana_Cost = 48 and k = 8 -> converges (24*8 = 192 < 200)
>
>Base_Mana_Cost = 58 and k = 7 -> diverges to infinity (29*7 = 203)
>
>Base_Mana_Cost = 56 and k = 7 -> converges (28*7 = 196 < 200)

There is likely a more thorough proof of this which we can investigate at some later date; for now, we can postulate that it diverges iff Base_Mana_Cost * 0.5 * k >= 200.

So we've determined the limit of our divergence/convergence. For Base_Mana_Cost = 48 and k = 8, we have:

>{0, 0, 0, 0, 0, 0, 0, 0, 48, 48, 48, 48, 48, 72, 72, 72, 96, 96, 96, 120, 120, 120, 120, 144, 144, 144, 168, 168, 168, 168, 192, 192, 192, 192, 216, 216, 216, 216, 240, 240, 240, 240, 264, 264, 264, 264, 288, 288, 288, 288, 312, 312, 312, 312, 336, 336, 336, 336, 336, 360, 360, 360, 360, 360, 384, 384, 384, 384, 384, 408, 408, 408, 408, 408, 408, 432, 432, 432, 432, 432, 432, 456, 456, 456, 456, 456, 456, 480, 480, 480, 480, 480, 480, 480, 504, 504, 504, 504, 504, 504, 504, 528, 528, 528, 528, 528, 528, 528, 552, 552, 552, 552, 552, 552, 552, 552, 576, 576, 576, 576, 576, 576, 576, 576, 600, 600, 600, 600, 600, 600, 600, 600, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624}

Convergence at 624 mana cost, which is not very high though still substantial. It's only 3*8 = 24 ticks of the full 80 which Indigon can handle at once (at max roll), with 4992 Mana spent Recently.

This can be a solid investment if one also wants to do Mind over Matter or if one simply doesn't have that much Mana due to Mana Reservation or lack of large Mana investment.

For another example, for Base_Mana_Cost = 96 and k = 4, we have:

>{0, 0, 0, 0, 96, 96, 96, 144, 192, 192, 240, 240, 288, 288, 336, 336, 384, 384, 432, 432, 480, 480, 528, 528, 576, 576, 624, 624, 672, 672, 672, 720, 720, 720, 768, 768, 768, 816, 816, 816, 864, 864, 864, 912, 912, 912, 960, 960, 960, 960, 1008, 1008, 1008, 1008, 1056, 1056, 1056, 1056, 1104, 1104, 1104, 1104, 1152, 1152, 1152, 1152, 1200, 1200, 1200, 1200, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248, 1248}

While the Mana cost is higher here, we actually have the same Recently spent Mana (since I just halved k and doubled Base_Mana_Cost): 4992 Mana spent Recently.

This yields us Floor(4992/200) = 24 amount to multiply the "(20-25)% increased Spell Damage" by, giving us between 480% and 600% increased Spell Damage from this setup.

But if we take it to the absolute maximum we can go, for Base_Mana_Cost = 99 and k = 4:

>{0, 0, 0, 0, 99., 99., 99., 148.5, 198., 198., 247.5, 247.5, 297., 297., 346.5, 346.5, 396., 396., 445.5, 445.5, 495., 495., 544.5, 544.5, 594., 594., 643.5, 643.5, 693., 693., 742.5, 742.5, 792., 792., 841.5, 841.5, 891., 891., 940.5, 940.5, 990., 990., 1039.5, ...
>
>[many, many rows later...]
>
>..., 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5, 4999.5}

It takes a lot longer, but we eventually get to a very high Mana cost: 4999.5, which gives us a massive 19998 Mana spent Recently. This more than maxes out our Indigon buff at 2000% increased Spell Damage.

We can try this for k = 8 as well, for Base_Mana_Cost = 49:

>{0, 0, 0, 0, 0, 0, 0, 0, 49., 49., 49., 49., 49., 73.5, 73.5, 73.5, ...
>
>[many, many rows later...]
>
>..., 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5, 1249.5}

Once again, it takes a lot longer to equalize, but we get to a much higher Mana cost here as well: 1249.5, which multiplied by k = 8 gives us 9996 Mana spent Recently.

This gives us 49 stacks, scaling between 980% and 1225% increased Spell Damage.

Finally, if we look at something far off like k = 16:

>{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 36, 36, 36, 36, 36, 36, 48, 48, 48, 48, 48, 48, 60, 60, 60, 60, 60, 60, 60, 72, 72, 72, 72, 72, 72, 72, , ...
>
>[many, many rows later...]
>
>..., 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, 312}

This gives us 312 * 16 = 4992 Mana spent Recently for a 480% to 600% increased Spell Damage buff. Not bad investment at all for those with low Mana and high cast rate!

But there is another question: what if we decide to let it diverge and instead consider our current Mana pool/Mana Regen as the method for running Indigon? In a sense, this monitors itself - if it gets too high, it just stops and waits for Mana to regen.

That would have some quality of life problems, though, given that it simply stops functioning, possibly at critical moments, so I won't pursue that line of thought. If one wanted to run, say, a Mjolner build that would continue to trigger even on no mana, then such a build would converge generally close to wherever their Mana Regen meets their scaling Mana costs, which naturally depends on said values for their build.

---

Conclusion

tl;dr: Overall, the main conclusion from this is that one can setup their Mana cost and cast speed in such a manner as to have their Indigon-increased Mana costs converge to a specific number.

I'd give a formula for it, but your starting conditions can actually change the number which you converge to, so if you start off with Arcane Cloak, for example, or you're using other Skills while you do this, you may change what you converge to.

This is the takeaway:

1. Calculate your pre-Indigon Mana spending and the number of casts per 4 second ('Recently') window.
2. So long as 0.5 * pre-Indigon Mana spending * number of casts per 4 second window < 200, then it will converge. Otherwise it will diverge to your maximum available Mana.
3. This also accounts for interrupts in your casting and such; the only way it surprises you by diverging is if your Mana costs or casts are increased too far. This can be a problem if you're "on the edge" of diverging, but being "on the edge" of diverging also maximizes your sustained damage, so it's a point of efficiency. The more effort you put into maintaining it high-but-not-diverging, the more sustained damage you get in return.
4. Since some builds (of those that do converge) can take a while to converge, you may want to spend some Mana up front (such as via Arcane Cloak) to speed up convergence.

For the absolute highest sustained damage, you'll want low casts with high mana cost, probably your best bet being a single cast per second with a Mana cost LESS THAN 100 but close to it (>= 100 causes divergence). As an example, for 99 mana cost, we spend ~4999.5 Mana every second, which gives us the full 2000% Indigon buff. The only problem is regenerating 5k+ Mana a second!

For a more budget amount, go for 2 casts per second (8 over 4 seconds): it's a more humble ~624 Mana cost per cast, only needing a little over 1.2k Mana regen per second, but gives us between 480% and 600% increased Spell Damage (since total Mana spent Recently is 4992). Mana cost LESS THAN 50 but close to it, if you can.

For a build with very small amounts of Mana but high regen, you can go for high cast speed: 4 casts per second. Similar mana costs at 312 Mana per cast (1.2k per second about) with the same exact 4992 Mana spent Recently, 480% to 600% increased Spell Damage via Indigon. This can probably be fit into a good amount of builds, actually, with some work on Mana regen/Recoup. Mana cost LESS THAN 25 but close to it, if you can.

EDIT: One thing I noticed is that getting the base cost below 25 is very difficult, since reduced modifiers are not effective (since the increased modifiers from Indigon are added to them), so only Less modifiers work - of which there are very few. So my initial Crackling Lance build would only work if a few support gems were dropped, lowering the base cost further. Same for other builds with a cast speed 4.0 or higher. Probably better to shoot for k = 12 (3.0 cast speed) or lower (requiring less than 33 cost), since k = 16 requires a mana cost below 25, which is difficult for any skill supported by a lot of support gems. The PoBs below have been updated accordingly.

Builds to display this:

Absolute Highest Sustained Indigon (~one cast a second): a weak Firestorm template, not recommended to try, but at least it demonstrates a template of how one might use Indigon with such one-cast-per-second concepts: https://pastebin.com/NAnYdwUq

Simpler two casts a second build: a template showing Disintegrator with Arc (only 1mil dps, not recommended to actually try, just a template): https://pastebin.com/VAtfvWLq

Speedy four casts a second: an actually strong(ish) though squishy 1.7mil Crackling Lance template: https://pastebin.com/gjv3xp0G