A function that (hopefully) delivers large numbers.

It's called the J-function, and it's a lot better than Letter Notation, I promise. Super creative name, I know ;)

[I'm a bad teacher, and yes, it is hard to understand lol, so no worries if it doesn't make total sense. It barely makes sense to me! A lot of it is intuition and memorized rules (to make sure the whole thing isn't 17 hours long :P]

{P.S. I use functions that look exactly like my Letter Functions for the sake of demonstration. They are defined differently here, but they're used only as shorthand.}

Version 4 (First Release)

We define a function J(s, b1, b2, ...bn, f) with the following rules.

s and b1 through bn are whole numbers (integers not less than zero) and bn is also a natural number (integer not less than one)

f is a function where every whole number input produces a larger whole number input

When s > 0, J(s, b1, b2,…bn, f)= J(s-1, J(s-1, b1, b2,…bn, f), J(s-1, b1, b2,…bn, f), … n times …, f) (Decrease s by 1 and replace all numbers after with a copy of the whole array)

When s = 0, = J(b1, b2,…bn, f) (Remove leading zeroes)

Repeat until only two numbers and f, thus represented as J(p, a, f).

When p > 0, similar to before, J (p, a, f) = J (p-1, J (p-1, a, f), f). Reminder: a should still be greater than 0, but I think the above rules ensure that happens.

J(0, a, f) = [a][a, a, a,…(a times)] which is a list with a variable argument.

(J(0, 3, f) = [3][3, 3, 3]

Then, for every [j][…]

When y > 0, [j][…y, z] = [j][…y-1, [j](z)] (Decrease the second to last value by one and set the last value to f of itself.)

If y=0, [j][…x, 0, z] = [j][…x-1, z, z] (Decrease the third to last value by one and set the second to last value to z.)

Then, if y=x=0, [j][…m, 0, 0, 0,…n times, …0, z] = [j][…m-1, z, z, z,…n times, …z, z]. (We replace every instance of 0 between the two last nonzero values with a copy of the second value and decrease that last nonzero value by 1.)

It is the same if m is the first number:

[j][m, 0, 0, 0,…n times, …0, z], = [j][m-1, z, z, z,…n times, …z, z].

Then, for j>0:

[j][0, 0,…z] = [j][z] = [j-1][[j-1][z] copies of [j-1][z]]

Or for j=0:

[0][0, 0,…z] = [0][z]

and [0][z] = f(z) [where f was put in at the start].

S is the successor function {S(100) = 101}.

J(0, 1, S) = [1][1] = [0][[0][1]] = [0][1] = 1.

J(0, 2, S) = [2][2, 2] = [2][1, [2][2]] where

[2][2] = [1][[1][2] copies of [1][2]]

where [1][2] = [0][[0][2] copies of [0][2]]

where [0][2] = S(2) = 3

[1][2] = [0][3, 3, 3] = [0][3,2,[0][3]] = [0][3,2,S(3)] = [0][3, 2, 4] = [0][3, 0, 6]

= [0][2, 6, 6] = [0][2, 5, 7] = [0][2, 0, 12] = [0][1, 0, 24] = [0][0, 0, 48] = [0][48] = 49

[1][2] = 49

[2][2] = [1][49 copies of 49] = [1][49x47, 49, 49] = [1][49x47, 48, [1][49]]

From right to left:

0[2 copies of x] = 2x + 1

0[3 copies of x] > x2^x + 1 > 2^x

0[4 copies of x] >= [3 copies of [3 copies of [3 copies of … with either x or x+1 entries… x] > 2^2^…with x entries…x] + 1 > 2^^x

0[5 copies of x] >= [4 copies of [4 copies of [4 copies of … with either x or x+1 entries… x] > 2^^2^^…with x entries…x] + 1 > 2^^^x

Etc

0[y copies of x] > 2^^…with y-2 arrows…^^x

[1][49] > 2^^47 arrows^^49

[1][49*47, 49, 49] > [1][49*47, 0, A(49)]

where A(0) = 49

and A(x) = 2^^[A(x-1)-2]^^A(x-1)

= [1][49*46, 48, A(49), A(49)] > [1][49*46, 48, 0, A(A(49))] > [1][49*46, 0, 0, B(49)] where B(1) = A(49) and B(x) = A(B(x-1))

= [1][49*45, 48, B(49), B(49), B(49)]

> [1][49*45, 48, B(49)-1, B(49), B(50)]

> [1][49*45, 48, 0, 0, B(49+B(49))]

> [1][49*45, 48, 0, 0, B(B(49))]

> [1][49*45, 47, B(B(49)), B(B(49)), B(B(49))]

> [1][49*45, 47, B(B(49))-1, B(B(49)), B(B(49)+1)]

> [1][49*45, 47, 0, 0, B(49+B(B(49)))

> [1][49*45, 47, 0, 0, B(B(B(49)))

> [1][49*45, 0, 0, 0, B(B(...49 B’s…B(49)))

= [1][49*45, 0, 0, 0, C(49)]

where C(x) = B(B(B(...with x B’s…B(49)...)))

This process should continue, so by my estimation:

[2][2] > g(x) where:

f(1, 0, z) = z

f(1, x, z) = 2^^f(1, x-1, z)-2 arrows^^f(1, x-1, z)

f(l, x, z) = f(l-1, f(l-1, ...x copies of f, ...(l-1, z, z), z)

g(x) = f(x-1, x, x)

[2][1, [2][2]] > [2][1, g(49)]

[2][1, g(49)] = [2][0, [2][g(49)]]

[2][g(49)] = [1][[1][g(49)] copies of [1][g(49)]]

[1][w*(w-2), w, w] > [1][w*(w-2), 0, A(w)]

where A(0) = w

and A(x) = 2^^[A(w-1)-2]^^A(w-1)

= [1][w*(w-2), 0, f(1, w, w)]

= [1][w*(w-3), w-1, f(1, w, w), f(1, w, w)] > [1][w*(w-3), 48, 0, f(1, f(1, w, w), w)] > [1][w*(w-3), 0, 0, f(2, w, w)] 

= [1][w*(w-4), w-1, f(2, w, w), f(2, w, w), f(2, w, w)]

> [1][w*(w-4), w-1, f(2, w, w)-1, f(2, w, w), f(2, w+1, w)]

> [1][w*(w-4), w-1, 0, 0, f(2, w+f(2, w, w), w)]

> [1][w*(w-4), w-1, 0, 0, f(2, f(2, w, w), w)]

> [1][w*(w-4), w-2, f(2, f(2, w, w), w), f(2, f(2, w, w), w), f(2, f(2, w, w), w)]

> [1][w*(w-4), w-2, f(2, f(2, w, w), w), f(2, f(2, w, w), w), f(2, f(2, w, w), w)]

> [1][w*(w-4), w-2, 0, 0, f(2, w+f(2, f(2, w, w), w), w))

> [1][w*(w-4), w-2, 0, 0, f(2, f(2, f(2, w, w), w), w))

> [1][w*(w-4), 0, 0, 0, f(3, w, w)]

> [1][0, 0, …(w-1 copies of 0)..., f(w-1,w,w)]

> [1][f(w-1, w, w)] > 2^^f(w-1, w, w) - 2 arrows^^f(w-1, w, w) >= f(1, 1, f(w-1, w, w))

This process should continue, so by my estimation:

[1][w copies of w] > f(1, 1, f(w-1, w, w))

[2][x] > f(1, 1, f([1][x]-1, [1][x], [1][x])) = f(1, 1, g([1][x])

[2][f(1, 1, g(49))] > f(1, 1, f([1][g(49)]-1, [1][g(49)], [1][g(49)]) = f(1, 1, g([1][g(49)]))

[1][g(49)] >= 2^^g(49)-2 arrows^^g(49) >= f(1, 1, g(49))

[2][g(49)] > f(1, 1, g([1][g(49)]))

[2][0, [2][g(49)]] > [2][0, f(1, 1, g([1][g(49)]))] = [2][f(1, 1, g([1][g(49)]))]

> f(1, 1, g([1][f(1, 1, g([1][g(49)]))])

>= f(1, 1, g(f(1, 1, g(f(1, 1, g(f(1, 1, g(49)))))))) < J(0, 2, S)

Pretty big! Pretty big...

Matthew