The Hydra Game - Numberphile 

Bonus: we get to see some extremely inefficient Python code

Calculating pi by killing a hydra

*Fast forward 3 month 14 days and 15 hours later

"I've calculated the answer for y=5 to within an error margin of about ten orders of magnitude, and that's close enough for me." The introduction of the Parker Hydra.

​@@IceMetalPunk, to be honest, the y=5 number has got to be so huge that being of by ten orders is not that bad.

Get Matt Parker to *WHAT* some inefficient Python!?

@@11Natrium Do not the python!

nah a spreadsheet will do

Python, Hydra, what's the difference....?

​@@jeremylakeman- ...the number of feet. 🤔😁

ikr. I think it's some kind of inside joke amongst university lecturers.

ok bro

Flashbacks to “this proof is trivial and is left as an exercise”

The "look at how smart I am you are inferior to me" stuff in university- all the posing in math- became quite clear to me off of those words. "The proof of this result is trivial." Then you look it up. It's complicated. Not only that but mathematicians had been trying to figure it out for YEARS before somebody came up with it and it was celebrated at the time as this great advance. And if there's an easy proof it sure doesn't use any of the machinery that existed at the time or any machinery someone in that class would have.

@@logstargo627 Damn, that sounds awful. At my uni "trivial" was only ever used for things that you could essentially demonstrate at a glance with a simple diagram. Also, anyone else here familiar with the The Proof Is Trivial website?

then you'll have what is known as an anhydrous hydra..

I applaud this joke. The best of mythical/mathematical dad jokes. I salute you, stranger on RU-vid. You are the champion.

De-hydra-ted. Yes.

Well done, very well done. Great joke.

I was never big on Greek mythology, but didn't he redirect a river to clean out the stables?

What does 'independent of peano arithmetic' mean please?

@@abigailcooling6604 I believe it means that you can proof it true or false in different models of Peano arithmetic, by adding axioms. Solely using Peano arithmetic is not enough to proof it either true or false. Like how the axiom of choice is independent of Zermelo-Fraenkel set theory.

by "subtree" you mean...? everything from the root to the level of the parent of the head you just shopped off?

Actually, you can choose any computable function f(n) and at each step you add f(n) copies of the subtree. It still ends. The proof is not very difficult, but you need ordinals for it. Proving that Peano arithmetics is not enough to conclude is difficult.

@@abigailcooling6604 I am not sure that 'independent of Peano arithmetic' is the accurate way to tell it, but what I think he means is that, in the case where you add to the grand-parent N copies of the subtree above the grand-parent, it has been proved that 1) the game always finishes, but 2) you CANNOT prove that the game always finishes using ONLY peano arithmetic. You need a more extensive theory to prove it, like ordinal numbers.

I knew someone would reference this!

There are weedkillers which consist of plant hormones that encourage growth of top part of plants. In the end roots can't support the metabolic demand of such, and plant dies.

mmmm hydra steak

A Hydra that follows physics and biology?😂

This is a mathematical hydra, nincompoop.

I would certainly not say no to a plushie of one of those heads.

I felt a tinge of sadness when the hydra died

Something about seeing all the heads blink in unison tickles my brain.

I liked the sound it made

too little horrifying to be "accurate", but adequate to an educational maths video

GET UP ON THE HYDRA'S BACK!

It's nice to know that I'm not actually alone.

​@@phiefer3My first thought

I think the squire with the fire is the most well known but I could be wrong It is fascinating how mythology changes over time though

He probably has a magical sword

yes, great video by Tony Padilla.

I need to know how it compares to those numbers.

We actually know a lot more about it than that but it's only in relation to other absurdly large numbers/fast growing series.

​@@miniropyeah isn't it funny how the Smosh guy is a genius mathematician

the hydra game grows alot slower than the TREE sequence

this is why I'm in the comments

​@@TomRocksMaths woah.. your profile picture needs a haircut dude!

The postage costs would be astronomical!

@@codahighland Won't the Postmaster Generals split the difference, or is that too soon?

@@codahighland The Hydra will pay for you

The interesting thing is that if you just chopped off the furthest layer each time, instead of the rightmost head, then it would be a significantly smaller number.

​@@michaelmurray6197Yeah, 48.

