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.
I hate to say it, but I think there's an infinite hiding in our current way to do computations with Dralnu's Crusade. By exploiting the dependency loop rules the opponent can halt a computation at an arbitrary point by choosing a different order for their Xathrid Necromancer triggers.
Let me explain:
Say we have 1 Dralnu turning A to B, 2 Dralnus turningn B to C and 1 Dralnu turning C to A. Before the decision point we only have a creature of base type C. The C->A Dralnu will change the set of objects that the A->B Dralnu affects, so A->B is dependent on C->A. Then A->B changes what B->C affects, so there is another dependency. But B->C doesn't change what C->A affects, since there is only the 1 base type C creature and that is affected by C->A anyway. No dependency there, so there's no loop and the Dralnus get applied in dependency order. The C creature becomes a A,B,C creature and collects +4/+4 from all the Dralnus.
Then a token of base type A gets created. We still have A->B dependent on C->A and B->C dependent on A->B from before. But now the B->C Dralnu changes what objects the C->A Dralnu affects, because it gives the base B creature the type C. So C->A is now dependent on B->C and we have a loop. The Dralnus now get applied in timestamp order.
Say that timestamp order is A->B, B->C, then C-A. Now the base C creature becomes a A,C creature and only collects +2/+2 from the Dralnus. It gets another +1/+1 from sharing a creature type with the base A creature, that became a A,B,C. But that is still a net loss of 1 toughness.
It is then fairly straightforward to construct a computation that can use this toughness loss to halt at an arbitrary point. Just give the opponent the triggers to create an A token and a token that shares a type with the base C creature at the same time, while the C creature is 1 damage away from death. If they create the A token first, then the C creature dies, leading to a halt. If they create the other creature first then the extra buff keeps C alive through the toughness loss. And a few heartbeats later the base A creature can be dead, the C creature 1 damage away from dying again and the choice can repeat.
Yeah, we sacrifice the "Boar" Bishop. The "Boar" Vanilla is the golem token that's targeted by the Audacious Swap copy that we use to cast Soulblast. As such it is shuffled away before anything happens, and the buff it provides to the Bishop is removed before it is sacrificed.
I don't quite recall why I decided to require that immediately shuffled vanilla in the program description, but now it is there. Maybe it will be useful if I at some point program in some alternate way to start the computation that we want to compare.
The type boar for that vanilla is certainly an irrelevant choice that doesn't matter and could lead to confusion. Sorry
The important part about that bishop is that it has 1 power when it is sacrificed and that it replaces itself with a vanilla Kavu, to give that last little push to the input.
Imo the 8 card hand should use Mishra's Workshop instead of Show and Tell. That is only so we don't give the opponent the opportunity to put something nasty into play. Not at all because I'm tired of using Show and Tell for the start
A high level overview of the 14 cards start-up computation could follow these lines:
We start by sacrificing a single, unbuffed Bishop of Wings to Soulblast and aim it at the Arcbond creature, so each arcbond tick will deal 1 damage.
After 3 ticks the starting Crab in the Input Heartbeat dies. Going forward a Crab will die almost every tick, since the crab replaces itself. A Crab dying also creates a Kavu, which buffs the arcbonded creature. The arcbond creature is now stable at 25 life and won't lose anymore unless this heartbeat is skipped.
After the next tick clock 1, 2 and 3 empty, creating a Cat, Ape and Frog. Thus they start the heartbeats for Clock 2, 3 and 4, which keep those clocks special creatures at a stable life, unless the corresponding heartbeat is skipped.
The program will end on its own once 25 input heartbeats are skipped, which causes the arcbonded creature to die.
To skip a beat of the input heartbeat we need to empty clock 4, i.e. reduce the life of the Horror to 0. This has two effects:
1. it skips a beat of the input heartbeat by creating a Crab*, thus reducing the arcbonded creatures life by 1
2. it recreates the Horror and Druids that make up clock 4, but now without damage. Since on most ticks in the past the heartbeat for clock 4 has created a druid to keep the life stable we now get a number of druids close to the number of arcbond ticks that have happened since the start. All the druids buff the toughness of the Horror and each other, so this time around the clock starts with "ticks since start" life.
So we need to empty clock 4 25 times, each time recreating it with bigger life.
To empty clock 4 when it has N life we need to skip the clock 4 heart beat N times. This is done by emptying clock 3.
Again, emptying clock 3 has two effects:
1. skip heartbeat of clock 4
2. recreate itself with "ticks since start" life
You see where this is going:
To empty clock 3 when it has N life we need to skip the clock 3 heart beat N times. This is done by emptying clock 2.
Emptying clock 2 has two effects:
1. skip heartbeat of clock 3
2. recreate itself with "ticks since start" life
To empty clock 2 when it has N life we need to skip the clock 2 heart beat N times. This is done by emptying clock 1.
Emptying clock 1 has two effects:
1. skip heartbeat of clock 2
2. recreate itself with "ticks since start" life. While it doesn't have a heartbeat that takes care of increasing this starting life it creates 2 Golems for every 1 that dies, which has the same effect.
Finally clock 1 doesn't have a heartbeat, so to empty it when it has N life we just need to wait N ticks. Doing that effectively doubles "ticks since start"
Put together we have a layer system with "ticks since start" as the output.
The input heartbeat clock also happens to produce 2 drakes per tick, which turns this output into output creatures as we go. Those also keep the vanillas that are still targeted by Audacious Swap alive.
There are a few things you could go into greater detail on. I'm not sure what level of brevity is appropriate.
- Skipping a heartbeat causes the heartbeat to be slower but more powerful. So instead of talking about clock N life it would be more accurate to talk about (clock N life - heartbeat N life)
- All the creatures of each clock die at the same time because the most damage creature dies and stops buffing the less damaged ones. The cascading toughness loss leaves no survivors. Technically this needs to be formally proven somewhere.
- The "ticks since start" life is not quite accurate. It's more like "ticks since start - number of times the heartbeat for this clock was skipped"
- There's probably more stuff about how clocks work that I can't think of right now because I just take it for granted, but which could require additional explanation or a proof that it does actually work like that.
The first Replication Technique can make a second Precursor and use the main Vessel to tuck itself back, then playing Audacious Swap gets two Precursor-Swap triggers. Using Casualty to tuck Vessel lets us replay Technique to get to 12 Precursors and 45 regular golems, so the first Precursor-Swap trigger gives 56 Swaps.
Building a board like this is pretty clunky, especially making new Dralnu's Crusades (copying one and editing it twice costs 5 Swaps), but using the methods here, I think it's enough to set up and run a computation that outputs three or four Knuth arrows. (It helps that having multiple Precursors means we can cast Artificial Evolution once to hack all of our creatures multiple times.) From there, we can replay Scrambleverse to retake all but one of the creatures, then replay Soulblast to kill all those creatures and get a bunch of Bishop triggers that fill our board with a corresponding number of golems we own. Then we can resolve the second Precursor-Swap trigger for a that many Swaps and use them to build a proper computation, and finish with Soulblast.
15-card can add Possibility Storm, which I think gets it to about BB{2}(2^^12). 16-card could add Sakashima's Will to get many computations per Precursor-Swap trigger and reach BB{3}, but honestly, if these actually work, I'm not sure the writeup even needs a 16-card strategy. BB{2}(2^^12) is already a big step over the Eiganjo Uprising 16-card deck.
Edit: I miscounted - it's 12 Precursors, 42 regular golems, 53 Swaps from the trigger. That should still be enough for three arrows, but I think it ends up just below the number we'd need for four.
I did some programming to pin down the damage for this 14 card deck a bit more. Those programs can be found on github. Here's what I figured out:
I found a way to write a waterfall program that runs a given n state, m symbol turing machine using 8+4m+mn clocks and a low number of bishops, under 13 per clock pair. That allows us to explicitly implement a universal turing machine. For example the 15 state, 2 symbol UTM by T. Neary and D. Woods takes roughly 14000 bishops. That UTM is the smallest I found for this conversion.
To simulate a TM using that UTM in MTG we would need roughly 2^(length(encoding(TM))) vanillas for the input. And the encoding(TM) that the UTM requires could be lengthy. But we can generate an initial batch of vanillas by programming the bishops to directly run the BB(15) champion instead of the UTM. Afterwards we can reprogram the bishops to run the UTM and have BB(15) vanillas to use for the input. That is enough to cover any losses from the encoding.
Restarting a computation after writing new input (and optionally reprogramming the bishops) requires casts of Scrambleverse, Arcbond, Artificial Evolution and Soulblast. So we need to resolve 8 Audacious Swap copies for each repetition of the BB computation. So we can roughly say that our final damage will be more than BB^X(15) when we get more than 8X+15000 Audacious Swap copies from the second Precursor Golem trigger.
To figure out how many golems we can get before the second trigger I wrote a simulator, that goes through a given boardstate step by step and can display the results. Obviously I can't run that for long enough to complete even a significant tetration. But the intermediate boardstates have convinced me that the small exponentiation and layer framework described by Deedlit11 works.
Incidentally, I think I have some good cheap computations.
For exponentiation, we can use a heartbeat clock, a part-flooding clock, and a decrement clock. For the heartbeat clock, we will have one creature that keeps dying and creating another creature, and also creating another creature for the decrement clock, so the decrement clock will normally stay the same. The part-flooding clock will still have a "special" creature type, and we will have one creature of that special type that will create another one when it dies. But we will have two Bishop of Wingss for the non-special creature type, so that when they die, twice as many of the non-special ones get created. The special creature type dying will also create a creature for the heartbeat clock, delaying the heartbeat one turn, causing the decrement clock to go down 1. So each time the part-flooding group dies, the number of non-special creatures double, and the decrement clock goes down by 1. So when the decrement clock goes from N down to 0, the nonspecial creatures will have doubled N times, so this gives us exponentiation. (So the decrement clock is the input clock and the clock causing the computation to halt, and the part-flooding clock is the output clock.)
I think we just need one creature type for the decrement clock, which can be Samurai if we use Eiganjo Uprising for the opponent's creatures. For the heartbeat clock, I think we can also use one creature type, and have maybe 4 copies of Bishop of Wings, which, when a creature of the heartbeat type dies, will create a creature of the heartbeat type, a creature of the decrement type, and two creatures of the same type as Bishop of Wings, to keep those creatures from dying. (So I guess that type can be the output clock, since we will have the most of those.) If we make Angel the heartbeat creature type, we will need 4 copies of AE to hack the Bishops. For the part-flooding type, we will need two creature types, one copy of Dralnu's Crusade to make the special creature type to also be the non-special creature type, and 4 copies of Bishop of Wings, 1 to create a special creature when the special creature dies, 1 to create a heartbeat creature when the special creature dies, and 2 to create 2 non-special creatures whenever a non-special creature dies. So that looks like 10 copies of AE needed, but we can save 2 AE's by using Spirit for one of the creature types.
So, we will need 1 Dralnu's Crusade, 8 Bishop of Wings, and 12 Artifical Evolutions, not counting what we need for input. For input, we need 1 each of heartbeat/special/non-special, then the rest go into the decrement creature type. I guess we will need another 3 AEs, for 15 total.
For tetration, we can turn the decrement clock into a second part-flooding clock, and make another decrement clock and heartbeat clock. So the original heartbeat clock and part-flooding clock work exactly the same way, except the heartbeat clock now creates one of the second part-flooding clock rather than the new decrement clock. So the second part-flooding clock decrements once each time the first part-flooding clock hits 0, so if the second part-flooding clock starts at N, we will double the first part-flooding clock N times before the second hits 0. Then, we will create a special creature for each special creature that dies (so we only need one Bishop of Wings here rather than two), which will be more than 2^N, since we add a special creature to the second pf clock each time the first pf clock decrements without hitting 0. We also have a second heartbeat clock that will maintain the new decrement clock, and the second pf clock will increment the second heartbeat clock when it dies, causing the decrement clock to decrement. So the decrement clock will decrement each time the second pf clock hits 0, resulting in an exponentiation. So if the decrement clock starts at N, we will exponentiate the second pf clock N times, resulting in more than 2^^N output.
Counting things up, the first heartbeat clock requires 4 copies of Bishop of Wings, the first part-flooding clock requires 4 copies of Bishops and 1 Dralnu's Crusade, the second heartbeat clock requires 2 copies of Bishops, the second part-flooding clock requires 3 copies of Bishops and 1 Dralnu's Crusade, and the decrement clock doesn't require anything. So it looks like we need 2 Dralnu's Crusades and 13 Bishop of Wings, along with one creature of each of the 6 creature types we need other than the decrement creature type. We will need 30 AE's if I've counted correctly.
More generally, it looks like each additional Knuth arrow will use up one more Dralnu's Crusades, 5 more Bishop of Wings, 3 more creature types used, and 3 more creatures of types besides the decrement type, along with 15 more copies of AE.
I'm not quite sure how to make things work with Xathrid Necromancers in the most efficient way; it looks like the numbers are going to be considerably higher. Maybe I'll look at it later.
My initial concern was that there is some accumulation of vanillas in the heartbeat clocks everytime you stop them for a step. But while that does make them beat slower afterwards they also become correspondingly more powerful. That does make it annoying to formally prove the construction does what we expect, but it should still work. The decreasing variables of the layer sequence become (life(input)-life(heartbeat_input)) instead of the simple life(input) that we would have without the growing heartbeat.
With that construction we can squeeze a hexation out of the initial 53 Audations Swap casts. And since we can use all the bishops of that program as input as well it is even a pretty big one. I think we reach 2^^^^24 with this construction.
Here are the costs in Audacious Swap casts I get for that:
The free Vanillas are the 5 Vanillas that are targeted by Audacious Swap copies, one of which gets exiled to cast Soulblast. The 6th free Vanilla is the target of the original Audacious Swap, that didn't get a copy targeting it. The program ensures that the 4 vanillas targeted by Audacious Swap survive the computation, along with a Bishop that turns the output into Golems. If I forgot anything that should be included in the costs please let me know.
Operations like -15000 and /8 just disappear in the rounding with numbers like 2^^^^24. So my conclusion is that this 14 card deck can deal more than BB^(2^^^^24)(15) damage.
A tier-N resource A, with tier N-1 resource B
Transition creation: A process to spend 1 A and a small amount of triggers to create a transition on the stack and many B
Transition use: A process to remove all B and create 1 A. After which, everything is back in the same state necessary to create another transition.
(the "spending a small amount of triggers" can be done in transition use instead of creation, but that's equivalent to considering those triggers as part of the transition)
Small nitpick: the transition use needs to remove the resources of all lower tier stages, not only those of the tier N-1 stage. Basically all the resources that would allow replacing the triggers used.
The good news for Tier 3 stages is that the Tier 1 resource, triggers, gets cleared just by resolving the stack. But it is a problem when trying to get Tier 4 to work.
Regarding the infinite, it has been to long since I looked at the deck. I'd need to study it again to figure out if the infinite I had in mind back then actually works. If you can proof it is impossible that would be great! But getting this close to any infinite is risky, even if it currently doesn't work. If we miss any small implication anywhere when working on the rest of the deck, it will quickly blow up. Personally I wouldn't want to risk it.
Liquimetal Torque goes infinite by giving the opponent access to mana, which allows them to interrupt a computation: We Wrong Turn a few copies of Liquimetal Torque and a Soul Foundry with an imprinted creature while March of the Machines is out, then get rid of MoM and start the computation. After an arbitrary time the opponent activates the Foundry with mana from the Torques and gets an additional typed creature, which can lead to halting.
The type creature of Palladium Myr is the important part of the old card combo, since only creatures on our side of the battlefield can have haste from Emblem of the Warmind. So the opponent can't use it to gain mana.
Ah, I misunderstood the procedure after attacking. I thought we'd go through the main loop described earlier again to turn life into more shapeshifters. That one includes the golem cast for efficiency. But it is of course enough to turn life into shapeshifters less efficiently using only Saw in Half.
What you're missing is that the Shapeshifter count is increased both by Sawing Shapeshifter-Golems and by Sawing Shapeshifter-Inverters.
I still count only two Saws for each Shapeshifter ability that is around when we cast the golem. And both of those Saws destroy 1 and create 2 creatures with the ability, whether it's an inverter or golem. I still don't see how you get the *3.
Cast a Saw pair on a Shapeshifter-Inverter and the original Golem.
Cast Boulderbranch Golem. (net -1 life) All Shapeshifters trigger.
After each of those Shapeshifter triggers resolve, cast a Saw pair on an Inverter and the 6/5 Shapeshifter-Golem. The first two times, it has to target a plain Inverter; each subsequent time can target a Shapeshifter-Inverter that does not have a waiting trigger to become a 6/5 Golem.
The net result is -1 life, and +1 and then *3-2 to the number of Shapeshifters, which works out to *3+1.
This can be repeated 7 times, ending with 7 life and 9841 Shapeshifters.
Are those numbers correct? The initial saw pair accounts for the +1, but after that we only cast one saw pair for each shapeshifter with a trigger. Each saw increases the number of creatures with the shapeshifter ability by -1+2 = 1. So I think we go from N to (N+1)*2-2 = 2*N instead of the N*3+1 you have.
That would result in 512 shapeshifters instead of 9841. That should still be enough to beat grahams number though.
I had another run in with the "oracle text" on mtgsalvation. It says "Whenever another creature enters the battlefield, Unstable Shapeshifter becomes a copy of that creature and gains this ability." That would lead to the combo not working, since the Saw in Half copies of a shapeshifter that has become a copy of the golem or inverter would just be that golem or inverter. The shapeshifter ability would not be transferred to the new copies since it was only gained later.
Fortunately the actual gatherer text is "Whenever another creature enters the battlefield, Unstable Shapeshifter becomes a copy of that creature, except it has this ability." It gives the shapeshifter ability by modifying the copy effect with an "except", so the ability gets copied properly onto the Saw in Half copies.
So as far as I can tell the combo should work. That's an amazing build!
The problem is that we can't actually use Replication Technique for tetrations during the Precursor-Swap triggers. The main spell always needs to target Vessel to recur Technique, so we can't get Precursor triggers from it. (The only exception is when we cast it off Casualty, since Vessel is back in our library.) But hopefully we can do better anyway.
Ugh, right, I didn't realize that.
So each Bishop copy costs 1 cast, each Dralnu's Crusade costs 1 cast + 2 per hack, so usually 5, but we can save a bit by making use of goblin/zombies. We need additional casts to hack all creatures (3?), get Coat of Arms (1), Arcbond (1?), Comeuppance (1), Soulblast (1), and Scrambleverse to give the setup to the opponent and get the output back (1+2). And all from only 53 casts (and I think there's a card in hand we could use?). That's pretty tight.
Regarding the heartbeat clocks, would adding Dralnu's Crusades to them fix the issue? That would get even more expensive but I think it would at least be enough for two arrows. I think we'd have enough spare Swaps in that case to run the small computation twice, hacking the output creatures from the first one into the input type, to reach 2^^2^^N and beat that target anyway. But yeah, hopefully there's an alternative that leans less on Crusade and more on Bishops.
Adding a Dralnu's Crusade for the Heartbeat should work at least for the exponentiation part. I don't fully understand the tetration and additional layer parts yet.
Starting the computation again with bigger vanilla input might be helpful. After those small computations we then get a lot more casts. Hopefully we can manage to set up the universal turing machine with a fixed number of those casts and have the majority left over. Then we can use the remaining casts to get repeated Busy Beaver computation with the same trick, and wouldn't need to go to 15 cards for that ^^'
Those are some great ideas to get the computations!
For 14 cards using a very small computations to get the numbers needed for the big computation should be doable.
I think skipping the small computation and casting Replication Technique 21 times instead would get us to ~2^^24 golems, so that would be our lower bound of what we can reach. IIRC that is a bit below the input sizes where we know how to implement a universal turing machine. So a computation that gets more layers would be preferred.
The special creature type dying will also create a creature for the heartbeat clock, delaying the heartbeat one turn,
For the heartbeat clock, I think we can also use one creature type,
We can't have both of those, or the heartbeat will accumulate more and more creatures.
The constructions are also probably not optimized for the situation we actually get here, where we can create and hack Bishops fairly easily but the Dralnu's crusades are very expensive. I plan to look into those small computations a bit more.
Edit: Using a similar method, I believe the 7-card deck finishes its second Slaughter cast with 7,258,845,553,210 copies of Precursor Golem and 16,937,306,290,822 copies of Salvaging Station:
That would be the numbers after the second Precursor Golem trigger on Slaughter, so before the second Slaughter cast.
We can however do better by using the mana from the last two slaughter deaths to create Precursor Golems, instead of only the mana from the last one. The Salvaging Stations we could create on the second to last death only give us 6 mana back before we resolve the next precursor golem trigger or cast the next spell and in either case getting just one more golem beforehand is worth more than the additional salvaging stations. (Though to optimize we can create Salvaging Stations on the second to last death at the cost of effectively 1 mana, so we can use that to finish with 0 to 6 additional stations 0 mana)
I updated my spreadsheet with that play pattern. We end up with 25 Salvaging Stations, 19 Precursor Golems and 36 Golem Tokens before the second Precursor Golem trigger on Slaughter will resolve.
Because Comeuppance is our trigger and it’s our turn, it goes on the stack before the opponent’s triggers, and therefore resolves after them.
This part in the description of the computation is wrong. Comeuppance doesn't trigger, it creates a replacement effect. So the damage that it deals to the Arcbonded creature is dealt at the same time as all of the other Arcbond damage.
If that wasn't the case we could go infinite if we are able to set up a computation with multiple arcbonded creature, because the slight asymmetry of arcbond allows us to change the computation after an arbitrary time by changing the order of the arcbond triggers.
The trigger that is ours and goes on the stack before the opponent's triggers is actually the Arcbond trigger itself. We controlled arcbond when it resolved, so that trigger is ours, even when we don't control the arcbonded creature.
I noticed a problem with the Archon of Falling Stars plan: If we have a Spellweaver Volute trigger for a targeting instant on the top of the stack while we sacrifice everything to another Volute trigger on Kaervek's Spite then we can use an Archon trigger to bring Cowardice back to the battlefield. That would allow the lower Volute trigger to bounce the Armor Thrull if we have it donated to the opponent to survive the mass sacrifice.
We can get the two Volute triggers from the same Lingering Souls flashback since no casting is required between them. It might be complicated to set that up, but I believe whatever shenanigans we do to manage to cast the multiple instants necessary to set up a computation would also allow us to do this with an otherwise normal hyperstage transition.
So we can bring the stage creature back to hand through the transition when resolving it. That means we get an additional stage resource in the lower stage, going infinite.
Usually any Volutes below the mass sacrifice can't bounce anything because all copies of Cowardice have just been sacrificed. We can't use Wrong Turn to donate Cowardice, because to be targeted it needs to be a creature and then it bounces itself before it can get to the opponent.
I suppose we can also add "things that counter the Cowardice triggered ability" to the list of stuff that makes us go infinite. If we can get Cowardice into the library, then using Academy Rector for the start becomes unsafe for the same reason as Archon.
So I think another plan for gaining life out of the hyperstage transition is required. Maybe we need to use lands for the Tier 2 or 3 stage and two additional stages are too ambitious.
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.
Let me explain:
Say we have 1 Dralnu turning A to B, 2 Dralnus turningn B to C and 1 Dralnu turning C to A. Before the decision point we only have a creature of base type C. The C->A Dralnu will change the set of objects that the A->B Dralnu affects, so A->B is dependent on C->A. Then A->B changes what B->C affects, so there is another dependency. But B->C doesn't change what C->A affects, since there is only the 1 base type C creature and that is affected by C->A anyway. No dependency there, so there's no loop and the Dralnus get applied in dependency order. The C creature becomes a A,B,C creature and collects +4/+4 from all the Dralnus.
Then a token of base type A gets created. We still have A->B dependent on C->A and B->C dependent on A->B from before. But now the B->C Dralnu changes what objects the C->A Dralnu affects, because it gives the base B creature the type C. So C->A is now dependent on B->C and we have a loop. The Dralnus now get applied in timestamp order.
Say that timestamp order is A->B, B->C, then C-A. Now the base C creature becomes a A,C creature and only collects +2/+2 from the Dralnus. It gets another +1/+1 from sharing a creature type with the base A creature, that became a A,B,C. But that is still a net loss of 1 toughness.
It is then fairly straightforward to construct a computation that can use this toughness loss to halt at an arbitrary point. Just give the opponent the triggers to create an A token and a token that shares a type with the base C creature at the same time, while the C creature is 1 damage away from death. If they create the A token first, then the C creature dies, leading to a halt. If they create the other creature first then the extra buff keeps C alive through the toughness loss. And a few heartbeats later the base A creature can be dead, the C creature 1 damage away from dying again and the choice can repeat.
I don't quite recall why I decided to require that immediately shuffled vanilla in the program description, but now it is there. Maybe it will be useful if I at some point program in some alternate way to start the computation that we want to compare.
The type boar for that vanilla is certainly an irrelevant choice that doesn't matter and could lead to confusion. Sorry
The important part about that bishop is that it has 1 power when it is sacrificed and that it replaces itself with a vanilla Kavu, to give that last little push to the input.
Imo the 8 card hand should use Mishra's Workshop instead of Show and Tell. That is only so we don't give the opponent the opportunity to put something nasty into play. Not at all because I'm tired of using Show and Tell for the start
A high level overview of the 14 cards start-up computation could follow these lines:
We start by sacrificing a single, unbuffed Bishop of Wings to Soulblast and aim it at the Arcbond creature, so each arcbond tick will deal 1 damage.
After 3 ticks the starting Crab in the Input Heartbeat dies. Going forward a Crab will die almost every tick, since the crab replaces itself. A Crab dying also creates a Kavu, which buffs the arcbonded creature. The arcbond creature is now stable at 25 life and won't lose anymore unless this heartbeat is skipped.
After the next tick clock 1, 2 and 3 empty, creating a Cat, Ape and Frog. Thus they start the heartbeats for Clock 2, 3 and 4, which keep those clocks special creatures at a stable life, unless the corresponding heartbeat is skipped.
The program will end on its own once 25 input heartbeats are skipped, which causes the arcbonded creature to die.
To skip a beat of the input heartbeat we need to empty clock 4, i.e. reduce the life of the Horror to 0. This has two effects:
1. it skips a beat of the input heartbeat by creating a Crab*, thus reducing the arcbonded creatures life by 1
2. it recreates the Horror and Druids that make up clock 4, but now without damage. Since on most ticks in the past the heartbeat for clock 4 has created a druid to keep the life stable we now get a number of druids close to the number of arcbond ticks that have happened since the start. All the druids buff the toughness of the Horror and each other, so this time around the clock starts with "ticks since start" life.
So we need to empty clock 4 25 times, each time recreating it with bigger life.
To empty clock 4 when it has N life we need to skip the clock 4 heart beat N times. This is done by emptying clock 3.
Again, emptying clock 3 has two effects:
1. skip heartbeat of clock 4
2. recreate itself with "ticks since start" life
You see where this is going:
To empty clock 3 when it has N life we need to skip the clock 3 heart beat N times. This is done by emptying clock 2.
Emptying clock 2 has two effects:
1. skip heartbeat of clock 3
2. recreate itself with "ticks since start" life
To empty clock 2 when it has N life we need to skip the clock 2 heart beat N times. This is done by emptying clock 1.
Emptying clock 1 has two effects:
1. skip heartbeat of clock 2
2. recreate itself with "ticks since start" life. While it doesn't have a heartbeat that takes care of increasing this starting life it creates 2 Golems for every 1 that dies, which has the same effect.
Finally clock 1 doesn't have a heartbeat, so to empty it when it has N life we just need to wait N ticks. Doing that effectively doubles "ticks since start"
Put together we have a layer system with "ticks since start" as the output.
The input heartbeat clock also happens to produce 2 drakes per tick, which turns this output into output creatures as we go. Those also keep the vanillas that are still targeted by Audacious Swap alive.
There are a few things you could go into greater detail on. I'm not sure what level of brevity is appropriate.
- Skipping a heartbeat causes the heartbeat to be slower but more powerful. So instead of talking about clock N life it would be more accurate to talk about (clock N life - heartbeat N life)
- All the creatures of each clock die at the same time because the most damage creature dies and stops buffing the less damaged ones. The cascading toughness loss leaves no survivors. Technically this needs to be formally proven somewhere.
- The "ticks since start" life is not quite accurate. It's more like "ticks since start - number of times the heartbeat for this clock was skipped"
- There's probably more stuff about how clocks work that I can't think of right now because I just take it for granted, but which could require additional explanation or a proof that it does actually work like that.
I did some programming to pin down the damage for this 14 card deck a bit more. Those programs can be found on github. Here's what I figured out:
I found a way to write a waterfall program that runs a given n state, m symbol turing machine using 8+4m+mn clocks and a low number of bishops, under 13 per clock pair. That allows us to explicitly implement a universal turing machine. For example the 15 state, 2 symbol UTM by T. Neary and D. Woods takes roughly 14000 bishops. That UTM is the smallest I found for this conversion.
To simulate a TM using that UTM in MTG we would need roughly 2^(length(encoding(TM))) vanillas for the input. And the encoding(TM) that the UTM requires could be lengthy. But we can generate an initial batch of vanillas by programming the bishops to directly run the BB(15) champion instead of the UTM. Afterwards we can reprogram the bishops to run the UTM and have BB(15) vanillas to use for the input. That is enough to cover any losses from the encoding.
Restarting a computation after writing new input (and optionally reprogramming the bishops) requires casts of Scrambleverse, Arcbond, Artificial Evolution and Soulblast. So we need to resolve 8 Audacious Swap copies for each repetition of the BB computation. So we can roughly say that our final damage will be more than BB^X(15) when we get more than 8X+15000 Audacious Swap copies from the second Precursor Golem trigger.
To figure out how many golems we can get before the second trigger I wrote a simulator, that goes through a given boardstate step by step and can display the results. Obviously I can't run that for long enough to complete even a significant tetration. But the intermediate boardstates have convinced me that the small exponentiation and layer framework described by Deedlit11 works.
My initial concern was that there is some accumulation of vanillas in the heartbeat clocks everytime you stop them for a step. But while that does make them beat slower afterwards they also become correspondingly more powerful. That does make it annoying to formally prove the construction does what we expect, but it should still work. The decreasing variables of the layer sequence become (life(input)-life(heartbeat_input)) instead of the simple life(input) that we would have without the growing heartbeat.
With that construction we can squeeze a hexation out of the initial 53 Audations Swap casts. And since we can use all the bishops of that program as input as well it is even a pretty big one. I think we reach 2^^^^24 with this construction.
Here are the costs in Audacious Swap casts I get for that:
Description | Quantity | Price/Unit | LineTotal ---------------------------------------- | -------- | ---------- | --------- Replication Technique recovery | 1 | 1 | 1 Coat of Arms | 1 | 1 | 1 Free Vanilla (from start up) | 6 | 0 | 0 Vanilla | 6 | 1/3 | 2 Bishop of Wings | 25 | 1 | 25 Dralnu's Crusade | 4 | 1 | 4 Artificial Evolution on Dralnu's Crusade | 6 | 2 | 12 Artificial Evolution on all creatures | 1 | 1 | 1 Arcbond (from hand) | 1 | 0 | 0 Comeuppance | 1 | 1 | 1 Scrambleverse | 1 | 1 | 1 Soulblast (computation start) | 1 | 1 | 1 Scrambleverse (after computation) | 1 | 2 | 2 Soulblast (after computation) | 1 | 2 | 2 Total: 53The free Vanillas are the 5 Vanillas that are targeted by Audacious Swap copies, one of which gets exiled to cast Soulblast. The 6th free Vanilla is the target of the original Audacious Swap, that didn't get a copy targeting it. The program ensures that the 4 vanillas targeted by Audacious Swap survive the computation, along with a Bishop that turns the output into Golems. If I forgot anything that should be included in the costs please let me know.
Operations like -15000 and /8 just disappear in the rounding with numbers like 2^^^^24. So my conclusion is that this 14 card deck can deal more than BB^(2^^^^24)(15) damage.
The good news for Tier 3 stages is that the Tier 1 resource, triggers, gets cleared just by resolving the stack. But it is a problem when trying to get Tier 4 to work.
Regarding the infinite, it has been to long since I looked at the deck. I'd need to study it again to figure out if the infinite I had in mind back then actually works. If you can proof it is impossible that would be great! But getting this close to any infinite is risky, even if it currently doesn't work. If we miss any small implication anywhere when working on the rest of the deck, it will quickly blow up. Personally I wouldn't want to risk it.
Liquimetal Torque goes infinite by giving the opponent access to mana, which allows them to interrupt a computation: We Wrong Turn a few copies of Liquimetal Torque and a Soul Foundry with an imprinted creature while March of the Machines is out, then get rid of MoM and start the computation. After an arbitrary time the opponent activates the Foundry with mana from the Torques and gets an additional typed creature, which can lead to halting.
The type creature of Palladium Myr is the important part of the old card combo, since only creatures on our side of the battlefield can have haste from Emblem of the Warmind. So the opponent can't use it to gain mana.
I still count only two Saws for each Shapeshifter ability that is around when we cast the golem. And both of those Saws destroy 1 and create 2 creatures with the ability, whether it's an inverter or golem. I still don't see how you get the *3.
That would result in 512 shapeshifters instead of 9841. That should still be enough to beat grahams number though.
I had another run in with the "oracle text" on mtgsalvation. It says "Whenever another creature enters the battlefield, Unstable Shapeshifter becomes a copy of that creature and gains this ability." That would lead to the combo not working, since the Saw in Half copies of a shapeshifter that has become a copy of the golem or inverter would just be that golem or inverter. The shapeshifter ability would not be transferred to the new copies since it was only gained later.
Fortunately the actual gatherer text is "Whenever another creature enters the battlefield, Unstable Shapeshifter becomes a copy of that creature, except it has this ability." It gives the shapeshifter ability by modifying the copy effect with an "except", so the ability gets copied properly onto the Saw in Half copies.
So as far as I can tell the combo should work. That's an amazing build!
EDIT: Wait. How are we casting Boulderbranch Golem for the loop with Unstable Shapeshifter triggers on the stack? Or in combat?
So each Bishop copy costs 1 cast, each Dralnu's Crusade costs 1 cast + 2 per hack, so usually 5, but we can save a bit by making use of goblin/zombies. We need additional casts to hack all creatures (3?), get Coat of Arms (1), Arcbond (1?), Comeuppance (1), Soulblast (1), and Scrambleverse to give the setup to the opponent and get the output back (1+2). And all from only 53 casts (and I think there's a card in hand we could use?). That's pretty tight.
Adding a Dralnu's Crusade for the Heartbeat should work at least for the exponentiation part. I don't fully understand the tetration and additional layer parts yet.
Starting the computation again with bigger vanilla input might be helpful. After those small computations we then get a lot more casts. Hopefully we can manage to set up the universal turing machine with a fixed number of those casts and have the majority left over. Then we can use the remaining casts to get repeated Busy Beaver computation with the same trick, and wouldn't need to go to 15 cards for that ^^'
For 14 cards using a very small computations to get the numbers needed for the big computation should be doable.
I think skipping the small computation and casting Replication Technique 21 times instead would get us to ~2^^24 golems, so that would be our lower bound of what we can reach. IIRC that is a bit below the input sizes where we know how to implement a universal turing machine. So a computation that gets more layers would be preferred.
I'm not sure the constructions Deedlit11 gave work out completely, specifically:
We can't have both of those, or the heartbeat will accumulate more and more creatures.
The constructions are also probably not optimized for the situation we actually get here, where we can create and hack Bishops fairly easily but the Dralnu's crusades are very expensive. I plan to look into those small computations a bit more.
We can however do better by using the mana from the last two slaughter deaths to create Precursor Golems, instead of only the mana from the last one. The Salvaging Stations we could create on the second to last death only give us 6 mana back before we resolve the next precursor golem trigger or cast the next spell and in either case getting just one more golem beforehand is worth more than the additional salvaging stations. (Though to optimize we can create Salvaging Stations on the second to last death at the cost of effectively 1 mana, so we can use that to finish with 0 to 6 additional stations 0 mana)
I updated my spreadsheet with that play pattern. We end up with 25 Salvaging Stations, 19 Precursor Golems and 36 Golem Tokens before the second Precursor Golem trigger on Slaughter will resolve.
If that wasn't the case we could go infinite if we are able to set up a computation with multiple arcbonded creature, because the slight asymmetry of arcbond allows us to change the computation after an arbitrary time by changing the order of the arcbond triggers.
The trigger that is ours and goes on the stack before the opponent's triggers is actually the Arcbond trigger itself. We controlled arcbond when it resolved, so that trigger is ours, even when we don't control the arcbonded creature.
I noticed a problem with the Archon of Falling Stars plan: If we have a Spellweaver Volute trigger for a targeting instant on the top of the stack while we sacrifice everything to another Volute trigger on Kaervek's Spite then we can use an Archon trigger to bring Cowardice back to the battlefield. That would allow the lower Volute trigger to bounce the Armor Thrull if we have it donated to the opponent to survive the mass sacrifice.
We can get the two Volute triggers from the same Lingering Souls flashback since no casting is required between them. It might be complicated to set that up, but I believe whatever shenanigans we do to manage to cast the multiple instants necessary to set up a computation would also allow us to do this with an otherwise normal hyperstage transition.
So we can bring the stage creature back to hand through the transition when resolving it. That means we get an additional stage resource in the lower stage, going infinite.
Usually any Volutes below the mass sacrifice can't bounce anything because all copies of Cowardice have just been sacrificed. We can't use Wrong Turn to donate Cowardice, because to be targeted it needs to be a creature and then it bounces itself before it can get to the opponent.
I suppose we can also add "things that counter the Cowardice triggered ability" to the list of stuff that makes us go infinite. If we can get Cowardice into the library, then using Academy Rector for the start becomes unsafe for the same reason as Archon.
So I think another plan for gaining life out of the hyperstage transition is required. Maybe we need to use lands for the Tier 2 or 3 stage and two additional stages are too ambitious.