The Comma Sequence is WILD..

The mathematical sequence that terminates after 2.1 million terms!
Presented by Robert Dougherty-Bliss from Rutgers/Dartmouth: rwdb.xyz/

[@yurenchu]

A few results: The _kill numbers_ are numbers after which the sequence dies; they don't have a possible successor in the Comma sequence. The kill numbers are (positive) integers of the form 'ab' , '9ab' , '99ab' , '999ab' , '9...9ab' (i.e. a non-negative amount of 9s, followed by 'ab') where digits a and b satisfy the equation a+b = 9 , and digit a ranges from 1 to 8 . The _branching numbers_ are numbers that have _two_ possible successors (the official rule then stipulates that the smaller of the two shall continue the sequence). The branching numbers smaller than 100 are 14, 33, 52, and 71; their possible successors are respectively {59 or 60}, {69 or 70}, {79 or 80} and {89 or 90}. The branching numbers of three or more digits are (positive) integers of the form 'aab' , 'a9ab' , 'a99ab' , 'a9...9ab' , where digits a and b follow the same conditions as with the kill numbers. The two possible successors of a branch number of three or more digits are of the form 'a9...99' and 'c0...00' (which is the digit 'a' followed by two or more 9s, or the digit 'c' followed by two or more 0s), where c = a+1 . There are 50 (positive) integers that don't have a possible precessor (not even a branching number as a possible precessor). These 50 integers are all smaller than 100 ; it can be shown that any positive integer of three or more digits has a possible (positive) precessor (potentially a branching number). The 50 positive integers without a possible (positive) precessor are: Set A1 = {21 , 31 , 32 , 41 , 42 , 43 , 51 , 52 , 53 , 54 , 62 , 63 , 64 , 65 , 74 , 75 , 76 , 86 , 87 , 98} Set A2 = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 , 25 , 26 , 27 , 28 , 29 , 30 , 37 , 38 , 39 , 40 , 49 , 50} These 50 starting numbers are forming 50 different Comma sequences, and produce 4 extra branches from branching numbers {14 , 33 , 52, 71} ; but 8 sequences/branches also die (at kill numbers {18 , 27 , 36 , 45 , 54 , 63 , 72 , 81}) before reaching and/or passing 100 . So 50 + 4 - 8 = 46 sequences enter between 100 and 1000. These 46 sequences then continue and produce 8 extra branches/sequences from branching numbers {118 , 227, 336, 445 , 544, 663, 772, 881}, but also 8 sequences die at kill numbers {918 , 927 , 936 , 945 , 954 , 963 , 972 , 981}, just short of reaching 1000 ; and so 46 sequences reach and/or pass 1000. And this continues between every 10^n and 10^(n+1), for any integer n ≥2 : 46 sequences continue after reaching/passing 10^n , producing 8 extra sequence branches from branch numbers {'19...918' , '29...927' , '39...936' , '49...945' , '59...954' , '69...963' , '79...972' , '89...981'} (which each time is shortly before the first digit changes, but the number of digits remains the same). But also 8 sequences die at kill numbers {'99...918' , '99...927' , '99...936' , '99...945' , '99...954' , '99...963' , '99...972' , '99...981'} , just short of reaching 10^(n+1) ; and so 46 sequences reach and/or pass 10^(n+1). The expected increment before a (large enough) term that has digit D as its first digit, is (45+D) . Similar results apply for other positional number representation systems with integer base w ≥ 2 (such as binary, octal, hexadecimal, etc.). Generally, in Comma sequences defined in base w representation, the number of kill numbers between w^n and w^(n+1) (for any integer n≥2) , which equals the number of branching numbers between w^n and w^(n+1) , is (w-2) . (This means that in the binary system, where w=2 , there are 0 kill numbers and also 0 branching numbers, and hence no sequence dies nor branches.) Furthermore, the number of sequences that reach and/or pass each w^n , is M(w) = [(w-1)w/2 + 1] = T(w-1)+1 (where T(k) is the k'th _triangle number_ : T(k) = k(k+1)/2 ). For w = 2, 3, 4, 5, 6, ... , this gives M(w) = 2 , 4 , 7 , 11 , 16 , 22 , ... (etc.) The two distinct Comma sequences defined in binary representation system have starting values 1₂ and 10₂ (= 2) , and in either sequence the increments are alternating between +1₂ and +11₂ (or +1 and +3 as represented in base ten), infinitely.

[@aidanhennessey5586]

This should be pinned

[@WoolyCow]

the lore goes deep...

[@Faroshkas]

Commenting for engagement

[@dibenp]

Nice! 👏

[@JynxSp0ck]

So if the rule is changed such that any branch can be chosen, is it possible to generate an infinite base 10 sequence?

[@johnchessant3012]

According to A330128, the comma sequence at 2 terminates after 194,697,747,222,394 terms!

[@realwermos]

Wow, how was that even calculated 🤔

[@shric_]

@@realwermos It's a small enough number that you could just calculate the whole sequence and you can discard the preceding terms.

[@realwermos]

@@shric_ calculating 194 trillion terms of a sequence is no joke, even on a supercomputer. Plus, I can't really think of any way to parallelize it.

[@realwermos]

And yet, the Python code on the OEIS page that was referred to, gives me the answer in less than 0.5s on my machine (Python 3.11.6). I'm baffled.

[@kuskus_th13]

and at 6, it dies after 209 quadrillion terms.

[@W.EdwinClark-gv7ik]

Oh my. I looked up the sequence in the OEIS and discovered that Dec 11, 2006 I apparently was the first to write a program to show that the sequence is finite when you start with 1. I don't recall the sequence at all!

[@mal2ksc]

Some problems truly are "fire and forget".

[@exoplanet11]

Thanks for sharing this. Such lapses happen to the best of us. Same thing happened in the math of Johannes Kepler when he was working out Mars' orbit.

[@KenLieck]

@@exoplanet11 Hell, I was watching a documentary recently and the narrator was telling an interesting story that I had never heard before -- or so I thought until they showed the person speaking and it was me!

[@maniamapper3202]

Wow that’s extremely rare

[@toast_recon]

This is one of the most impressive things i think one could say. "Oh yeah, interesting problem, forgot I solved it"

[@thomasrosebrough9062]

This is a genuinely fantastic explainer video that deserves a better camera and microphone.

[@StoicTheGeek]

Agree. The production is scuffed, but the ideas and script are spot on. Great video

[@jonatan01i]

I would rather have more such potato videos than less production level ones.

[@CrimsonFlameRTR]

Yeah, he's holding a mic, but I don't think they switched the mic. Seems like it's using the camera's mic.

[@ThomasKundera]

The hardware is likely good enough, what is missing is the skill to use it properly.

[@minamur]

it's fine

[@akaRicoSanchez]

For the lazy, the sequence dies at 99 999 945 because the next term can only start by 9 or 1 but both cases are invalid. 99 999 945 + 59 = 100 000 004. 99 999 945 + 51 = 99 999 996. It's a pretty odd sequence, because if I understand it correctly, the "kill numbers" appear in clusters: 18, 27, 36, 45, 54, 63, 72, 81 and then 918, 927, 936, 945, 954, 963, 972, 981 and then 9918, 9927, 9936, 9945, 9954, 9963, 9972, 9981, etc. The clusters become more and more distant from each other, but going through them unscathed I would guess is always roughly the same challenge as the step between two elements is always under 100.

[@realwermos]

Why are both cases invalid?

[@realwermos]

Wait, I'm stupid. I get it now. It's because the first digit isn't what we theorized it to be. But that's only the case for 100 000 004. What's wrong with 99 999 96?

[@Zheeraffa1]

@@realwermos I doesn't start with 1 after adding 51 to the previous term.

[@zanti4132]

​​​@@realwermosThe sequence can continue after your number by adding 61. The sequence killers are numbers with (a) all 9s in every position except the last two, (b) no 9s in the last two positions, (c) the last two positions by themselves are a multiple of 9. As for why these numbers end the sequence, if the last two digits are ab, where a + b = 9, then continuing the sequence becomes impossible only when you are about to cross the next power of 10. For example, if the number is 9999ab, adding b9 (i.e. the two-digit number with tens digit b and units digit 9) puts you over 10^6, but adding b1 keeps you under 10^6. These are the only numbers where this happens. So, any time the sequence manages to traverse the land mines when it gets to the numbers with leading 9s, it can coast along until it approaches the next multiple 10 and the leading 9s again come into play. When the sequence starts with 3, it hits 36 immediately and dies a quick death. Similarly, the sequence starting with 18 is stillborn, dying immediately.

[@realwermos]

@@Zheeraffa1 Ah right, I get it now. Thanks!

[@senororlando2]

@8:02 I’ve noticed this a lot, people who are PhD level in math can whizz through Nobel prize theories and break down unsolved conjectures but need as much time as the rest of us to add 47+24

[@markvwood2007]

I've always thought that mathematics was the high concepts and arithmetic was the basic functions. I suppose two different parts of your brain.

[@xenmaifirebringer552]

If adding 46 was exactly enough to get 70 (and thus 6X could be ruled out), I assummed it was obvious that 47 would yield 71, as it's just 1 more 😅 But you are right, he was probably focused in something deeper.

[@Wlerin7]

He probably could have arrived at the sum faster if he hadn't been trying to explain, yeah.

[@nekad2000]

It's sort of like saying a rocket engineer still needs to measure a gas mixture, he can't just eyeball it.

[@QuantumCurvature]

As someone with a PhD in Physics, I can confirm that this is true and also add some background to why it happens. Arithmetic is a completely separate skill from higher level mathematics, and proficiency at it is mostly dependent on repetition and memorization. For people who pursue advanced math or science, there comes a point in our training (usually second or third year of undergrad) where all of the math that we deal with on a day-to-day basis comes in the form of abstract symbol manipulation (algebra, calculus, etc.) and skill with actual numbers become rather unimportant. And so, we fall out of practice and our ability to calculate declines - bringing us back on par with the general populace, who never had that skill in the first place.

[@alexandersanchez9138]

At the end he says the 2-seeded sequence dies “between 2 and 2 million terms”, but he only checked the lower bound.

[@digama0]

And as a matter of fact the claim is false: according to the arxiv paper the sequence starting at 2 lasts much longer than 1, going for 194697747222394 terms before dying.

[@ramenandvitamins]

He said it goes on for at least three, which is between two and two million. His math checks out.

[@alexandersanchez9138]

@@ramenandvitamins I see; good point.

[@BillyViBritannia]

​@@ramenandvitaminsit's his next sentence which implies 2 million is an upper bound to the sequence's term count unless "it" refers to 3.

[@matthijshebly]

Sequences like this are fun for sure, but since they depend on base-10 digits, they do feel a bit arbitrary, less fundamental than sequences that do not.

[@peterhemmings2929]

I feel this quite strongly too. There's so much hidden computation that's implicit in working with base-10 representations of numbers - lots of modulo 10, or division-by-10-then-floor operations.

[@RandomBurfness]

Every sequence is arbitrary lol.

[@NoNameAtAll2]

you see it as arbitrary I see it as having 8 more sequences to analyze =)

