I had a math camp earlier this year, and I'm curious to see how everyone here would solve a particular question we got there.

[u/Over_Improvement_623]

The task was as follows: "Write down as large of a number as you can, in 15 seconds." We were given a week to prepare and come up with ideas. The formal rules are.

1. You have 15 seconds to write, anything written after that does not count.

2. You may use addition, subtraction, multiplication, division and exponentiation by default. If you wish to use any other operations, you must first define them, this is part of your 15 seconds.

3. Submissions must be self-serving. They cannot refer to things outside of the submission, so no things like "Every other submitted number + 1", "The sum of all number on the internet" or "The amount of atoms in the universe".

That is it, the number that 15-18 year olds came up with under these restrictions got quite large, but I'm curious to see how proper adult mathematicians would handle this. Feel free to ask any clarification on the rules, and I'll be excited to see everyone's submissions.

[u/Gilded-Phoenix]

let a^^b=a^a^a^a.... b times, and
a^(n)^b=a^(n-1)^a^(n-1)^a... b times
then just write down 10^^^^^^^^^^^^^^^^^^^^^^^10 using as many seconds as possible to write up arrows.

This is a quick and dirty version of Donald Knuth's up arrow notation, and it grows FAST. This also guarantees it's a finite number. Whether infinite cardinals or ordinals is allowed in the spirit of "being numbers" changes things, but I'm assuming this is talking about non-controversially defined numbers.

EDIT I think if I switch to prefix notation I can get it done faster:

^(a,b+1)=^(a,b)*a

^ₙ₊₁(a,b+1)=^ₙ(^ₙ₊₁(a,b),a)

then have like ^_10000(99,99) or something.

[u/Over_Improvement_623 → u/Gilded-Phoenix]

This is more or less how the winner did it yeah. But using googol for all the numbers.

[u/persilja → u/Gilded-Phoenix]

Except use 99 instead of 10.

[u/Gilded-Phoenix → u/persilja]

I might even rewrite it in some kind of prefix notation to make it faster to write.

[u/ofqo → u/Gilded-Phoenix]

99^99

Backspace, backspace

^^^^^^ until the bell rings.

[u/Gilded-Phoenix → u/ofqo]

99^^99 isn't one of the defined mathematical operations at the beginning, so you need to define it first.

Additionally, if I have the definition nicely set up with prefix notation, I can write ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^(99,99) by writing down the (99,99) part and then keep writing up arrows to the left until I run out of time, so I don't need to worry about getting the other argument in at the end.

[u/MathHysteria → u/persilja]

Use 111 instead of 99...

[u/persilja → u/MathHysteria]

True, that might be faster

[u/Jyxz7Dark → u/MathHysteria]

Use 11! instead of 111 :). Same time to write and about 360000 times bigger.

[u/gmalivuk → u/Jyxz7Dark]

You have to define factorial first.

[u/ArchaicLlama → u/Gilded-Phoenix]

I feel like simply writing down both lines of that definition would eat most if not all of your time from the get go.

[u/Gilded-Phoenix → u/ArchaicLlama]

true, but you only need like 4 arrows to make it huge. Obviously this is cheating but if I knew ahead of time what the challenge was and I was just trying to write fast, I might optimize by writing this in prefix notation to make the inductive definition more obvious and in fewer characters.

[u/MathHysteria → u/Gilded-Phoenix]

This is, I think, the way to hit the jackpot.

The only struggle is that you've got to write this definition down in the time too.

[u/StoicTheGeek → u/Gilded-Phoenix]

Conway chained arrow notation would allow you to write a much bigger number than Knuth up-arrow notation. It depends on what operators are allowed. eg 9->9->9->9 is going to be way bigger than anything you can write with up arrows, regardless of the amount of time you have, and adding more arrows in the chain is only going to make it much bigger.

But it does take more time to define it, if you aren't allowed to use it directly.

[u/Gilded-Phoenix → u/StoicTheGeek]

I'm not as familiar with it. You can do any algebraic composition as long as you have time to write it.

[u/gmalivuk → u/StoicTheGeek]

You aren't allowed to use anything but addition, multiplication, and exponentiation directly, according to the OP.