I also got 1114111 when calculating n=4 with a method I had that might be quite similar to yours, Where did you find the correct answer? Wikipedia had 1,3,37,>graham's number which was not the same function. I'd be keen to correspond more on that. I haven't looked at 5 yet but I don't think it's quite as big as you say, although it would be ridiculous (intuitively, I'm not actually certain)

I take it back, your size for n=5 makes more sense on some experimentation, but I'd be curious to hear how you got that value exactly

​@@evanfrench3040 can anyone share a code example or link on the head determination algorithm? I have a working code that got n=1,2,3 the same and after logging the operations n=4 seems logically consistent but produces 327,677 steps, and n=5 is bigger then 10^(10^( ...million more times.. .^(10^10)))) which I would write as 10 ^^ 1,000,000, after my code reached the max supported number I made an estimation using the growth pattern and would place n=5 around 10 ^^ 1,441,792. ( and n=6 would be around 10 ^^^ (10 ^^ 6,291,453) and yes that's 10 ^^ (10 ^^ (10 ^^ ... 10^^6,291,453 times)) )

I got 1114111 too

after some research it seems that: 1114111 is what you get if you cut at the lowest height with 2+ nodes or the highest if all 1. 327677 if you cut the highest with most nodes total. 720891 if you cut the lowest with most nodes total or highest if all 1.

Ah, i thought this was a remaster! I miss that channel

Yeah, I saw this is my recommendations like 2 or 3 times and thought it was a suggestion for that video so I didn't click it because I thought I had already seen it. Then I checked and lo and behold, actually a new one!

No one cares about "cuteness" in math.

@@Gordy-io8sb or battle!

Yeah it would have been nice to see him make a crack at it and see how far he can get...

I have discovered a truly marvellous proof for a lower bound for arbitrary d, which this comment is too small to contain.

I calculated that chopping the 2nd head of level 4 would been done at the step 22,539,988,369,407 but maybe I did something wrong. But it still pretty close to your number (for that magnitude).

Thank you for this, I started programming a Hydra game and the rules for cutting heads wasn't clear -- I ended up slaying the hydra much too quickly.

That Hydra would need to use a lot of toothpaste.

The old library in St Edmund Hall, Oxford. A bit scary at night.....

*examine table*

@@serversurfer6169 Nononono no, you're not drawing me into DMing a game in the comments section :)

@@marasmusine Fine... I cast Magic Missile!

I… cast… extremely… slow… Internet… on you all!

I wrote a super quick python script to see what would happen. It crashed around step 10^4300

That's wrong estimate. I have written a script and it estimates value to be above: 2^2^2^2^...^22539988369409, with height of this tower 22539988369407. Just one step of this tower is going to produce a number with 6.7*10^12 digits.

That only vaguely matches the numbers in the sequence, and we don't have enough information to verify that based on the sequence alone. Also, looking into it some more I've concluded that it actually seems to grow in hyperoperators - i.e. moving through exponentiation, tetration, pentation etc as d increases. Heads on each layer create loops at lower layers. These loops are n long - n being the number of heads cut off so far. This leads to loops of loops of loops of... etc... of successorship (cutting off a head from the root node) - which is how hyperoperators are defined, each as a repeated form of the previous.

@@newkobra Yeah, that seems right. A few people in the comments have got very similar answers. What does your script do btw? No way it's brute force.

@@alansmithee419 it possible to prove that if level_1 has only 1 node and on level_2 there are x nodes and you currently on step S, then you will get to the state with level_1 and level_2 having 1 node at step 2^(x-1)*(S+1) - 1. Using this equation it's very easy to write a script that will quickly decrease first two levels. In less than 10 iterations I got to the point where I had next number of nodes on each level 1, ~22*10^12, ~22*10^12, 0, 0. But using an equation after this point is impossible as I need to evaluate 2^(22*10^12) and this number has 6.7*10^12 number of digits. And this will just reset first two levels to one, after that we need to remove one head from level 3, and repeat but with this huge number instead.

negative infinitely amplyfying hydra heads, where you have to supply it with a hydra head to counterbalance a negative hydra head, but still having more negative hydra heads appear somewhere else on the negative hydra. Spooky.

4green

It looks like they just copied from Wikipedia

I also got this result

"Computable" is actually a rigorously defined mathematical term and yes, all of these numbers are computable in that sense. Doesn't necessarily mean they are computable in the sense that there is an actual computer that can spit them out ;)

I've thought about it some and I might've been wrong. This grows more like a power towers sequence. 1, 2^2, 3^3^3, 4^4^4^4, ... So it's not going to be just few thousand decimal digits, more like few trillions decimal digits. And the next one will have its amount of decimal digits being represented by a number with millions of digits.

@@DukeBG That doesn't really match the numbers in the sequence. Also, looking into it some more I've concluded that it actually seems to grow in hyperoperators - i.e. moving through exponentiation, tetration, pentation etc as d increases. Heads on each layer create loops at lower layers. These loops are n long - n being the number of heads cut off so far. This leads to loops of loops of loops of... etc... of successorship (cutting off a head from the root node) - which is how hyperoperators are defined, each as a repeated form of the previous.

@@alansmithee419 I'm not sure what you mean by matching, I'm using a subjective description of "this grows like". I would say hydra(5) might be between 3^3^3 and 4^4^4^4

@@DukeBG Well, they just don't line up at all so I don't know where you got this from. 1, 3, 11, 983038 1, 4, 7.6e12, 4^(1.4e154) These sequences are nothing alike?

True, but they have a very different view of what "right-most" means. You should at least get the 11 they get for 3, in your formula, before you try and change the rules.

I got the same (numerically, I didn't think about a function). As @kindlin points out, it's not the approach they took but I also noticed that they chose a clearly not optimized approach. But maybe it's because cutting off the rightmost head is less efficient that makes it blow up in a less predictable way and therefore makes it more interesting, I guess.

@@kindlin my hydra grows the heads to the left

@@uzqap to the left, to the left

slay

PBS Infinite, alongside Numberphile and 3Blue1Brown, were probably the biggest influences on me trying to get into learning maths more, so it's always nice when Numberphile makes me think "I'll go back and rewatch those!". Is a shame Infinite didn't hang around for two long, but there are so many great maths channels out there right now :D

What about TREE(3+3i)?

@@Gordy-io8sb I doubt it's defined for non-natural numbers.

@@alansmithee419 TREE(a)+TREE(b)i is a possibility, dimwit.

like tree sequence, this is also a graph theory problem

@@DarkestValar Category theory*

How did you come up with those formula? If the tetration is relatively small, a computer could handle it.

by my calculations (really inaccurate), if you were to develop a software for it and allocate the graph to RAM (where the node is defined as a set of memory adresses to its children) it'd take roughly 10 petabytes(10*1024TB) of ram (which still fits 64-bit architectures on a single computer)

@@kindlin I just followed my back-of-the-envelope model to count the steps. No formula for level 5 because there are too many terms to write it down.

@@peguera_eu You only need to store the step counter and the number of heads on each level to run the calculation. But i think even the step counter alone would be too big to store in a computer.

@@suan22 maybe it fits on an unsigned long/bigint btw I'm aware that you don't need a graph structure to make the calculation, I just wanted to state how big one'd be

Because the goal is to get the biggest number, not minimize the length of the game.

Isn't it much more interesting to see how fast the minimum length of the game grows, though? If I want to move 10 centimetres West and go East around the entire world to do so nobody's going to be impressed by how long it took me to move the 10 centimetres. Sure it's a big number but it's horribly inefficient, why would you ever want to do that?

you got me

Yeah I didn’t get this either. In the y=3 when they were chopping off heads from the root node, those nodes were not the rightmost in the way the hydra was drawn. So “rightmost” must be defined some other way.

Yeah I was also very confused by the definition of right-most. I'm assuming, since it's the simplest, that the rightmost is simply the most recently created node, and the root is the first node created, and that satisfies the video, but you're right that the y=3 example doesn't have enough heads in the early steps to make a determination between these interpretations of the rules.

@@patrickrobertshaw7020 I was thinking the same at first, but in that case it's not too hard to compute the numbers. Also, if my math is correct, y=4 will be about 500 steps, nowhere near what Tom said. Which made me think it's as described in my comment, as that pattern is way less predictable and should lead to bigger numbers too.

@@LeviATallaksen Hmm. Not so sure. I haven't done the numbers here, but intuitively you'll get the smallest numbers if you chop the higher depth heads as early as possible, that's because chopping a higher head with a higher n will scale the number of future heads needed to be chopped quicker. So you want to get that out of the way. This strategy, fully resolves a head and its creations before moving onto the next one, which should have incremented n as much as possible before moving to the next head at the same depth. The other interpretation allows for chopping higher heads sooner in the cycle

​@@patrickrobertshaw7020 yeah I think that's correct. And to clarify, it sounds like you must chop a head that is at the lowest level. So if there are heads at levels 2, 3, and 4, then you must chop the heads at level 2. Once you chop the head at level 2, you'll have heads at level 1, which then you must chop the heads at level 1 before moving back up to level 2

7:02 I think they specified that in this minute

You can think of it as the body of the hydra. Without any heads, the body dies.

no more edges to cut

I'm also confused why stumps become heads. It's kinda like 1 chop - 3 heads, which is against the rules

cause you can't chop off the root so even if it did turn into a head, it coudn't be chopped

That's basically what he did with the induction, but his method being a bit more mathematical subsequently gave him an algorithm which he used to derive the formula for the number of steps required.

​@@NikozBGI don't think that's true. The induction doesn't care about the structure. That's why it only gives an answer in the first case.

If your proof is not based on "pure logic", I don't think it counts as a proof ;) I don't think your intuition counts as "pure logic" though, especially since you state that the number of parents never increases, which is not actually true. And you didn't define "complexity" rigorously.

@@unvergebeneid Where exactly do I use "intuition"? And what about "number of parents" isn't rigorous? Your comment makes no sense.

@@NikozBG My point was, that you DON'T need math to prove it.

I tried it for y = 4, and if I did the math right it is 48 total cuts if you always chop off the highest most head. Y = 5 is 1179, assuming I didn't make a mistake here either. Thank you friend.

@@bebe8090 nice! I also got 48 for 4. It was so low I was worried I did something wrong, but seems not. It's amazing how much of a difference the order of things matters here.

I tried it and got 1114111 cuts. My logic is: Whichever leaf you cut, following it up with cutting "the rightmost leaf" will always work through all of the new leafs that have been produced by that cut, until you are left with your original tree minus the first leaf you cut. Let f(n,s) be the cost of cutting off a leaf at level n where s is the number of the cut. Then f(n,s) = 1 + f(n-1,s+1) + f(n-1,s+1+f(n-1,s+1)) + ... repeated s times Then you cut down the original tree by cutting an end leaf at level n (taking f(n,s) cuts), incrementing s by the number of cuts needed, and repeating with the next end leaf at level n-1

@@Matthew-eu4ps Mhm, I tried going with the following rule for "rightmost head": If one level has more heads than all the other levels, than the overall rightmost head is the rightmost head in this level. If there is a tie between levels, I go with the highest level. (Following the example in the original comment, step 19 would be [1, 34, 14])

I did the lowest available head in the tree and got the same result as you (which thinking about it it does seem we did the same thing by thinking about it in different ways). So I'm not sure. Maybe if they gave a source for the ~950,000 number.

Ah, okay. So I'm not the only one then. I also think 1114111 is a way more interesting result, simply due to the shape of the number itself. xP

Me too. I can't get 983038

Same here...

also get 1114111.

Yeah some others got 1114111 as well. Seems unlikely none of us would get it right. d=5 is interesting though. It is *very very big.*

I also got 1114111. Also I'm pretty sure 983038 cannot be correct, as the correct solution must be an odd number, I would be happy if someone could check my reasoning. Since we always chop of the newly generated heads next, the d=4 hydra will eventually become a d=2 hydra. Call the number of steps it took to get here m-1, then cutting the d=2 head is step m. Then this action spawns m new heads at d=1. There are now m+1 heads (m generated + 1 original) at d=1, which take m+1 steps to cut, after which we are finished. In total, this means, cutting all the heads took 2*m + 1 steps, which must be an odd number, regardless of m.

Thanks to Pete McPartlan

​@@numberphile You should make another video on the Buchholz Hydras, a more powerful version of the Kirby-Paris Hydras. It creates bigger numbers than even TREE(3)!

Yes, that was the result for that specific rule set. If you draw the heads a different way, that’s a different rule set.

I think "right most" actually was intended to mean "the right-most *lowest available* head." E.g. if you can cut off a head at the base of the hydra you must. In this case though the specifier "right-most" doesn't actually matter, so I'm not sure what they were doing.

I watched it again and they never mentioned a rule where the heads have to grow back to the right. Was that an actual rule that they accidentally omitted from the video?

@@SethLavender that's the only way I can see it working so I assume so.

@@karmachameleon326 but the drawing of the heads isn't specifically mentioned in the rules right? Just their starting node, not which side to draw them on?

Same here

Same.

You, I, and at least on other I've seen in the comments all got that result too for d=4. As for d=5, that seems incredibly small. I'm having a hard time articulating why but the number should be vastly larger than that. Remember each head on the grandchild of the root node (the one that gets 15 heads which leads into this exponential mess for d=4) will trigger an entire similar exponential back and forth between heads attached to the root node and heads attached to the root node's child. Only once that's over you will have to return to the root node's grandchild, cut off another head there, and then launch into another one of these exponential loops with >1000000 steps in it. Rinse repeat I guess a few dozen times (it will be bigger than the 15 that happened for d=4) and you get ridiculously big numbers. Edit: just have a look at it by hand by doing some of the initial steps, you'll soon see that not only are you going to get huge numbers but you're going to get them long before your tree even reduces to being smaller in depth than the d=4 case. Meaning you will eventually have something similar to the d=4 case, but starting with an n that is vastly larger than 1 (which is what we started with in the d=4 case).

@@alansmithee419 Exactly the problem can be solved recursively. Now it turns out actually that the formula applies always, when we have n hydra heads emerging from a parents node above the grandparents node, where when cut off the heads do not respawn. That being said one can apply the formula in between calculation steps, and predict at which step this entire set of hydra heads are cut of entirely, while leaving the main strain untouched. (you have to subtract 1 to actually end up at that step, where only the main strand is left, because otherwise you would have deleted another head an spawn a new one at respective positions.) Using this information one ends up with a configuration where one has 40 parents heads at step 39. plugging into the formula yields: 2^40*(39+2) -1.

@@alansmithee419 I also have it written down by hand, but maybe you might be able to cook up with the same solution. At least that would be great.

@@TobiliGames My point is that after you've done this (minus one step because you've skipped to the end) you will be left with a tree that is the same as the d=4 one, only you now have n=~2.25e13 as your starting point. This will continue to explode.

​@@TobiliGames I created a recursive solution similar to yours, but a bit different. I also get 1114111 for the d=4 case. However, my estimate for d=5 is vastly larger. Using a computer simulation, I determined, that it takes 22,539,988,369,406 (~2*10^13) steps until the d=5 case will turn into a d=4 graph. Then, cutting the d=4 node creates 22539988369407 (call this number m-1) d=3 nodes. The first d=3 node is removed in Step m, creating m d=2 nodes, we'll now look how many steps removing them takes. Step m+1: Remove first d=2 node, leaving (m-1) and creating (m+1) d=1 nodes. Step 2(m+1): All d=1 nodes removed. Step 2(m+1)+1: Remove next d=2 node, leaving (m-2) and creating 2(m+1)+1 d=1 nodes. Step 4(m+1)+2: All d=1 nodes removed again. Step 4(m+1)+3: Remove next d=2 node, etc.... repeat until no d=2 and d=1 nodes are left. We can see, that the steps where a d=2 node is removed follow the pattern: a(n) = 2^n*(m+2) - 1, when removing the nth node (starting at 0). This operation has to be repeated m-times and after removing the last d=1 nodes, one d=3 node can be removed (fits well into the sequence). So the step at which the next d=3 node is removed is a(m) = 2^m * (m+2) - 1. Removing this d=3 node now creates a(m) d=2 nodes, so we can again remove all these node, finding a new sequence for their steps: a2(n) = 2^n * (a(m)+2) - 1. Since we need to remove a node a(m) times, this results in removing the next d=3 node at step a2(a(m)) If we simply define a(n) to be 2^n*(n+2) - 1, this simplifies to a(a(m)). We now define a new sequence for the steps at which the d=3 nodes are removed, call it b(n). We know b(1) = m (by definition). By the last two steps, we see a pattern, that b(n) = a(b(n-1)). The last d=3 node will then be removed by step b(m-1). Computing a direct formula for b(n) is not simple, but we can find a lower bound for it by disregarding some terms. We can use the exponential ã(n) = 2^n as an approximation, as ã(n) < a(n) for n > 1. Using the exponential, we can see, that this lower bound for b(n) is just repeated exponentiation (a power tower), which we can write using Knuths arrow notation as b(n) > 2 ↑↑ n. So our total number of steps until all d=3 nodes are removed is at least 2 ↑↑ 22,539,988,369,406 Which is really a gigantic number

I implemented it in javascript with "rightmost" defined as at the highest step with most nodes total: it overflowed to infinity after reaching step 1.23e308 with [1.23e308, 4324378, 1441789] remaining, but after doing some abstract math estimations from there, and defining a notation for repeated exponent-first power called ^^ here and for example 3^^4 = 3^(3^(3^3)) I estimated n=5 to 2 ^^ 1441794.04 within 0.01 digit accuracy on the "super" exponent.

you can also define ^ as ^1, ^^ as ^2, and x ^n y = x ^n-1 ( y times total (x ^n-1 x)) these are repeated exponent-first powers of the previous order with these high operations and "highest step with most nodes total" logic, chopping all x hydra heads on any height n and below once equal can be estimated at once ! and have the rounded effect of increasing the step total from (2 ^n-1 y) to (2 ^n-1 y+x) its not perfectly accurate but would not deviate beyond less then a digit of the relevant exponent :) you can estimate until overflow in code and describe the remaining estimate steps as a nesting of the appropriate power functions for the remaining higher head heights and the value before overflow.