[@matthijshebly]

@@RandomBurfness Of course not... E.g., the sequence of prime numbers is the same in any base, it doesn't depend on notation. It's fundamental.

[@thelesserknownmath]

The original paper of Angeline et al. (incl. Neil Sloane) considers other bases: arxiv.org/pdf/2401.14346

[@nbvehbectw5640]

Why haven't you explained why the sequence dies? I mean, it's not rocket science, I can do it myself. But it feels like the most interesting part, and simply skipping the explanation seems odd.

[@braybuss5379]

Are you wanting an explanation as to why the certain sequence dies or an explanation on why it lasts so long? To my knowledge there is no solution after 99999945 because we need to add 50 something. Our two options are 10000000_ or 9999999_, blank being the last digit. To get the 10000000_ option the number added would be 51, but that’s not large enough to add to make the first digit one, and 59 is too large to add to the sequence and keep a 9 as the leading digit. It may be hard to understand, so I may be able to clarify more later if needed lol

[@nbvehbectw5640]

@@braybuss5379 Thanks, but I've said "I can do it myself". It's the same reasoning I came to. The point of my comment was not to ask for explanation, but to express my opinion about weird structure of the video.

[@Quadratic4mula]

​@@nbvehbectw5640 Can you explain to me why 3,36 ... Doesn't continue? I'm sure there's an answer that's obvious to everyone else, but I couldn't catch on.

[@josepherhardt164]

I agree. I understand what's happening, but "the sequence dies" needs at least a definition. Does it end in a loop, like many Collatz Conjecture sequences, or do we get to the point where the next number in the sequence becomes impossible to create, what? That should have been covered in the video.

[@jesusthroughmary]

Agreed, it should definitely be part of the video

[@janMaja]

woah cool! the next question I'd have is what about a "nondeterministic" variant of this, where instead of choosing the smallest number at each step, we choose whichever possibility lets the sequence "survive" the longest. like, while 118 -> (+81=)199 under the usual definition, maybe (+82=)200 can keep going for more terms

[@Harlequin_3141]

Yeah I wonder how many "choices" you get for a given sequence and how quickly that explodes into a branching tree of possible choices to find the longest survivor.

[@RadicalCaveman]

Careful. Which sequence lasts longest isn't well-defined if these sequences themselves depend on what lasts longest.

[@janMaja]

@@RadicalCaveman my thoughts are - start with a tree, where each number has as children the possible next numbers; then, among the paths of max depth, choose the lexicographically earliest one (i.e. at each step choose whatever is the smallest next number that is on some path of max depth)

[@yurenchu]

Keep in mind that "going for more terms" doesn't necessarily mean reaching a higher end value, though. For example, the sequence starting with 5 goes on for less terms, but reaches a higher end number than the sequence that starts with 10 . Fun Fact #1 : Just as _kill numbers_ can be defined as positive integers that don't have a possible successor (= next term) in the Comma sequence, we can define _branch numbers_ as positive integers that have two possible successors in the Comma sequence. It turns out that _kill numbers_ and _branch numbers_ are somewhat related to each other. _Kill numbers_ are positive integers of the form 'ab' , '9ab' , '99ab' , '9...9ab' , where digits a and b satisfy the equation a+b = 9 , and digit a is ranging from 1 to 8 . _Branch numbers_ of three or more digits are positive integers of the form 'aab' , 'a9ab' , 'a99ab' , 'a9...9ab' , with the same conditions on digits a and b as in the defintion of kill numbers. The branch numbers of less than three digits are 14 , 33 , 52 , and 71 . If Y is an n-digit branch number and its last digit is b , then its two possible successors have the form 'a9...99' (which is the digit a followed by (n-1) 9s , where a = (9-b) ) and 'c0...00' (which is the digit c followed by (n-1) 0s , where c = (10-b) = (1+a) ). To each branch number, we can link a unique kill number: if Y is an n-digit branch number and its last digit is b , then X = Y + b * 10^(n-1) is an n-digit kill number. Note that for every integer n ≥ 3 , there are eight n-digit kill numbers and eight n-digit branch numbers. It could be interesting to investigate for which values of n , a branch of an n-digit branch number Y will later arrive at the n-digit kill number X in the Comma sequence. (By the way, these principles also extend to other integer number base representations. In the binary (= base 2) system, there are no kill numbers and _hence_ also no branch numbers (because if there existed a branch number, then we could also construct a kill number).) Fun Fact #2 : There are 50 positive integers that don't have a possible (positive) _precessor_ (in other words, there exists no positive integer than can precede any of these 50 positive integers in a Comma sequence). Each of them is smaller than 100 , because for any integer of three or more digits there exists a positive integer that can precede it. Every positive integer has at most one possible positive precessor. These 50 integers can only occur as a start number (in a Comma sequence with only positive terms). This means that there are 50 different _trees_ to consider. (By the way, for 30 of these integers there exists a possible non-positive precessor. 21 is the smallest of the twenty positive integers that have neither a _positive_ nor a _non-positive_ possible precessor.)