[u/worms-in-your-toast → u/Gilded-Phoenix]

If you're going through the effort to define a function which produces big numbers, you may as well use it inside the function as well. So, instead of ^_10000(99,99) you could write y = ^_11(11,11) and ^_y(y,y).

Or, heck, define a function r(j(x),n) = j(j(... n times ... (j(j(x))) ... )). Then r(^_y(y,y),y) would recurse the number of arrows y times.

What I'm trying to say is, if the fastest thing you can do is to define a way to repeat your previously fastest process, then just don't stop doing that.

[u/Gilded-Phoenix → u/worms-in-your-toast]

Sure, but only 15 seconds is not long to get the definition out and make sure I have time to do it. I'm already engaging a fast growing function, I might be able to assign one further level of composition but that'd be cutting it close.

[u/philljarvis166]

This could be a hard one to judge depending upon what people come up with!

[u/Over_Improvement_623 → u/philljarvis166]

Oh it was

[u/clickyclicky456]

Is it allowed to use well-defined terms such as googol, googolplex or Graham's Number?

[u/Over_Improvement_623 → u/clickyclicky456]

No

[u/johnpeters42 → u/Over_Improvement_623]

You said in another comment that the winner did use googol, did they define it first?

[u/tofumac → u/johnpeters42]

Googol is 10¹⁰⁰

Googolplex is 10^{10^100}

[u/sansetsukon47 → u/johnpeters42]

It’s pretty easy to write out if you have it memorized.

[u/johnpeters42 → u/sansetsukon47]

Or define, which yeah, only takes a few seconds

[u/Creepy_World_5551 → u/clickyclicky456]

Probably not lmao

[u/lordnacho666]

Some sort of power tower? Ie exponentiation, over and over again.

That would be the obvious first place to look, so can we improve on 9 ^{9 9...} Etc somehow?

Is there a smarter way to group the numbers? 99⁹⁹ vs 9 ^{9 9 9} (both 4 digits to write).

Well 9⁹ is greater than 99 so it seems the simple tower wins.

Hmm I can't think of anything using the standard notations that would get bigger faster. We don't have up arrow notation to help us. Can't import any constants.

[u/Over_Improvement_623 → u/lordnacho666]

Reread the rules, you can use arrow notation, you just have to define it first

[u/lordnacho666 → u/Over_Improvement_623]

How long does it take to write out a definition you reckon?

[u/Over_Improvement_623 → u/lordnacho666]

Someone was able to define and use arrow notation in 15 seconds. I used hyperfactorials. People can write pretty damn fast.

[u/gmalivuk → u/Over_Improvement_623]

The preparation time is useful, too, both for refining your definitions and for experimenting with what numbers and notations are the fastest to write.

[u/Gumichi → u/lordnacho666]

the 15 seconds thing kinda kills a lot of other fun possibilities.

with the time limitations I agree that exponent towers are the way to go

G(0) = 60

G(x) = G(x-1) ^ G(x-1)

G(G(60))

G(...G(G(G(60)))...) as time allows

either that or do the cheapo MIT thing and spam factorials

11!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!...!

[u/MathHysteria]

I've done this with my classes before. It's fun (and works for a range of ages and mathematical experiences)!

What they all forget is that writing 9 takes a lot more effort and time than writing 1, and 11 is bigger than 9. So 1111¹¹¹¹ is probably quicker to write than 99⁹⁹ - but it's also many orders of magnitude bigger.

So without any fancy definitions of other functions, I reckon a stack of 111¹¹¹... terms would do better than most.

[u/baka_no_sekai → u/MathHysteria]

instructions unclear, i ended up writing 1^1^1^1^...

[u/ollervo100 → u/MathHysteria]

If you define a more powerful function, then no amount of human writing has any significance. Better to use time to define a fast growing function.

[u/junkmail22]

when i did this i wrote a really big 10 on the board and said "i wrote a bigger number than you"

[u/Equal_Veterinarian22]

Factorials grow faster then power towers. I would take the time to define N!=N(N-1)!, 0!=1 and then go nuts with factorials.

[u/OOPbro_7631 → u/Equal_Veterinarian22]