i think because the root doesn't have a parent, a leaf node (head) should always have parent

Yeah I got your values of 720891 and 327677. There is too much ambiguity

I also got 1114111, 327677, and 720891, depending on how "rightmost" is defined, and where new heads are growing (be it immediately right of the existing heads on that level, or further right than any currently existing leaf on any level). Poorly defined procedure indeed.

Same! I think wikipedia got it from a blog, and the blog is wrong :)

Holy cow, I got the same too! I am thinking maybe there's something wrong with how we define the "rightmost" leaf. The way I implement this is just by adding new leaves at the top of the queue. But apparently this is incorrect because the answer is not the same with the video

Many people in the comments have been reaching the same result, and no one seems to have any idea where the 983038 figure came from. Definitely seems to be wrong.

I disagree. There are countless mathematical analogies to objects that does not exhibit a fundamental property of that object. It's not the Herculean hydra but that doesn't mean it can't be a hydra in some sense.

What name would you suggest for when you cut something off and more of it comes back? Is an excellent choice if yoi ask me, they simply arent interested in the trivial case where it blows up to infinity.

​@@fatsquirrel75They could just go with the analogy of pruning a bramble bush. Snip one branch and 2 new ones pop up at the grandfather node a few days later. It's also a closer analogy to something that exists.

@@Marlosian , mathematicians like Greek mythology more than gardening, apparently. I like your idea, though. It sounds like a more fitting name.

​@@SgtSupaman Instead of hydra....kudzu?

with the logic of cut at the highest with most nodes total as "rightmost" I actually estimated y=5 pretty well ! but to describe it you need repeated power so I defined x ^^ y as x^(x^( ..y times total .. (x^x))) and with this I can write it down as 2 ^^ 1,441,794.04 and its accurate up to 0.01 of the "super" exponent.

Also for those curious, the size of y = 5 is a power tower of roughly 2.25 trillion 2s. So not at all computable

I guess i can see a slight resemblance, but they're actually very different in terms of which areas of math they are relevant to. The hydra game is about combinatorics and the proof that they will always eventually count down to 0 is not difficult. However, we have no idea whether the Collatz conjecture is true or not. Only that if there are counterexamples, they are so large that we can't find them on supercomputers. The d=5 hydra has too many steps to calculate (at least with brute force) on any supercomputer, but we still know it's finite.