@@janMaja Just define things in terms of directed graphs, not sequences.

[@reidflemingworldstoughestm1394]

Amazing acoustics in that room. Perfect for the condenser mic.

[@Sonny_McMacsson]

I like it. It's reminiscent of a '90s video camera and the dude looks like he's from the early '90s and ready to attend a Grateful Dead concert. Total time warp for me.

[@jakemaranzatto6514]

glad to see your channel getting more recognition - keep up the good work!

[@alielhajj7769]

Let’s define a new sequence, where each term “a_n” is equal to the length of the comma sequence with initial condition “n”

[@Baumscheibenkunst]

That's the sequence A330128 in the online encyclopedia of integer sequences.

[@vdm942]

​@@Baumscheibenkunst 1→2137453 2→194697747222394 6→209534289952018960 40→2153441655319779164332 4000→195152998207833388640389 20000→192648330068920004741771823742285752 2296→2024 🔥🔥🔥

[@yurenchu]

a_18 = 1 a_27 = 1 a_36 = 1 a_45 = 1 a_54 = 1 a_63 = 1 a_72 = 1 a_81 = 1 a_918 = 1 a_927 = 1 a_936 = 1 a_945 = 1 a_954 = 1 a_963 = 1 a_972 = 1 a_981 = 1 a_9918 = a_9927 = a_9936 = a_9945 = a_9954 = a_9963 = a_9972 = a_9981 = 1 a_99918 = a_99927 = a_99936 = a_99945 = a_99954 = a_99963 = a_99972 = a_99981 = 1 a_3 = 2 a_15 = 2 a_819 = 2 a_838 = 2 a_857 = 2 a_876 = 2 a_895 = 2 a_914 = 2 a_933 = 2 a_952 = 2 a_9819 = a_9838 = a_9857 = a_9876 = a_9895 = a_9914 = a_9933 = a_9952 = 2 a_99819 = a_99838 = a_99857 = a_99876 = a_99895 = a_99914 = a_99933 = a_99952 = 2 a_801 = 3 a_830 = 3 a_759 = 3 a_788 = 3 a_817 = 3 a_855 = 3 a_884 = 3 a_913 = 3 a_9810 = 3 a_9739 = 3 a_9768 = 3 a_9797 = 3 a_9826 = 3 a_9855 = 3 a_9884 = 3 a_9913 = 3 a_99810 = a_99739 = a_99768 = a_99797 = a_99826 = a_99855 = a_99884 = a_99913 = 3

[@bioLarzen]

Great. Does this have any implication or practical application yet, or just plain interesting (which it undoubtedly is)?

[@yvonresplandy4217]

he forgot to explain why the sequence dies????

[@elijahbuscho7715]

There is no possible comma number. For 36, the comma number must have a 6 in the tens place, and then 6_ + 36 = either 9_ or 10_. So your candidate comma numbers are 69 and 61, but neither of them satisfy the rule. If we have 61 as the comma number, we get 36, 97 which means the comma number should be 69 which is a contradiction, so it fails. If we try 69 as the comma number, we get 36, 105 which means the comma number should be 61 which is another contradiction, so it fails too. You can work out why the 99999945 dies yourself

[@hits_different]

@@elijahbuscho7715sucks that the explanation is in the comments, since it’s the most interesting part about the sequence. I hope they do better next time

[@petrospaulos7736]

R.I.P Eric Angelini . Thank you for all these marvellous sequences!!!

[@chance1986]

This was interesting. I loved the closing comment about the number of terms for the 2-sequence. "We've done a good job at bounding it LOL." Great fun, thank you. And nice job.

[@RafaelSCalsaverini]

I managed to show that the sequence dies whenever it reaches a number whose last two digits are 18, 27, 36, 45, 54, 63, 72 or 81.

[@yurenchu]

That's not completely true. The sequence dies whenever it reaches a number whose last two digits are 18 , 27 , 36 , 45 , 54 , 63 , 72 , or 81 , and whose other digits (if there are any) are only 9s. So it dies after reaching (for example) 99918 ; but not after reaching 19918 (because then the sequence continues as 19918 , 19999 , 20091 , 20103 , etc.).

[@cooltaylor1015]

@@yurenchu so, multiples of 9?

[@yurenchu]

@@cooltaylor1015 ... and also not after reaching (for examples) 189918 , or 279918 , or 369918 , or 459918 , or 549918 , or 639918 , or 729918 , or 819918 , or 909918 , or 918918 , or 927918 , or 936918 , or 945918 , or 954918 , or 963918 , or 972918 , or 981918 , or 990918 , or 991818 , or 992718 , or 929718 , or 299718 , or 297918 , or 189927 , or 182736 etc. (even though these are all multiples of 9)

[@hershyfishman2929]

​@@cooltaylor1015only a tiny subset of multiples of 9

[@yurenchu]

​@@cooltaylor1015 189918 is a multiple of 9 , but it's not a _kill number_ . Likewise for (for example) 927918 , or 299718 , or 909972 , or 25236 , and a lotta bunch more.

[@sidkemp4672]

There are two things I'd like to see in this video. First, I wish you had shown what happens when you try to find a next term (say on the sequence beginning with 3) and you can't. How do you work out that you can't. Second, it was not mentioned that this sequence will be very different if we try bases other than Base 10. The Fibbonacci series remains the same actual values no matter what base we use to represent the numbers, but the comma sequence is dependent on the base being used. What would the comma sequence look like if we used binary? starting with zero, it's clear: 0, 0, 0 ... starting with one? Hmm

[@yurenchu]

_Binary_ base system: Each positive integer is contained in exactly one of two infinite Comma sequences: b₁(n) : 1 , 100 , 101 , 1000 , 1001 , 1100 , 1101 , 10000, 10001 , 10100 , 10101 , 11000 , 11001 , 11100 , ... b₂(n) : 10 , 11 , 110 , 111 , 1010 , 1011 , 1110 , 1111 , 10010 , 10011 , 10110 , 10111 , 11010 , 11011 , ... (Written in base ten representation, these two sequences are b₁(n) : 1 , 4 , 5 , 8 , 9 , 12 , 13 , ... , (4k , 4k+1) , ... b₂(n) : 2 , 3 , 6 , 7 , 10 , 11 , 14 , 15 , ... , (4k+2 , 4k+3) , ... ) In b₁(n), the increments are (+11 , +1 , +11 , +1 , +11 , +1 , ...) and in b₂(n), the increments are (+1 , +11 , +1 , +11 , +1 , +11 , ...) It can be shown that this pattern of alternating +1 and +11 (or +1 and +3 when written in base ten representation) goes on infinitely; and hence that neither sequence dies. Notice that b₁(n) = b₂(n) + 1 when n is even, and b₁(n) = b₂(n) - 1 when n is odd.

[@Bluhbear]

It would have been nice, but you can simply try and see why it won't work. Try adding 60-something to 36. You get 90-something or 100-something. Adding 69 gives 105, so that doesn't work. Adding 61 gives 97, so that doesn't work either. Basically, 9 is not equal to 1.

[@Quadratic4mula]

​@@Bluhbear Can you explain a little bit more about why 105 or 97 won't work... (I get the first part where you get a 90 something or a 100 something.)

[@Doeniz1]