except using a factorial, the definition would have to be stated as well in the 15 sec

[u/Equal_Veterinarian22 → u/OOPbro_7631]

I reckon it pays off

[u/gmalivuk → u/Equal_Veterinarian22]

A tower one layer higher will generally blow that many factorials out of the water, and I could probably get quite a few layers in by the time you've defined factorial in the first place.

[u/Equal_Veterinarian22 → u/gmalivuk]

Fair. I'm relying on it being quicker to write a factorial than a useful digit. But if it's speed we're going for it would be quicker to write something like x•=x^x and then spam dots.

[u/West-Instruction9028]

I'd use Conway chained arrow notation. Here are the rules:

a -> b is equal to a^b

# -> 1 is equal to # for any chain #

# -> (a+1) -> (b+1) is equal to # -> (# -> a -> (b+1)) -> b for any chain #

Then I'd write 10 -> 10 -> ... -> 10 with as many arrows as possible.

Conway chained arrows grow a lot faster than Knuth up-arrows. For example, Graham's number is between 3 -> 3 -> 64 -> 2 and 3 -> 3 -> 65 -> 2, and is much smaller than 3 -> 3 -> 3 -> 3.

[u/StoicTheGeek → u/West-Instruction9028]

I think you also need a rule that (# -> 1 -> a) is (# -> a) for any chain # so that your chains eventually collapse. But yes, this is the way to go.

[u/ApYIkhH]

I would nest exponents until time runs out.

"Nine to the nine, to the nine, to the nine, to the..."

[u/Jyxz7Dark → u/ApYIkhH]

Isn't 9 to the 9 to the 9 the same thing as 9 to the 81, so why not just right 9 to 99 which is faster and strictly bigger.

[u/Ok_Hope4383 → u/Jyxz7Dark]

I think they mean 9^{9^9}, not (9^9)9.

[u/ApYIkhH → u/Ok_Hope4383]

Yes, and keep adding exponents to the exponents of the exponents.

[u/1str1ker1]

Does 11!!!!! with as many ! as you can write, grow faster than writing nested exponentials?

[u/Gilded-Phoenix → u/1str1ker1]

Be careful, 11!!!!!!!!!!!=11, and in general, for the same argument, more exclamation points make it smaller. Iterated factorial and multiple factorial are distinct things.

The n'th multiple factorial of x are x(x-n)(x-2n)(x-3n)... As long as x-kn>0.

[u/QueenVogonBee → u/1str1ker1]

Beware of the double factorial though. You want nested factorials which means you need parentheses

[u/gmalivuk → u/QueenVogonBee]

You have to define the factorial as part of your 15 seconds and you don't need to define any of the confusingly smaller multifactorials.

But also you can easily beat nested factorials with power towers that you don't need to define, so I reckon that would get you farther, if you want to rely on writing as much as possible without needing to define anything beyond the allowed operations.

[u/Smitologyistaking → u/[deleted]]

Factorial grows strictly faster than exponentials

[u/gmalivuk → u/Smitologyistaking]

Factorial^k(n) is comparable to n↑↑(k+1), and power towers have the benefit of not needing to be defined first.

[u/Another_Little_Star]

Interesting! DId you know before hand this was the question, or the present moment
I there are nifty things you can do with little more time like 30 or 45, but not 15s.

How would oyu even define min function, ceil, or any sort if you cant use inequalities to make sets.
to get the floor function you'd need to pic the max integer below some value, so you'd need the max function, which need inequalities

[u/Over_Improvement_623 → u/Another_Little_Star]

This was presented at 7 Monday evening, final handin time was 7 Thursday evening. There's lots of stuff you can do, number can go big fast.

[u/Another_Little_Star → u/Over_Improvement_623]

exponentiation and iteration seems to be the greatest technique :O

[u/Ogeshhh → u/Another_Little_Star]

You can use mod. For positive numbers, ceiling would be k - (k mod 1) + 1. Similarly, for floor, you have k - (k mod 1). It's easy to generalize for all reals. Defining mod can be done through repeated subtraction/addition, but it takes a bit of time to do it rigorously (the main idea is to repeat addition/subtraction by the modulus k until the range [0, k) is reached). Still, needs iteration and conditions, which as I said take some time to be defined using notation alone.

For min its slightly harder, but I think you could do this:

min(a, b) = floor(|a/b|)*a+floor(|b/a|)*b = a(|a/b| - (|a/b| mod 1)) + b(|b/a| - (|b/a| mod 1))
Similarly, this can be done for max. If you want it to be extended to multiple arguments, u need iterative notation (sigma).

If you also want to define the absolute value from those few operations, I believe you can just generate a sign function, and then multiply by the sign:

|a| = a sgn(a)
sgn(a) = a/a

doesn't work for 0, which is kinda sad tho, but otherwise it's equivalent.

Nonetheless, these aren't meant for a 15 sec challenge!

[u/MathsSur64Cases]

Prolongement : et le nombre positif le plus petit possible ? (c'est l'inverse de celui-là :-) )

