Yes, we have used Sea Gate Stormcaller in the past. I'm also fond of Izzet Guildmage for that task, though I think that never ended up being the best option.
Currently I'm struggling to see how we can get repeated computations. Worldfire doesn't work to get Arcbond unstuck while clearing the board at the same time, because of the Sanctifier en-Vec exile.
The only boardwipe+unstuck combination card I see is Sway of the Stars, which seems sub-optimal. It goes infinite with basically anything that tries to repeat it.
We can't allow Arcbond to get unstuck without wiping the board because we go infinite with multiple arcbond effects. So no amount of resources is high enough to allow the recovery of arcbond, unless the boardwipe is absolutely mandatory.
The other option for repeated computation is not having to recast Arcbond. Then we need the computation to halt without the arcbond creature dying. Something along the lines of a Leonin Relic-Warder dies to end the computation by putting Mark of Asylum back into play.
Leonin Relic-Warder probably goes infinite by smuggling any number of enchantments/artifacts into a computation. I didn't put a lot of effort into finding working cards for this option, because I'm hoping someone has a better idea
There's one thing we can still do to get the Sanctifier en-Vec computations to work: limit the deck to only allow one active Arcbond at a time. When we can't choose between different arcbond sources the protection on sanctifier can't create any problems.
So we'd be going back to the techniques we used before Comeuppance, when we had no other way to deal with the asymmetric arcbond damage. Iirc we got our instants stuck in the graveyard, with no way to get them out of there except for Worldfire. So no higher tier stage from Spellweaver Volute.
And the exiling from sanctifier might complicate the "getting stuck" part, as it gets our instants into exile easily. So we'd probably have to get them stuck in graveyard/exile/library.
Wait. We were talking about problems with protection, and Sanctifier has protection. Wouldn't that mean any computation involving Sanctifier has the possibility to run an infinite computation that it terminates by switching from a damage source that wouldn't hit Sanctifier to one that would, to kill it at the right time?
We use one creature type per clock, and one bishop that produces a properly dying token per clock, on the diagonal. All other bishops produce the tokens in colors that are getting exiled. And then we just have x bishops that produce type2 whenever type1 dies if the waterfall problem adds x to clock 2 when clock 1 empties.
For example this program for exponentiation:
[[1000,5,5,5,5,5],
[2,2,2,6,0,2],
[4,2,2,0,4,2],
[3,0,4,4,2,2],
[3,4,0,2,4,0],
[15,0,0,0,0,0]]
can be built with 44 bishops. (row 1 is for bookkeeping, column 1 is for the input that translates to vanillas.) Getting the input right might require additional bishops, as only 1 of the vanillas per clock is allowed to die properly with all the others needing to be exiled.
There are optimizations we can do. For example in this case all bishops come in multiples of 2, so we can use 2 white vanillas per clock and use only half of the bishops.
So we get a list, including a startup type to get the equivalent initial input:
1x bishop type1 -> type1 white
1x bishop type1 -> type2 green
3x bishop type1 -> type3 green
1x bishop type1 -> type5 green
1x bishop type2 -> type1 green
1x bishop type2 -> type2 white
2x bishop type2 -> type4 green
1x bishop type2 -> type5 green
2x bishop type3 -> type2 green
1x bishop type3 -> type3 white
1x bishop type3 -> type3 green
1x bishop type3 -> type4 green
1x bishop type3 -> type5 green
2x bishop type4 -> type1 green
1x bishop type4 -> type3 green
1x bishop type4 -> type4 white
1x bishop type4 -> type4 green
2x vanilla type1 white
2x vanilla type2 white
2x vanilla type3 white
2x vanilla type4 white
15x vanilla type5 white, one with arcbond
1x vanilla startType white
2x bishop startType -> type2 green
1x bishop startType -> type3 green
1x bishop startType -> type4 green
(assuming green gets exiled and white dies properly. White vanillas may be colorless)
This exponentiation program produces an output exponential in (#type5/2). It seems to be roughly 6*2^((#type5-1)/2), but that is not exact. Using this might be slightly better than the start without sanctifier, depending on how many type5 vanillas we can actually get. Or rather how much toughness we can give to the type5 vanilla with arcbond.
Here's a program I wrote for tetration:
[[10000,8,8,8,8,8,8,8,8],
[2,2,2,2,6,6,0,2,2],
[4,2,2,2,0,0,4,2,2],
[4,2,2,2,0,0,2,4,2],
[3,0,4,2,4,2,2,2,2],
[3,0,2,4,2,4,2,2,2],
[3,4,0,2,2,4,4,0,2],
[5,2,4,0,4,0,2,4,0],
[5,0,0,0,0,0,0,0,0]]
That seems to require too many bishops to be used. But there might be more efficient programs out there.
I can't think of any useful tricks with the sanctifier computation that would set it apart from a waterfall model program, like the part-flooding clocks we had with dralnu.
Edit: Huh, I found a small optimization for the exponentiation program:
[[1000,5,5,5,5,5],
[2,2,2,6,0,2],
[4,2,2,0,6,2],
[3,0,4,4,2,2],
[3,4,0,2,4,0],
[15,0,0,0,0,0]]
Using only 1 additional type2->type4 bishop we improve the output to ~2^#type5. With that improvement this is almost certainly a better start than not using sanctifier.
Oh, so the rules can't figure out a dependency on more than one effect together? I should have figured.
Unfortunately the infinite has an easy fix: just replace the C->A reanimator with a C->B reanimator and get the dependency loop by creating a B token. To enable the rules to figure out that B->C is dependent on A->B we can add an A,C indestructible creature.
Though I have to say, the single effect dependency has some strange results. For example with dralnus Y->Z, X->Y and W->X a single W token would not be Z, because the Y->Z dralnu is not dependent on any of the other dralnus alone. I find that very strange in this situation where there's an "obvious" dependency chain.
Things are kicked off by any type C creature dying. Type C is not used to represent any clock, where all creatures die in a batch. Instead the creature that dies to kick things off is a lonely C token that gets a fixed amount of toughness buffs from a few dralnus and indestructible reanimators, and the arcbond creature, that happen to share a type with it.
The arcbond creature is one of our creatures with 2 creature types, one of which is C. It survives through the accumulated damage by sharing its second type, H, with an increasing amount of tokens. But those H tokens don't share a type with the C token, so they don't buff it, and it can die without also killing the H,C arcbond creature.
In the Rotlung Reanimator computation we need to give the reanimators indestructible because there is no other way for them to survive while the tokens it creates and triggers from keep dying. Sephara doesn't help with that.
Putting it together with Bishop and Necromancers just seems like it is an unnecessary additional card, because we still need Sanctifier en-Vec to get buffer tokens that don't cause triggers when they leave the battlefield. (And then we need the color changer instead of the necromancer to keep the important red cards.)
Edit: Ah I think I understand what you wanted to do. But it doesn't really work.
We do need the buffer-creatures to leave the battlefield so they don't keep buffing the next run of the clock. If they stick around indestructibly they mess up the computation by still providing their coat of arms buff to new non-flying tokens.
Having these buffs stick around is a different computational model, where we can have flooding and self-refilling clocks, but no normal clocks. Great for layers, and maybe it is turing-complete. But I don't see an obvious way to run waterfall programs with it.
So, after thinking about it for a night I've come to the conclusion that Rotlung Reanimator is not enough to prevent dependency loop shenanigans. The reason is that the second creature type on the reanimator can stop it from establishing dependencies that the token it creates then forms.
Concretely:
Lets have the looping dralnus A->B, B->C, C->A. All creatures of those types that are sticking around will have base type C. So none of them can establish that C->A is dependent on B->C, because they are C already so C->A affects them anyway.
In particular there's an A,C reanimator that creates A whenever C dies. So while we have no A token there is no dependency loop because the reanimator is already C. But once the token is created the rules can detect that B->C changes what C->A applies to and see that there's a loop. The switch to timestamp order can then cause the toughness drop in a H,C arcbond creature.
We get into the situation of a C dying by occasionally creating a signalling C token with a S->C reanimator. We also need a C->H reanimator to give the opponent the choice between H,C dying and living.
I think it takes 10 ticks for the C token to die, and then another 10 ticks for the A token to die and reset the situation. So all that remains to get an infinite is add heartbeats that create 1 C (via the S->C reanimator) and 20 H every 21 ticks and synchronize them properly to get the near death event. Using 21 different heartbeat clocks for that makes it easy despite the shared creature types.
I edited this in the other thread. Making sure it is here as well:
Getting lifelink and indestructible from the same effect is no good, because it is the arcbonded creature that needs lifelink to let the opponent survive, but that creature also needs to die for the computation to stop.
There might be alternatives that provide lifelink and indestructible separately, but in a very rushed search I didn't find anything.
I went back to check, and while post 4018 was written with Necromancers in mind the procedure should work just as well for Reanimators. So we can still implement any waterfall program.
That should work, although the haste from Ignition probably goes infinite by starting an illegal computation from combat. Take Up the Shield seems fine.
Though I can't make any promises about the start being particularly great. The shared creature types between Rotlung Reanimator and the tokens it looks for and creates are really annoying to work with. Particularly when we can't just throw bigger numbers at it.
Edit: Wait, getting lifelink and indestructible from the same effect is no good, because it is the arcbonded creature that needs lifelink to let the opponent survive, but that creature also needs to die for the computation to stop. There might be alternatives, but looking for them should go into the other thread.
my point before was that the second dralnu's crusade for B->C is not part of the dependency loop but depends on the result of the loop and will thus apply at the end.
Huh, I never even considered that 2 versions of the same effect could have different dependencies. That might be possible, but I don't think it helps us here, since we can easily construct around it.
One thing to note that complicates this a little is that because Xathrid Necromancer is itself a human, any type we create that also has death triggers will always exist and be subject to dralnu's crusades the same way. Also, once the opponent decides to not trip the N clock early, they don't have that option again until the clock zeroes out the added creature. So I think creating a specific counterexample computation is at least a little nontrivial?
None of the types in the loop need anything triggering from them dying, so while the shared type from the Necromancer is annoying when constructing a specific counterexample it is not that complicated. If you think it is necessary I can work it out, though I'd prefer to use Bishop of Wings
The base C creature that sticks around and which leads to halting when it dies can have another type, not part of the loop that gives it buffs. So it is no problem to have the base A creature die after a constant amount of ticks, while the base C creature stays alive.
The more fleshed out dralnu universe could look something like A->B, B->C, C->A, B->Z, H->C, H->I, with 1 H creature carrying the arcbond, kept barely alive by I creatures, while the increasing amount if I creatures don't help to keep the A creature alive. (Or we just use a 2 type creature to carry arcbond instead of adding more dralnus)
Rotlung Reanimator would work to avoid this infinite, since then we can never create a creature of any type that wasn't there before. But I don't quite remember if we had a working way to build waterfall programs with all the extra buffs from the double shared creature type? And keeping the Reanimators alive through a computation might be more difficult than using Sanctifier en-Vec
Right, Sanctifier en-Veg exiling Scrambleverse and Soulblast wouldn't let us profit from the computations, let alone repeat them. But you mentioned the color changing spells in the other thread and I think those would work.
We need to be a bit careful since we can then start an infinite computation without casting the color changer. So we could keep that in hand to potentially disrupt the computation at an arbitrary point. But I think to get the computation sensitive to color we would need to exile Scrambleverse and Soulblast, so we would not be able to turn those creatures on the opponents side into damage. And to be extra safe we can use the sorcery Trait Doctoring.
I don't think we will actually be able to increase the output of the start. Without Dralnu's Crusade we can't build these half-flooding clocks, that refill themself after emptying. At first glance that makes a layer system a lot more expensive. We can still turn waterfall programs into bishops, but doing it that way we'd be lucky to even fit exponentiation it.
I tried to work out the best start without Dralnus before and got to ~1.6 million. That would still work. So until we can use Sanctifier in a helpful way that can be our lower bound.
I think we still need around 14000 bishops to build the UTM and we are comfortably above that, even without layers in the start up. So we can still do a bit of repeated busy beavering.
From how this is phrased, I can't tell whether it's saying the dependency needs to affect something actually on the field to count towards the loop, or if the theoretical dependency is in effect at all times and makes the order of token creation a non-issue.
I don't think the dependency rules care about any theoretical dependencies. The relevant check in 613.8a (b) asks if the other effect changes what the first effect applies to. Not if it could potentially change what it applies to.
I tried to break things with this before but couldnt, and I think the problem in your example is that if you have two dranlus making B->C then there is a way to order them so every A, every B and every C always ends up as an ABC.
and its by applying B->C C->A A->B and B->C in that order. But that does seem to cause the As to lose a toughness on net when the first B is created...
I find even less support for the idea that the rules care about any ordering of the effects that achieves some sort of maximal effect. But in any case, the 2nd B->C Dralnu is only there for the +1/+1. We can change it to B->B or B->Z to get the same buff. Then it certainly shouldn't change the dependencies.
This infinite certainly depends on the exact details of how dependencies are detected, in what order effects are checked for dependencies and applied, and what counts as a loop. At that point there are likely differences between what is intuitive, what is in the rules, and possibly what is intended by the rule makers.
My interpretation of the rules is that the rules try to apply effects in timestamp order and only delay the application if a dependency on one of the unapplied effects is detected right when an effect would normally be applied. That check for dependencies is done with the objects in the game as they are at that point as the universe of things that can be affected.
(I don't have a lot of hope for flooding waterfall computations. I tried for a bit to get good flooding computations for the start of the small deck. But the best I could get is 1 multiplication by n for n bishops: ~2^(#bishops/2). Any sort of looping logic was beyond me, because the effects of a flooding always depends on how late it happens.)
I've been working further on the writeup, and I wonder if there's any further room to optimize. In particular, is there a need for one of the Bishops to have a Drake type? It seems like it's to guarantee that it survives the computation, but as far as I can tell, when we end the computation by killing the Kavus, it has to be shortly after we flooded the Druid clock, so they should be safe just from being Kavu Horror-Druids.
On that note, do we even need the Drakes-to-Golems Bishop at all? We should end up with at least a quarter as many Golems as Drakes, and taking those Golems along with the relevant Bishops would allow us to produce a similar number of Swappable Golems even without taking the Drakes. We need to produce Drakes to keep the remaining Swap targets alive, but perhaps replacing that Bishop with more vanilla Kavus would be more helpful?
I also want to make sure my math is correct so far. I got 2^^^^25 rather than 2^^^^24, but I'm not totally sure about my logic there. Also might have forgotten about the extra vanilla Kavu from sacrificing the Boar Bishop?
When it's time to discuss the full computation, I was thinking it could be cool to be able to explain how we can use Bishops to construct arbitrary stages, as a demonstration of how this can be so much more powerful than stage combos. Do we know what that might look like?
I don't think the Kavu bishops will survive at the end. They have #steps damage on them, but there should be slightly less than #steps druids around, since new ones are not created on some of the flooding steps. It might be enough, but it's close enough that I made 1 bishop a drake to be sure.
2^^^^24 vs 2^^^^25, it is very possible that you are correct and I underestimated the damage. I just tried to be extremely conservative with my rounding and estimates everywhere
I am not aware of any good way to directly implement stages with a computation. I think it would require saving the current value of an arbitrary amount of layer resources in a single "clock", so you need some sort of encoding and decoding to make that possible. At that point I found it easier to use that encoding + decoding technology on the tape for a turing machine and implement those instead.
Going that route with known turing machines we need over 15000 bishops to beat grahams number. I don't have high hopes for a small example of massive growth thats easy to describe directly.
More importantly, I think there is an infinite in the computation with Dralnu's Crusade. I've posted about it in the other thread.
Unless I am mistaken we need to fall back on a different method for computation. I think in this case we could replace Dralnu's Crusade with Xathrid Necromancer + Sanctifier en-Vec and go to the white vs black model for the primary vs buffer distinction, instead of using a primary type and buffer types. That increases the card count, but at least we still have computations.
Of course we'd need to redo the setup computation with new costs. So we should be sure that I'm not hallucinating infinites and take some time to look for better alternatives.
Currently I'm struggling to see how we can get repeated computations. Worldfire doesn't work to get Arcbond unstuck while clearing the board at the same time, because of the Sanctifier en-Vec exile.
The only boardwipe+unstuck combination card I see is Sway of the Stars, which seems sub-optimal. It goes infinite with basically anything that tries to repeat it.
We can't allow Arcbond to get unstuck without wiping the board because we go infinite with multiple arcbond effects. So no amount of resources is high enough to allow the recovery of arcbond, unless the boardwipe is absolutely mandatory.
The other option for repeated computation is not having to recast Arcbond. Then we need the computation to halt without the arcbond creature dying. Something along the lines of a Leonin Relic-Warder dies to end the computation by putting Mark of Asylum back into play.
Leonin Relic-Warder probably goes infinite by smuggling any number of enchantments/artifacts into a computation. I didn't put a lot of effort into finding working cards for this option, because I'm hoping someone has a better idea
So we'd be going back to the techniques we used before Comeuppance, when we had no other way to deal with the asymmetric arcbond damage. Iirc we got our instants stuck in the graveyard, with no way to get them out of there except for Worldfire. So no higher tier stage from Spellweaver Volute.
And the exiling from sanctifier might complicate the "getting stuck" part, as it gets our instants into exile easily. So we'd probably have to get them stuck in graveyard/exile/library.
I don't think any way we know to do turing complete computations is left
We use one creature type per clock, and one bishop that produces a properly dying token per clock, on the diagonal. All other bishops produce the tokens in colors that are getting exiled. And then we just have x bishops that produce type2 whenever type1 dies if the waterfall problem adds x to clock 2 when clock 1 empties.
For example this program for exponentiation:
[[1000,5,5,5,5,5],
[2,2,2,6,0,2],
[4,2,2,0,4,2],
[3,0,4,4,2,2],
[3,4,0,2,4,0],
[15,0,0,0,0,0]]
can be built with 44 bishops. (row 1 is for bookkeeping, column 1 is for the input that translates to vanillas.) Getting the input right might require additional bishops, as only 1 of the vanillas per clock is allowed to die properly with all the others needing to be exiled.
There are optimizations we can do. For example in this case all bishops come in multiples of 2, so we can use 2 white vanillas per clock and use only half of the bishops.
So we get a list, including a startup type to get the equivalent initial input:
1x bishop type1 -> type1 white
1x bishop type1 -> type2 green
3x bishop type1 -> type3 green
1x bishop type1 -> type5 green
1x bishop type2 -> type1 green
1x bishop type2 -> type2 white
2x bishop type2 -> type4 green
1x bishop type2 -> type5 green
2x bishop type3 -> type2 green
1x bishop type3 -> type3 white
1x bishop type3 -> type3 green
1x bishop type3 -> type4 green
1x bishop type3 -> type5 green
2x bishop type4 -> type1 green
1x bishop type4 -> type3 green
1x bishop type4 -> type4 white
1x bishop type4 -> type4 green
2x vanilla type1 white
2x vanilla type2 white
2x vanilla type3 white
2x vanilla type4 white
15x vanilla type5 white, one with arcbond
1x vanilla startType white
2x bishop startType -> type2 green
1x bishop startType -> type3 green
1x bishop startType -> type4 green
(assuming green gets exiled and white dies properly. White vanillas may be colorless)
This exponentiation program produces an output exponential in (#type5/2). It seems to be roughly 6*2^((#type5-1)/2), but that is not exact. Using this might be slightly better than the start without sanctifier, depending on how many type5 vanillas we can actually get. Or rather how much toughness we can give to the type5 vanilla with arcbond.
Here's a program I wrote for tetration:
[[10000,8,8,8,8,8,8,8,8],
[2,2,2,2,6,6,0,2,2],
[4,2,2,2,0,0,4,2,2],
[4,2,2,2,0,0,2,4,2],
[3,0,4,2,4,2,2,2,2],
[3,0,2,4,2,4,2,2,2],
[3,4,0,2,2,4,4,0,2],
[5,2,4,0,4,0,2,4,0],
[5,0,0,0,0,0,0,0,0]]
That seems to require too many bishops to be used. But there might be more efficient programs out there.
I can't think of any useful tricks with the sanctifier computation that would set it apart from a waterfall model program, like the part-flooding clocks we had with dralnu.
Edit: Huh, I found a small optimization for the exponentiation program:
[[1000,5,5,5,5,5],
[2,2,2,6,0,2],
[4,2,2,0,6,2],
[3,0,4,4,2,2],
[3,4,0,2,4,0],
[15,0,0,0,0,0]]
Using only 1 additional type2->type4 bishop we improve the output to ~2^#type5. With that improvement this is almost certainly a better start than not using sanctifier.
Unfortunately the infinite has an easy fix: just replace the C->A reanimator with a C->B reanimator and get the dependency loop by creating a B token. To enable the rules to figure out that B->C is dependent on A->B we can add an A,C indestructible creature.
Though I have to say, the single effect dependency has some strange results. For example with dralnus Y->Z, X->Y and W->X a single W token would not be Z, because the Y->Z dralnu is not dependent on any of the other dralnus alone. I find that very strange in this situation where there's an "obvious" dependency chain.
The arcbond creature is one of our creatures with 2 creature types, one of which is C. It survives through the accumulated damage by sharing its second type, H, with an increasing amount of tokens. But those H tokens don't share a type with the C token, so they don't buff it, and it can die without also killing the H,C arcbond creature.
In the Rotlung Reanimator computation we need to give the reanimators indestructible because there is no other way for them to survive while the tokens it creates and triggers from keep dying. Sephara doesn't help with that.
Putting it together with Bishop and Necromancers just seems like it is an unnecessary additional card, because we still need Sanctifier en-Vec to get buffer tokens that don't cause triggers when they leave the battlefield. (And then we need the color changer instead of the necromancer to keep the important red cards.)
Edit: Ah I think I understand what you wanted to do. But it doesn't really work.
We do need the buffer-creatures to leave the battlefield so they don't keep buffing the next run of the clock. If they stick around indestructibly they mess up the computation by still providing their coat of arms buff to new non-flying tokens.
Having these buffs stick around is a different computational model, where we can have flooding and self-refilling clocks, but no normal clocks. Great for layers, and maybe it is turing-complete. But I don't see an obvious way to run waterfall programs with it.
Concretely:
Lets have the looping dralnus A->B, B->C, C->A. All creatures of those types that are sticking around will have base type C. So none of them can establish that C->A is dependent on B->C, because they are C already so C->A affects them anyway.
In particular there's an A,C reanimator that creates A whenever C dies. So while we have no A token there is no dependency loop because the reanimator is already C. But once the token is created the rules can detect that B->C changes what C->A applies to and see that there's a loop. The switch to timestamp order can then cause the toughness drop in a H,C arcbond creature.
We get into the situation of a C dying by occasionally creating a signalling C token with a S->C reanimator. We also need a C->H reanimator to give the opponent the choice between H,C dying and living.
I think it takes 10 ticks for the C token to die, and then another 10 ticks for the A token to die and reset the situation. So all that remains to get an infinite is add heartbeats that create 1 C (via the S->C reanimator) and 20 H every 21 ticks and synchronize them properly to get the near death event. Using 21 different heartbeat clocks for that makes it easy despite the shared creature types.
Getting lifelink and indestructible from the same effect is no good, because it is the arcbonded creature that needs lifelink to let the opponent survive, but that creature also needs to die for the computation to stop.
There might be alternatives that provide lifelink and indestructible separately, but in a very rushed search I didn't find anything.
That should work, although the haste from Ignition probably goes infinite by starting an illegal computation from combat. Take Up the Shield seems fine.
Though I can't make any promises about the start being particularly great. The shared creature types between Rotlung Reanimator and the tokens it looks for and creates are really annoying to work with. Particularly when we can't just throw bigger numbers at it.
Edit: Wait, getting lifelink and indestructible from the same effect is no good, because it is the arcbonded creature that needs lifelink to let the opponent survive, but that creature also needs to die for the computation to stop. There might be alternatives, but looking for them should go into the other thread.
None of the types in the loop need anything triggering from them dying, so while the shared type from the Necromancer is annoying when constructing a specific counterexample it is not that complicated. If you think it is necessary I can work it out, though I'd prefer to use Bishop of Wings
The base C creature that sticks around and which leads to halting when it dies can have another type, not part of the loop that gives it buffs. So it is no problem to have the base A creature die after a constant amount of ticks, while the base C creature stays alive.
The more fleshed out dralnu universe could look something like A->B, B->C, C->A, B->Z, H->C, H->I, with 1 H creature carrying the arcbond, kept barely alive by I creatures, while the increasing amount if I creatures don't help to keep the A creature alive. (Or we just use a 2 type creature to carry arcbond instead of adding more dralnus)
Rotlung Reanimator would work to avoid this infinite, since then we can never create a creature of any type that wasn't there before. But I don't quite remember if we had a working way to build waterfall programs with all the extra buffs from the double shared creature type? And keeping the Reanimators alive through a computation might be more difficult than using Sanctifier en-Vec
We need to be a bit careful since we can then start an infinite computation without casting the color changer. So we could keep that in hand to potentially disrupt the computation at an arbitrary point. But I think to get the computation sensitive to color we would need to exile Scrambleverse and Soulblast, so we would not be able to turn those creatures on the opponents side into damage. And to be extra safe we can use the sorcery Trait Doctoring.
I don't think we will actually be able to increase the output of the start. Without Dralnu's Crusade we can't build these half-flooding clocks, that refill themself after emptying. At first glance that makes a layer system a lot more expensive. We can still turn waterfall programs into bishops, but doing it that way we'd be lucky to even fit exponentiation it.
I tried to work out the best start without Dralnus before and got to ~1.6 million. That would still work. So until we can use Sanctifier in a helpful way that can be our lower bound.
I think we still need around 14000 bishops to build the UTM and we are comfortably above that, even without layers in the start up. So we can still do a bit of repeated busy beavering.
I find even less support for the idea that the rules care about any ordering of the effects that achieves some sort of maximal effect. But in any case, the 2nd B->C Dralnu is only there for the +1/+1. We can change it to B->B or B->Z to get the same buff. Then it certainly shouldn't change the dependencies.
This infinite certainly depends on the exact details of how dependencies are detected, in what order effects are checked for dependencies and applied, and what counts as a loop. At that point there are likely differences between what is intuitive, what is in the rules, and possibly what is intended by the rule makers.
My interpretation of the rules is that the rules try to apply effects in timestamp order and only delay the application if a dependency on one of the unapplied effects is detected right when an effect would normally be applied. That check for dependencies is done with the objects in the game as they are at that point as the universe of things that can be affected.
(I don't have a lot of hope for flooding waterfall computations. I tried for a bit to get good flooding computations for the start of the small deck. But the best I could get is 1 multiplication by n for n bishops: ~2^(#bishops/2). Any sort of looping logic was beyond me, because the effects of a flooding always depends on how late it happens.)
2^^^^24 vs 2^^^^25, it is very possible that you are correct and I underestimated the damage. I just tried to be extremely conservative with my rounding and estimates everywhere
I am not aware of any good way to directly implement stages with a computation. I think it would require saving the current value of an arbitrary amount of layer resources in a single "clock", so you need some sort of encoding and decoding to make that possible. At that point I found it easier to use that encoding + decoding technology on the tape for a turing machine and implement those instead.
Going that route with known turing machines we need over 15000 bishops to beat grahams number. I don't have high hopes for a small example of massive growth thats easy to describe directly.
More importantly, I think there is an infinite in the computation with Dralnu's Crusade. I've posted about it in the other thread.
Unless I am mistaken we need to fall back on a different method for computation. I think in this case we could replace Dralnu's Crusade with Xathrid Necromancer + Sanctifier en-Vec and go to the white vs black model for the primary vs buffer distinction, instead of using a primary type and buffer types. That increases the card count, but at least we still have computations.
Of course we'd need to redo the setup computation with new costs. So we should be sure that I'm not hallucinating infinites and take some time to look for better alternatives.