I wonder two things: 1. How would this sequence play out in other bases? 2. If you add the following rule: Whenever you hit a dead end, go back to the last number that had two possible sucessors and take the larger one instead. Would the squence than be able to carry on forever?

[@rhaedas9085]

My gut feeling is that in bases with more than ten digits you'd have more flexibility to get past these dead ends, whereas lower bases would be more and more limiting and likely to die out fast. I do wonder the same thing as you about the branching, if a sequence can stay alive longer or forever if it uses all branches as a determinant.

[@yurenchu]

Not in every sequence would the final term have been preceded (somewhere earlier in the sequence) by a number that had two possible successors. For example, if we start with, say, the number 43, then the next term is 81 (because 43 + 38 = 81) and then the sequence dies (because 81 is a _kill number_ ); and there was no _branch number_ in the sequence. But for any n-digit kill number X greater than or equal to 54, we could calculate a _unique_ n-digit branch number Y by the following recipe: Y = X - d*10^(n-1) where integer d is the last digit of X . The two possible successors of Y are [(10-d)*10^(n-1) - 1] and [(10-d)*10^(n-1)] . So we could add a rule that when the sequence hits on a kill number X, then the following term is the larger possible successor of Y ; and that successor is (10-d)*10^(n-1) . With this rule, every Comma sequence would go on forever, except sequences that hit on the kill numbers 18 , 27 , 36 , and 45 . (Note: these four kill numbers don't have a (positive) possible precessor anyway, so they only occur in sequences of length 1, with themselves as start number _and_ end number. -- [CORRECTION: This note is not entirely true. 18 and 27 don't have a positive precessor, but 36 and 45 do have precessors: see the sequences [3 , 36] and [31, 45]. But in any way, these four kill numbers are part of very short Comma sequences. ] ) However, I don't know if with this rule some infinite sequences may get trapped in a cycle/loop: that after having leaped to (the larger successor of) the branch number, the sequence eventually arrives back at the same kill number.

[@clickaccept]

I would go further, and look at the tree with all branches from the start. Is there always an unbounded twig?

[@yurenchu]

​​​@@clickaccept There are 50 (positive) integers that don't have a (positive) possible precessor (i.e. there is no positive integer that could precede them, even if we consider numbers that have two possible successors). Each of them is less than 100; it is easily shown that every (positive) integer of three or more digits has a precessor. So that means there are 50 trees to consider. A researcher named Neil Sloane has figured out that 49 trees (out of these 50) die out eventually. Only the tree that starts with 20 has a branch that keeps going; however, it's not known (yet) which branch to choose at every branching point to keep on going. From the 50 trees/starting sequences, 4 die before reaching 100, so only 46 sequences reach and/or pass 100. From these 46 sequences, 8 branch into two branches (hence produce 8 additional branches) before passing 900 , so 54 branches/sequences pass 900 but then 8 branches die short of reaching 1000; so only 46 branches reach and/or pass 1000. And this process repeats in each interval [10^n , 10^(n+1)), for any integer n≥2 : 46 branches reach/pass 10^n , 8 additional branches are created before passing 9*10^n , but then 8 branches die short of reaching 10^(n+1) . That means that every positive integer can be traced back to one of the 50 integers that don't have a precessor, and (since 49 trees eventually die out) that every positive integer greater than some limit M, belongs to the tree that starts with 20 . So if we are allowed to choose whichever branch at every branching point (and start with 20 or another integer in its sequence), it is possible to have an infinite sequence. This means that the tree that starts with 20 has _at least one_ "unbounded twig".

[@PrinceOfKenya]

The sequences seem to fail whenever they hit a number of the form 10^n - 9m - 1 for n>=2 and m in [2,9], since the rollover to a new power of 10 causes a contradiction in the second digit of the comma number.

[@JohnDoe-ti2np]

At 4:26 when Robert started to write a single number using commas, I wondered whether there's a variation of the comma sequence that uses not only the commas separating successive numbers in the sequence, but also the commas that are used to write down numbers with more than three digits.

[@KazmirRunik]

A mathematical notation for the next term in the sequence without using modulo: f(n+1) = f(n) + 10*(f(n) - 10*floor(f(n)/10)) + floor(f(n+1) / 10^(floor(log10(f(n+1))))) Another little inquiry you could have is to find non-comma numbers: numbers that can't be reached from below using this method. Everything 1 to 9 is a given, but 10 can't be reached, either. 11 can be reached by 10, but 13 through 21 cannot be reached. 22 is reachable from 20, and so on. Even further, one can find anti-comma numbers, which terminate the sequence. For instance, there isn't a term that comes after 18, 19, or 27.

[@crowreligion]

110 comes after 19 as 19+91=110 So 19 is not a anti-comma number

[@CovidIslandDiscs]

Wow cool formula

[@jay31415]

Fascinating. What's the lowest number for whose comma sequence we're not sure is infinite or not? Also, I wonder if different base number systems lend themselves to a proof of infinite sequence. I imagine binary does.

[@yurenchu]

Regarding your second question: I'm not going to provide complete/formal proofs, but it can easily be shown that in the binary system and in the so-called _balanced ternary_ system, there are only infinite (= never-dying) Comma sequences. _Binary_ base system: Each positive integer is contained in exactly one of two infinite Comma sequences: b₁(n) : 1 , 100 , 101 , 1000 , 1001 , 1100 , 1101 , 10000, 10001 , 10100 , 10101 , 11000 , 11001 , 11100 , ... b₂(n) : 10 , 11 , 110 , 111 , 1010 , 1011 , 1110 , 1111 , 10010 , 10011 , 10110 , 10111 , 11010 , 11011 , ... (Written in base ten representation, these two sequences are b₁(n) : 1 , 4 , 5 , 8 , 9 , 12 , 13 , ... , (4k , 4k+1) , ... b₂(n) : 2 , 3 , 6 , 7 , 10 , 11 , 14 , 15 , ... , (4k+2 , 4k+3) , ... ) In b₁(n), the increments are (+11 , +1 , +11 , +1 , +11 , +1 , ...) and in b₂(n), the increments are (+1 , +11 , +1 , +11 , +1 , +11 , ...) It can be shown that this pattern of alternating +1 and +11 (or +1 and +3 when written in base ten representation) goes on infinitely; and hence that neither sequence dies. Notice that b₁(n) = b₂(n) + 1 when n is even, and b₁(n) = b₂(n) - 1 when n is odd. _Balanced ternary_ base system: The _balanced ternary_ base system is a base 3 representation system in which the three digits represent {0 , 1 , -1} (instead of {0, 1, 2}) . I'll be using the letter _h_ as the digit that represents (-1) . So, for example, the first ten non-negative integers [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9] are represented as [0 , 1 , 1h , 10 , 11 , 1hh , 1h0 , 1h1 , 10h , 100] ; and the first nine negative integers [-1 , -2 , -3 , -4 , -5 , -6 , -7 , -8 , -9] are represented as [h , h1 , h0 , hh , h11 , h10 , h1h , h01 , h00] . Each non-zero integer is contained in exactly one of three infinite Comma sequences t₁(n) , t₋₁(n) and t₂(n) : t₁(n) : 1 , 1hh , 10 , 11 , 10h , 1h0 , 1h1 , 11h , 100 , 101 , 1hhh , 110 , 111 , ... which is 1 , 5 , 3 , 4 , 8 , 6 , 7 , 11 , 9 , 10 , 14 , 12 , 13 , ... when written in base ten representation. This follows the "linearly" growing pattern 1 , (2+3) , 3 , 4 , (5+3) , 6 , 7 , (8+3) , 9 , 10 , (11+3) , 12 , 13 , ... ; it contains every integer > 2 , and it can be shown that this pattern continues forever. The increments follow the pattern (+11, +h1, +01) (or (+4, +(-2), +1) in base ten), which repeats and continues forever because every term is positive and therefore starts with a "1", so every increment ends in a "1", and hence the last digit of the terms in t₁(n) follows the repeating pattern (1 , h , 0 , 1 , h , 0 , ...) indefinitely. t₋₁(n) : h , h11 , h0 , hh , h01 , h10 , h1h , hh1 , h00 , h0h , h111 , hh0 , hhh , ... (which is -1 , -5 , -3 , -4 , -8 , -6 , -7 , -11 , -9 , -10 , -14 , -12 , -13 , ... when written in base ten representation) is the negative "mirror image" of t₁(n) : just replace every 1 by h , and _vice versa_ . It contains every integer < (-2) , and it also continues forever. t₂(n) : 1h , h1 , 1h , h1 , 1h , h1 , ... (which is 2 , -2 , 2 , -2 , 2 , -2 , ... when written in base ten representation) is an infinite cyclic pattern. The increments follow the ever-repeating pattern (+hh , +11 , +hh , +11 , ...) (which is (-4 , +4 , -4 , +4 , ...) in base ten). 0 can be followed either by 0 , or by 1 (hence continuing as t₁(n) ), or by h (hence continuing as t₋₁(n) ).