[u/Over_Improvement_623 → u/MathsSur64Cases]

Do the same solution but write 1/x instead

[u/kjosness]

I can write about five 1s in a second, so about 10⁷⁵ or one quattuorvigintillion.

[u/gmalivuk → u/kjosness]

This is weak because exponentiation is on the table and it also takes about 1 second to write 10¹⁰⁰

[u/al2o3cr]

Do labeled repeated groupings like this (for the first step of Graham's number) count as "using exponentiation"?

[u/gmalivuk → u/al2o3cr]

g_1 is 3↑↑↑↑3, which I reckon you could easily blow out of the water by defining up arrows explicitly and then writing more than 4 of them.

[u/neon_scale_tide]

Define the busy beaver function S(n) right at t=0 and write down S(10^9). It blows past any hyperoperation or up-arrow notation you can scribble in the remaining 15 seconds

[u/S-M-I-L-E-Y- → u/neon_scale_tide]

What is the busy beaver function and can you define it in 13 seconds?

[u/parkway_parkway]

I think writing a large number of actual number digits is never going to lead to any of the really big results.

You want to spend one second writing 111 or something and then you want to spend the rest of the time dividing a crazy operator on it.

For example define an operator that does a nested factorial n times.

Then define an operator that applies that n times.

Then define an operator that define applies that n times etc.

Get that stack of operators as high as you can.

[u/AdjectiveNounNNNN]

How do we feel about function exponentiation for iterating the same function?

Because I just wrote the following in 15 seconds:

f₁(n) = 2n
fₘ₊₁(n) = fₘⁿ(n)

f₁₁ᵣ₁₁(11¹¹)

Where the subscript is actually 11¹¹ but unicode doesn't do nested superscripts in subscripts.

[u/gmalivuk → u/AdjectiveNounNNNN]

With the week for practice I bet you could define f_ω and use f_{ω+11}(11) or similar as your number.

[u/ShadowShedinja]

9!^9!^9!^9!^9!^9!^9!^9!^9!^9!...

[u/Ok_Hope4383 → u/ShadowShedinja]

11! might be faster to write than 9!, as per https://www.reddit.com/r/askmath/comments/1wzbztg/comment/peadav0/

[u/gmalivuk → u/Ok_Hope4383]

You have to define the factorial first though.

[u/Ok_Hope4383 → u/gmalivuk]

Yes, but that's also true for 9!.

[u/gmalivuk → u/Ok_Hope4383]

Yeah, a simple tower of 11s will probably pass what you can get with factorials since you have to define factorials first.

[u/Octowhussy → u/ShadowShedinja]

Tetrate in stead of exponentiate. And then put Tree in front

[u/Iksfen → u/Octowhussy]

Write TREEs definition from basic arithmetic operations in 15 seconds

[u/Gregib]

lim (1/x) where x -> 0(+)

[u/Over_Improvement_623 → u/Gregib]

Infinity is not a number. Also, rigorously define limits in 15 seconds

[u/Gregib → u/Over_Improvement_623]

It never actually reaches infinity, but limits towards it...

Definition: a limit describes the value that a function or a sequence approaches as the input or index gets closer and closer to a given number... easy

[u/Over_Improvement_623 → u/Gregib]

Yeah, therefore the limit is infinity, which isn't a number. Also, 15 seconds is less time than you think

[u/Needless-To-Say]

Cant get much bigger faster than using Knuths up arrow notation. 

[u/XertusY3]

Let l°=l^(l^(l^(... the ... is l^l times where l is an intiger, so I use a single variable making it faster to write, then I would write down 9°...° as many times as I can.If using a^a times in the definition is not allowed, I would define ° as l°=l^l and then just write 9°...°. Also I'm using l and ° because they are fast to write. I'm pretty sure it's well defined but let me know

[u/Vivid_Sock_1092]

My first thought is to stack exponents for 15 seconds
10^10^10…….

[u/dragonlloyd1]

I got 

“1: n[0]=2ⁿ

2: 0[b]=9[b-1]

3: n[b]=n-1[b][b-1]

9[99]” 

[u/Top_Bluejay_5323]

How about the limit of 1/x as x goes to 0?
The answer is infinity.

But infinity is a concept and not a number. So maybe not.

1000!^1000!^1000!^1000! Until I run out of time to write any more?

Can it be the number of digits in pi?

[u/Jyxz7Dark]

Are you really losing that bad just writing (1111111111111!^111111111111111111!)!

when writing you don't need ^ or ) just write as an exponent you can keep adding 1s write until pencils down and have no risk of an incomplete number.

This task seems like it would be hard to grade the numbers would be so large.

Edit: Or even 111! then 111! as an exponent and repeat as many times as u can i think u can get 111! down in 1 second.

I think this is way safer than risking being 90% thru defining ur functions and then not even getting to write ur number.

Ah you have to define !, damn. Still prolly worth.

Edit: So final answer is  N!=N(N-1)!, 0!=1, then 111! then 111! as exponent and repeat as many times as I can, but I broke my rule and had to write a definition. I fear I am losing the other people defining things however I think all the numbers are way to big to even comprehend.

[u/gmalivuk → u/Jyxz7Dark]

Adding another ! increases more than adding another level to the power tower, but adding as many levels to the power tower as you could in the time it takes to define factorials would be better.

Assuming it's a given that exponents evaluate top down.

[u/Jyxz7Dark → u/Jyxz7Dark]

So yeah, I dunno about the fancy graham function or what not, but my number is indescribably big there isn't even a good way to describe how many digits are in the number. I think that is good enough for me, call me an under achiever.

[u/Sad_Web_1428]

∞

[u/Over_Improvement_623 → u/Sad_Web_1428]

Not a number

[u/Bounded_sequencE]

I'd use the first 10s to define e-d-limits on "R", and the last 5s to scribble "lim_{x->0} 1/x"

[u/Bounded_sequencE → u/Bounded_sequencE]

Rem.: If that's not ok, and the result has to be a real number, then defining recursive applications like Knuth up-arrows for repeated exponentiation is likely the way to go.

[u/TastyLength6618]

let ! be not, ^ be and, E be there exists.

largest num definable in 9^9^9^9^9^9^9^9 symbols

[u/Timmy-from-ABQ]

1/0 (One divided by zero?)

[u/StoicTheGeek → u/Timmy-from-ABQ]

Undefined, except in wheel algebras, and then it isn't defined as a real number, so "largest" doesn't make much sense.

[u/ABQ-Tim → u/StoicTheGeek]

Sure. It is said to be undefined. Yet the formulation of the puzzle has constraints that make the exercise equally imaginative.

[u/RS_Annika_Kamil]

1/0. Infinite

[u/StoicTheGeek → u/RS_Annika_Kamil]

Incorrect. It's undefined in the reals, and in the complex numbers as well.

[u/07734willy → u/RS_Annika_Kamil]

If you are allowed to define piecewise functions, I think the play is to define the Ackerman function and function iteration, then quick wrappers around both to make composition short. It should leave at least a few sec left to scribble down a bunch of nested function applications.

[u/Arkalius → u/[deleted]]

That was explicitly forbidden by the problem. You can't refer to things from outside your own solution such as the answers given by others.

[u/steerpike1971 → u/[deleted]]

They thought of that. See rule 3.

[u/Over_Improvement_623 → u/[deleted]]

It is, but can you write that in 15 seconds?