[@rogerkearns8094]

Trying other number bases than ten might be interesting. Btw, I nearly wrote ten as 10, there. Duhh! ;)

[@asheep7797]

Just ran a simulation! In base-2, this sequence never terminates, as: ...0 -> ...1, ...1 -> (...+2) In base-3, it terminates at 76 (2211) after 17 terms. In base-4, it stumbles right out of the door at 6 (12) after 2 terms. In base-5, it terminates at 15,612 (444422) after 1,259 terms. And this is where I realised that using Desmos was not a good idea for speed.

[@DeJay7]

Actually, "10" is ten as long as we consider base ten to be the default base, and we do. Unless stated otherwise, we commonly use subscripts (e.g. 101_2 = 5) to indicate number base.

[@rogerkearns8094]

@@DeJay7 That's true, but if I'd written _10,_ then I'd probably have got a comment, from someone else, also beginning with the word _Actually._ Cheers ;)

[@rogerkearns8094]

@@asheep7797 That's great, thanks. :)

[@DeJay7]

@@rogerkearns8094 I understand completely, you definitely have a point here. But now you know how to respond, or you can just not even respond since it usually isn't worth the effort.

[@gustavomeza9137]

In base 2, it never ends

[@stevewindisch2882]

The contrarian in me wants to prove you wrong, but I'm drunk and tired, so you win

[@bioLarzen]

According to the comment of johnchessant3012 a bit further up, "According to A330128, the comma sequence at 2 terminates after 194,697,747,222,394 terms!" I suggest a dance-off to determine which of you is right.

[@zmitter4844]

Lol you're right... just adding 11 and 01 back and forth for infinity

[@danielyuan9862]

​@@bioLarzenBase 2 is a different number system where the only digits are 0 and 1, and it never ends becuase you can guarantee that the first digit in every number is 1.

[@bioLarzen]

@@danielyuan9862 OK, I misunderstood it then, I thought he meant a sequence (in base 10) that starts with 2. My bad.

[@MgtowRubicon]

This is number base 10. I wonder if there is something special about the number base 10 for this sequence. Is there a similar sequence for other bases?

[@yurenchu]

We can play the Comma Sequence game in any (valid, integer) base. In binary (= base 2), all sequences go on forever. In ternary (= base 3), the numbers without a successor (i.e. the numbers after which the sequence directly dies) are 11₃ (= 4), 211₃ (= 22), 2211₃ (= 76), 22211₃ (= 238), 222211₃ (= 724), 2...211₃ (= (3^k - 5), for any integer k≥2 ). In general, for any integer base B (with B ≥ 3), the numbers without a successor in the Comma sequence defined in base B representation are (B^n - B^2 + (B-1)*k), for any integer n ≥ 2 , and integer k ranging from 2 to (B-1). So for any integer n ≥ 2 , there are exactly (B-2) numbers between B^(n-1) and B^n that don't have a successor.

[@papasalt8823]

Does the comma sequence exist in different bases? (dumb question but what about p-adics too lol, im not sure how that'd work though)

[@Kromaatikse]

It looks as though the danger point is when the choice is between two potential successors which carry from 9- to 1-. The potential comma increments are then x9 and x1 respectively. If x9 causes the carry into the leading digit (which implies that the sequence reached a value within 100 of a power of 10), but x1 does not cause the carry, then the sequence dies at that point.

[@berndmayer3984]

You cannot separate the members of a sequence with comas and at the same time use commas within a number to separate thousands. -- Use semicolons

[@Pseudify]

But that would necessitate changing the name of the sequence 😉.

[@caspianmaclean8122]

Use comma-space to separate numbers and comma without space to separate thousands

[@martinpenwald9475]

Or do like people in civilized countries and use dots for large numbers.

[@honza1859]

Hi, what about other number systems? And what about changing definition - when there is more than one possibility, definiction says to choose the smallest number - but what about choosing whatever number i want - can sequence last forever? Even if not i can get longer sequences in average - or not? Is there some list of numbers for which sequence dies immediatelly after these numbers in this list?

[@yurenchu]

"Other number systems"? You mean same (positional) number system but other base number, right? The results derived for this Comma sequence can be generalized for other (valid) integer base numbers. The numbers that don't have a _successor_ (in other words, there exists no integer that can follow them in the Comma sequence; the sequence "dies" directly after such a number) are numbers of the form (10^n - 10^2 + 9*k) , for any integer n greater than or equal to 2 , and integer k ranging from 2 to 9 . So once a sequence reaches such a number, the sequence dies; it cannot continue. In general, when defining the Comma sequence for the positional number representation in (integer) base B (with B>2), the numbers with no successors are (B^n - B^2 + (B-1)k) , for any integer n greater than or equal to 2 , and integer k ranging from 2 to (B-1) . For B=2 , which means in _binary_ representation, there are no numbers without a successor; every possible sequence goes on forever. A researcher named Neil Sloane has found that in base ten representation, if we use 20 (or one of its later successors in the sequence) as the start value and we are allowed to choose whichever successor when there are two possible successors to consider, then the possibility exists to continue (and increase) the sequence forever; however, it is not known (yet) how to choose which branch to take at every branching point.

[@honza1859]

@@yurenchu Thank you for a nice explanation. Btw - mentioned Neil Slone is the same person who is the author of OEIS?

[@yurenchu]

@@honza1859 I don't know for sure, but I think so, yes. There is another video on youtube where he presents these results (it's a video that's 50 minutes long). Any way, you're welcome! :-)

[@ThomasKundera]

@@yurenchu : Really thanks for your in deep answers to questions on that video. Fascinating.

[@hkayakh]

I gotta say, this is my new favorite sequence

[@MattBarrett-u9j]

This is interesting, but what is an application for it?

[@matthewhuxtable1557]

That was really interesting, thank you!

[@dootnoot6052]

the multiplicative comma sequence (in base 10 starting from 1) goes: 1, 11, 121, 1331, 14641, 161051, 1771561, 19487171, 233846052, 5846151300 [terminates at the 10th term] there are 2 possible branches: ... 1771561, 21258732, 531468300 [terminates at the 9th term] ... 233846052, 6079997352, 127679944392, 2808958776624, 115167309841584, 5182528942871280 [terminates at the 14th term] starting from 2, it goes: main branch: 2, 48, 3984, 163344, 7677168, 660236448, 56120098080 [terminates] second branch: 2, 48, 4032 [terminates] third branch: 2, 50 [terminates]

[@dootnoot6052]

the 10th term of the sequence starting at 9 is 14618805237461400, which loops forever (14618805237461400 × 01 = 14618805237461400) 14618805237461400 also branches to 14618805237461400 × 02 = 29237610474922800, which has no following number, so if you exclude looping branches, the 9 sequence terminates after 11 terms

[@yurenchu]

​​​​@@dootnoot6052 How could the 10th term be 14618805237461400 (which is a multiple of 100) if the last multiplication factor supposedly ended in the digit 1 (so 11 , 21 , 31 , ..., or 91)? What would have been the preceding term? According to my calculations, the 10th term of the multiplicative comma sequence starting with 9 , is 14618805237461376 , and hence the sequence continues and doesn't get stuck in a loop (at least not at the 10th term). - - - EDIT - Correction: After the 10th term 14618805237461376 , the sequence doesn't continue but _dies_ , because neither 68, 69 or 61 works out as a multiplication factor: 9 , 882 , 18522 , 444528 , 36895824 , 1512728784 , 69585524064 , 2922592010688 , 239652544876416 , 14618805237461376 . [dies] However, the multiplicative comma sequence starting with 9 has a branching at the 7th term, but the second branch dies after the 9th term: 9 , 882 , 18522 , 444528 , 36895824 , 1512728784 , 71098252848 , 6114449744928 , 519728228318880. [dies]

[@yurenchu]

​@@dootnoot6052 The 10th term of the multiplicative comma sequence starting with 9 is _not_ 14,618,805,237,461,400 but 14,618,805,237,461,376 ; after which the sequence dies. (There is also a branching at the 7th term, but that second branch dies after the 9th term.)

[@DrewsOnFirst]

The most amazing thing about this is seeing someone use a chalkboard today.

[@comic4relief]

Chalkboards are wonderful.

[@clarenceauerbach7934]

bro everyone uses a chalkboard in math studies

[@gordoncgregory]

Do you always get the same numbers and length of the sequence in other number bases?

[@yurenchu]

No. For example, in binary (= base 2), every positive integer is a member of either the sequence that starts with 1, or the sequence that starts with 2, and both sequences grow infinitely large, with increments of +1 and +3 alternating forever. In other words, every sequence is infnite.

[@its.skywalker]

I wish you didn’t record it from the side

[@rogerkearns8094]

Turn your device to compensate. ;)

[@matthewdodd1262]

For the lazy who don't care to do the math themselves, the 'conma number' that screws it up will flip flop between 59 and 51 due to how the sequence works. So it is defined to end at 99,999,945.

[@ThomasGiles]

How does a sequence die though? That’s a pretty important point right?

[@knotwilg3596]

You should really discuss the dependency on the base number. The fate of this sequence is more likely depending on that than on any intrinsic property of numbers In base 2 for example, the sequence will be a never ending alternating addition of 11 and (0)1, being 3 and 1 in common numbering. Proof to the reader :)

[@yurenchu]

This was a very basic (and very accessible) introduction to the principle of the Comma sequence. He didn't even discuss the pattern of _kill numbers_ (= numbers after which the Comma sequence dies), so why would he have included an analysis of the Comma sequence in other bases?

[@knotwilg3596]

@@yurenchu He shouldn't do anything of course, it's a free world. But to me it's very important to distinguish between properties of numbers and properties of their representation. To a mathematician or numberphile this distinction is obvious, to a novice it isn't. Fibonacci or Lucas series are independent of their representation, this series isn't. I find that a fundamental thing to mention. Cheers.

[@dccrowther]

I was hoping to find in the comments someone who, like me, doesn't get how this sequence is generated, but alas, everyone seems to get it but me.

[@vbregier]

Each number in the sequence determines its next number. Choice is done by looking at its decimal digits. The difference to next number is a 2-digits number. First digit (tens) is the last digit of the number, and second digit (units) is the leading digit of next number. In more formal words, given a number u_n, let d =u_n mod 10. u_{n+1} is the smallest integer of the form u_n + d×10 + k such that k = LD(u_{n+1}), where LD(x) is the leading digit of base-10 representation of x) This makes for 10 possible values of k, in practice only two values of k need to be considered : LD(u_n + d×10) and LD(u_n + d×10) + 1.

[@betanapallisandeepra]

Interesting 😊… thank you for sharing this

[@shadyparadox]

Whenever a math problem involves manipulating digits, the general problem to explore is what happens when you change the base.

[@philippenachtergal6077]

6:04 Hum, it seems that the sequence is very fragile whenever the number of digits increases (/could increase) and probably completely safe everywhere else ? (to be verified). If so, this makes it easier for some sequences to have much more terms than others since "passing one danger" multiples the number of terms in the sequence.

[@ericfielding668]

You can stick a 0 in front where the comma number is 01 to produce 1 as the second term

[@jay31415]

🤦

[@yurenchu]

You can do that with any start value that is a single-digit number. (And that even applies to the number representation in any base, not just base-10.)

[@lowhplowhp]

Great explanation! I wonder if any sequences terminate with an odd number of terms…

[@yurenchu]

The sequence starting with 1 ends with a total of 2,137,453 terms, and 2,137,453 is an odd number. In that sequence, 1 is followed by 12 . So the sequence that starts with 12 would end with a total of 2,137,452 terms, and 2,137,452 is an even number. See also list A330128 in the OEIS (On-line Encyclopedia of Integer Sequences), which gives the number of terms when a Comma sequence starts with 1, 2, 3, 4, 5, etc. as start value.

[@anthonyberthon4986]

Great salesman always starts with “Yes”😂😂

[@2_Elliot]

Numberphile at home: No honestly though great work guys 😂

[@theorixlux]

Thats pretty funny because i also die after 2 million terms

[@mattgsm]

Does it work in other bases? There must be a critical base

[@WilliamWizer]

the thing that interests me is not that the sequence dies but under what conditions it dies and why those conditions.

[@iskallman5706]

Some more interesting stuff : If any number's 2 last digits are a multiple of nine the sequence dies Yes the sequence for 1 has 2 million values but.. The sequence for two has one hundred trillion values, the one for 6 has two hundred quadrillion values, 40 has 2 sextillions. And taking a big step, the one for four hundred octogintillion has a 271 digits long number of values before it dies. For some reason the sequences starting with 4 x 10 to some power grow very large. All these results were obtained running python code and have absolutely no rigor whatsoever :) If you can somehow prove the first assertion or the fact that number starting with 4 and then some zeros grow very large, well first, big props to you and I would love to see a proof

[@chrisroberts1773]

That example starting with 3 confused me. 3 [Comma number 33] 36 (comma number 37) 73... What did I miss?

[@yurenchu]

3 is followed by 36 , because the last digit of '3' and the first digit of '36' form the increment _+33_ , and 3 _+ 33_ = 36 . 36 is followed by... no possible number. 36 cannot be followed by 73 , because that would require the increment to be _+37_ , but the last digit of '36' is not a '3', so the increment cannot start with '3'. (If 36 is followed by 73 , then the increment according to the Comma sequence would be _+67_ (last digit of '36' & first digit of '73') , but that wouldn't work out because 36 _+ 67_ = 103 , and not 73 .) If 36 is followed by a number N , then the increment must be formed from the combination of the last digit of '36' , which is '6' , and the first digit of N , which is yet unknown. Suppose the first digit of N is 'p' . So the increment would be +'6p' . The sum 36 + '6p' would be certainly greater than 90 ; therefore p, the first digit of N, might be a '9' . However, if the increment is +69 , then the sum would be 36 + 69 = 105 , which starts not with the digit '9' but with the digit '1' . So then the increment must be +61 , but then the sum would be 36 + 61 = 97 , which doesn't have '1' as its first digit. Therefore, neither of the possible increments work, and 36 has no follower in the sequence. So the sequence "dies".

[@radomaj]

​@@yurenchuN = 096, hope this helps

[@matthewcooke4011]

I don't see why - in theory - there couldn't be an infinite sequence for some seed. As has been pointed out in another post, there are certain clusters of numbers that kill the sequence - and these form a predictable pattern. I imagine that a certain sequence could fall into its own predictable pattern that could be shown to never hit one of the above numbers. Obvously, the fact that nobody has found such a sequence means that it's not that simple, but it's still conceivable that such a sequence exists - to me at least (though I haven't studied this at all).

[@landsgevaer]

I can prove that for any N, no matter how big, there is a sequence for some starting number with length bigger than N. 😉

[@yurenchu]

​​@@landsgevaer LOL! Yeah, that's rather trivial. If we start with 1*(10^k) as a starting number, with integer k > log_10(50*N) , then it takes more than N steps before the sequence reaches/passes 2*(10^k) .

[@landsgevaer]

@@yurenchu That sounds like a bit tight lower bound, but yeah.

[@ShivanshSharma]

3:26 Isn't there only one option for the second term? The first digit of the second term has to be 1. Because if we try 2, then the second term has to be 1 + 12 = 13 (And that would not work as the first digit of 13 is 1)

[@yurenchu]

I think what he means in the video is that when you try and start from the smallest possible digit as the second digit of the increment, and it works out, then you don't have to look for other possible solutions with a larger digit that also work out, because the rule says to pick the smallest solution/increment anyway.

[@PhilHibbs]

What does this sequence do in other number bases?

[@seedmole]

Seems like the answer (or whatever) behind all of this lies in modular mathematics and rings.

[@yurenchu]

LOL, I read your comment as "This seems like the answer behind all of _these lies_ in modular mathematics and rings."

[@jpopelish]

You say the sequence does, but you don't describe that death. My guess is, that no matter what possible alternative you choose for the second digit of the comma number, you will not get that same digit as the most significant digit of the resulting sum.

[@radomaj]

just say your next term is 09_, easy

[@yurenchu]

What I'd like to know, is: Does the set of 2.1 million numbers in this sequence follow Benford's Law?

[@landsgevaer]

No, says my back-of-the-envelope reasoning. The increment usually consists of the last digit of the previous number (which is typically fairly uniform 0..9) followed by its first (since that rarely changes). So the increment for big numbers starting with a 9 will only be about 20% bigger on average than those starting with a 1. Numbers starting with nine will thus be only moderately rarer than those starting with 1. For Benford, they should be around 6x as rare. That is far apart.

[@yurenchu]

@@landsgevaer Thank you for your reply, and for engaging in my question. Your logic looks sound to me, so I think your conclusion is correct. Among the numbers in the Comma sequence that starts with 1 (and dies at around 100,000,000), the number of leading 1s is at most 20% higher than the number of leading 9s, whereas according to Benford's Law, the number of leading 1s should be at least 6 times as much as the number of leading 9s. So we must conclude that these numbers do not follow Benford's Law. Inspired by your analysis, I've made some calculations on the back-of-a-bit-larger-envelope. It seems that in the Comma sequence, the average increment before a number that starts with digit D , is (45+D) (because the increment is (10*B + D) , where digit B is uniformly distributed from 0 to 9); hence the frequency of numbers with leading digit D is proportional to 1/(45+D) . Again, thanks a lot for solving my question! :-)

[@anon5334]

2137k terms. That's not accidental. This should be named Pope's sequence

[@martind2520]

Surely if you start with 0 as the seed the sequence is clearly infinite.

[@abderrahim552]

1 5:55 why does it does, like it could simply go to 72, did I miss something 2 what is the point of it, like what do we earn from this

[@yurenchu]

The comma number between 36 and 72 would be 67 ("6" is the last digit of the preceding term, "7" is the first digit of the next term). But does 36 + 67 = 72 ? I don't think so. You earn from this the same thing that you earn from pretty much any other youtube video: nothing.

[@campbellmorrison8540]

Never heard of it, wonderful discovery, that should keep a computer going for a while unless you start with 3 :) Its almost like numerology in some respects, I wonder if it goes negative

[@abuzarov]

It appears that the further you go in a sequence, the less likely it becomes that you won't be able to find the next element. Past certain point, the next comma number will almost always have the format of (LAST DIGIT OF THE LAST ELEMENT, FIRST NUMBER OF THE LAST ELEMENT)

[@radomaj]

36 supposedly "dies", BUT 36 + 6_ reasoning is that it's between 96 and 105 and then 36+61 leads to 9_, a contradiction, or 36 + 69 leads to a 1__ a contradiction BUT if we add a rule that since the next number is either 9 or 1,we could say we gotta treat both as three digits so it's 1__ or it's 09_ and then 36+60=096 and we're fine GG EZ, next question

[@yurenchu]

Yeah, but then we'd lose the property that each positive integer has at most one possible (positive) precessor. 96 is already preceded by 17 : 17 , 96 , 157 , 229 , ... (etc.) Furthermore, such a rule would change the successor of numbers of the form '9...909' : for example the number 909 would then have the increment +90 instead of +91 , and hence have the "official" successor 0999 instead of 1000 (while 999 already has the precessor 990 ; so now it has two possible precessors). (And as a result, numbers of the form '9...909' would become a _branching number_ too, just like '19...918' , '29...927' , '39...936' , '49...945' etc.) The fact that multiple numbers now have the same successor leads to the question if every two distinct sequences eventually reach the same term. So there is your next question.

[@leefisher6366]

Confused. Isn't 10^(100/12) the same as 10^(25/3); and if so, why not reduce it? If not... I mean the way he wrote it clearly isn't intended to mean a twelfth of 10^100, is it?

[@khoross311]

You might not reduce a fraction like that if the numbers in it are meaningful, to leave an idea of where it came from. Here, the 100/12 is based on the fact that you can only die in specific danger zones immediately before each power of 10, and these are 12 of the 100 numbers before each power of 10. So if we pretend a sequence will pick one of these 100 values to land on at random each time, we would see 100/12 powers of 10 on average (so average value 10^(100/12)).

[@leefisher6366]

@@khoross311 Thanks for the explanation. This makes sense now.

[@yurenchu]

​@@khoross311 Which are the twelve numbers? Another comment mentioned clusters, but each cluster contains only eight numbers (for example, {18, 27, 36, 45, 54, 63, 72, 81}, or {918, 927, 936, 945, 954, 963, 972, 981}, or {9918, 9927, 9936, 9945, 9954, 9963, 9972, 9981} etc.)

[@lennartbjorksten707]

This is what you get when mathematicians have way too much time on their hands. 😛

[@jackalrd2209]

Good heuristic, I always want

[@philrobson7976]

The first 4 differences are primes. Can you keep going?

[@artemirrlazaris7406]

The question of the terms is basically how long does the chain of numbers linking work before it breaks and there would be a predictor of that; however, one break in the china, can you make a supposition of the number starting but I guess that would require another rule, Since you would have to predict a linked term in a now broken cycle...hmm without its predecessor..

[@kro_me]

The sequence roughly follows a{n+1}=11•a{n}-100•floor(a{n}/10) as that is what would describe it if you didn’t include the first number of the next term each time (which is negligible in the greater picture)

[@kro_me]

It also works in other bases :3

[@landsgevaer]

So a(n+1) is bigger than 11 times a(n)? I think not. You seem to misunderstanding the recipe.

[@kro_me]

⁠@@landsgevaerapologies it is supposed to be - not +, corrected

[@kro_me]

In general it would be (b+1)x-b^{2}floor(x/b) for base b btw

[@landsgevaer]

@@kro_me Okay, x-b*floor(x/b) would extract the last digit. You multiply that by b and add it to x. Checks out. That only misses the contribution of the first digit of the next number, which is usually simply the first digit of the previous number, on average slightly smaller than (b-1)/2. That is about 10% of the increment itself, not entirely negligible perhaps. But I get it.

[@cookiecrumbles2948]

Why don’t you change the camera angle

[@joemyk]

This type of sequences simply dies eventually due to the limitations of the numeral system it relies on (in this case, the decimal system)

[@yurenchu]

What "limitations"? For a Comma sequence defined in a standard positional numeral representation with base B , with integer B ≥ 2 , there are always (B-2) numbers between B^(n-1) and B^n without a possible successor, for _every_ integer n ≥ 2 . Can you predict for which values of B > 2 there exists (or doesn't exist) an infinite sequence, under the "official" rule that if a term has two possible successors, the smaller one is chosen?

[@whoeveriam0iam14222]

You should clean the cleaning block better so you don't leave those blocky streaks

[@phlanxsmurf]

So we're getting pretty good at bounding it. Legit LoL

[@GillAndBurtTheCop]

The thing about this is that it heavily depends on base set number

[@yurenchu]

The key principles are also applicable to other valid (integer) base numbers. For example, in the video's Comma sequence (which is defined for base ten representation), the numbers without a successor (i.e. the numbers after which the sequence "dies") are X(n,k) = (10^n - 10^2 + 9*k) , for any integer n≥2 , and integer k ranging from 2 to 9 . For any n≥2 , there are (10-2) = 8 such "kill numbers" between 10^(n-1) and 10^n . But in general, for the Comma sequence defined for any valid integer base B representation, there are (B-2) "kill numbers" (= numbers without a successor) between B^(n-1) and B^n , for any integer n≥2 . That means that for the Comma sequence in _binary_ representation (B=2), there are 0 "kill numbers", and hence in binary all Comma sequences never die, they go on forever. For integer B≥3 , the numbers without a successor are X(n,k) = (B^n - B^2 + k*(B-1)) , for any integer n≥2 and for integer k ranging from 2 to (B-1) . Note the analogy with the formula for base ten representation. This is just an example, there are more features that can be generalized.

[@GillAndBurtTheCop]

@@yurenchu thank you for the extrapolation, yes! Binary is cool like that, and for a couple other reasons. I have a thing I worked on and binary ended up being the thing I needed to see to blow the whole thing wide open. Might make a video on my findings

[@eyemaster3.14]

I wonder if interesting paterns may form if we use a base other than ten. Somebody else (@akaRicoSanchez) computed a number of "kill numbers," which all seem to be divisible by nine, one less than the base in base ten. Given that this sequence is dependent upon a particular digit in each number, a change base would effect the sequence, and I find it likely that the fact that kill numbers are all divisible by one less than the base is not a coincidence. That said, I'm unsure of the actual correlation.

[@j.thomas1420]

Very nice!

[@tamirerez2547]

Not sure about the position of the camera.

[@romanbushek7200]

That mic is NOT working

[@tomholroyd7519]

Clearly you need to do this in base 16 now.

[@noahblack914]

I think this is missing an explanation of why the sequences die. You say they do, and can do so at arbitrary sizes, but don't actually demonstrate why the next term can't be generated. Granted, I did enjoy reasoning it out myself. But surely it should be part of the explanation.

[@yellstr]

If you do it in binary numbers instead of decimal, it goes on forever.

[@skyjumper4097]

why do the sequences "die"?

[@yurenchu]

Because there exists no integer that would satisfy "the rules of the game" to continue the sequence. The "rules of the game" are that the so-called _comma number_ , which is the increment between two consecutive terms, must be a two-digit (positive) integer whose first digit equals the last digit of the preceding term, and whose last digit equals the first digit of the next term. ("Increment" means how much must be added to a term in order to get the next term.)

[@hassanalihusseini1717]

Can there be an infinite sequence? (Base 10)

[@landsgevaer]

I bet not. However, for any n, there are sequences longer than n.

[@johnmckown1267]

Seems like the numbers in the sequence are dependant on base 10 representation written with the digits written left to right.

[@yurenchu]

You can do this with positional number representations in other (valid) integer bases. Sure, the actual numbers in a sequence will be different, but key principles of how these sequences behave will stil hold. For example, in base B , for any integer n greater than or equal to 2 , there will be (B-2) so-called _kill numbers_ (= numbers with no successor) and also (B-2) so-called _branching numbers_ (= numbers with two possible successors) between B^n and B^(n+1) . The kill numbers will be X[n,k] = B^(n+1) - B^2 + k*(B-1) , and the branching numbers will be Y[n,k] = X[n,k] - (B-k)*B^n , for integer k ranging from 2 to (B-1) . (There are also (B-2) kill numbers smaller than B^2 , but not each of them can be linked to a branching number less than B^2 .)

[@johnmckown1267]

@@yurenchu It's interesting. The stuff I liked in my math courses in college, long ago. Does it have any use? The Fibonacci sequence was mentioned & it turned out to be in nature. Just curious.

[@yurenchu]

@@johnmckown1267 The Comma sequence is new to me too (this video is my first encounter with it), so I don't know of any practical uses or natural occurrences. However, I wouldn't be surprised if it can be used in Cryptography to encrypt/decrypt blocks of data. (Creating a comma-sequence from a certain starting number and determining the kill number at which it ends, is (as far as I can tell) possibly a bit more difficult than tracing a kill number back to its (smallest possible) starting number.)

[@tmwtpbrent14]

It's not that surprising for these sequences to be finite. It's just an equation that has a finite number of solutions.

[@yurenchu]

What equation? By the way, an equation with a finite number of solutions could also be associated with an infinitely repeated cycle of a finite set of numbers. This is for example the case in the Collatz conjecture (a.k.a. the 3n+1 problem): the sequence -5 , -14 , -7 , -20 , -10 , -5 , -14 , -7 , -20 , -10 , -5 , -14 , ... is an infinite loop of a cycle of just five different integers, which are the five solutions to the equation : n = T(T(T(T(T(n))))) where T(n) := (3n+1) when n is odd, and T(n) := n/2 when n is even. (Or more "succinctly" put: T(n) := (1.75n + 0.5) - (1.25n + 0.5)*cos(nπ) , for any integer n .)

[@mab9316]

Brilliant

[@HeinrichDixon]

I love how so many mathematicians are TERRIBLE at arithmetic! LOL. 🍌😂

[@BsktImp]

Is this possible in binary?

[@antoniusnies-komponistpian2172]

Yes, it's adding 11 and 01 alternately forever

[@uriituw]

Crazy.

[@the1exnay]

10^(100/12) seems an odd way to write that. Why not 10^(25/3)?

[@yurenchu]

Someone by the screenname @leefisher6366 posted the same question 2 weeks ago, and received a reply; you may want to check that out.

[@joemaffei]

@numberphile It would be great to have Neil Sloane do a video on this sequence.

[@the1exnay]

In base 2, none of the comma sequences ever terminate.

[@yurenchu]

In base 2 , each positive integer is a member of either the sequence that starts with 1 , or the sequence that starts with 2 . The sequence that starts with 1 : [1 , 4 , 5 , 8 , 9 , 12 , 13 , 16 , 17 , ...] consists of the (positive) integers that can be written as 4k and 4k+1, for some integer k ; the sequence that starts with 2 : [2 , 3 , 6 , 7 , 10 , 11 , 14 , 15 , 18 , ...] consists of the (positive) integers that can be written as 4k+2 and 4k+3 , for some integer k . In either sequence, the increments (= difference between consecutive terms) are forever alternating between +1 and +3 .

[@BKNeifert]

1, 12, 35, 94, 135, 186, (248)

[@Merkuse]

Крипер2004 ?

[@deleted-something]

wow

[@lunafoxfire]

neat!

[@ophello]

My dude, you didnt explain why it dies when you start with 3….

[@figboot]

I thought it was pretty obvious. Try to come up with the next digit: 3, 36, then 36 + 6X, which is either 9X or 10X. 36+69 causes a carry, and 36+61 is less than 100. So there is no comma number that works.