Largest total computable function competition

[testitemqlstudop]

1st:

Let a "cube" be a 3d cube of numbers that can be rotated, cut/separated (parallel to the XY-face, XZ-face, and YZ-face) and traslated.

Define a function CUBEPARTY(n) that counts the maximum length of a sequence of cubes that satisfies the following conditions:

0. Each number in the cube is between 1 and n inclusive.
1. The i-th cube is at most i by i by i in dimensions.
2. The i-th cube cannot be rotated, cut, or translated in such a sequence to attain a previous cube.

It is (most likely) finite. But now take this:

Take a number D.

Define a (hyper^D)-tesseract as an i by i by ... by i by i (D i-s) bundle of numbers that can be manipulated as any 3d object can: rotation, splitting (along a plane formed by a pair of hyperspatial axis), and translation (along a hyperspatial axis).
Define a function HYPERDPARTY(n) that counts the maximum length of a sequence of (hyper^D)-tesseract that satisfies the following conditions:

0. Each number in the (hyper^D)-tesseract is between 1 and n inclusive.
1. The i-th (hyper^D)-tesseract is at most i by i by i by ... by i by i (D i-s) in dimensions.
2. The i-th (hyper^D)-tesseract cannot be rotated, cut, or translated in such a sequence to attain a shape congruent to the previous (hyper^D)-tesseract.

Now let D = 100000000000000000000000000000000

[Moosey]

1st:

Let a "cube" be a 3d cube of numbers that can be rotated, cut/separated (parallel to the XY-face, XZ-face, and YZ-face) and traslated.

Define a function CUBEPARTY(n) that counts the maximum length of a sequence of cubes that satisfies the following conditions:

0. Each number in the cube is between 1 and n inclusive.
1. The i-th cube is at most i by i by i in dimensions.
2. The i-th cube cannot be rotated, cut, or translated in such a sequence to attain a previous cube.

It is (most likely) finite. But now take this:

Take a number D.

Define a (hyper^D)-tesseract as an i by i by ... by i by i (D i-s) bundle of numbers that can be manipulated as any 3d object can: rotation, splitting (along a plane formed by a pair of hyperspatial axis), and translation (along a hyperspatial axis).
Define a function HYPERDPARTY(n) that counts the maximum length of a sequence of (hyper^D)-tesseract that satisfies the following conditions:

0. Each number in the (hyper^D)-tesseract is between 1 and n inclusive.
1. The i-th (hyper^D)-tesseract is at most i by i by i by ... by i by i (D i-s) in dimensions.
2. The i-th (hyper^D)-tesseract cannot be rotated, cut, or translated in such a sequence to attain a shape congruent to the previous (hyper^D)-tesseract.

Now let D = 100000000000000000000000000000000

Actually, fluffy kitty says that no versions of MATRIXPARTY(n) are finite at 3 except for VECTORPARTY(n)

[testitemqlstudop]

No my cubeparty is different

(and next time please don't quote the whole post)

[Moosey]

No my cubeparty is different

(and next time please don't quote the whole post)

If you saw my response to your response to fluffykitty, you’d know that your cubeparty is infinite.

[testitemqlstudop]

Alright. 2nd:

Let a "bundle" be a 3d bundle of numbers, in which some locations may be empty (not contain numbers), that can be rotated, cut/separated (parallel to the XY-face, XZ-face, and YZ-face), translated, AND glued together (over a face parallel to the XY/XZ/YZ and over lattice points).

Define a function BUNDLEPARTY(n) that counts the maximum length of a sequence of bundles that satisfies the following conditions:

0. Each number in the bundle is between 1 and n inclusive, or is empty.
1. The i-th bundle can fit in an i by i by i cube without rotation.
2. The i-th bundle cannot be rotated, cut, translated, and have (rot/cut/trans/glue)-d pieces glued together in such a sequence to attain a bundle congruent to a previous bundle.

By congruent I mean a translation of a bundle exists such that the empty parts of each bundle form a congruent object and the same numbers are in the same locations.

[Moosey]

BUNDLEPARTY

That, I think, is finite.

But I don’t think it’s very big, but fluffykitty can tell better than my intuition

I submit my new ç function as a warm up for bignumbermaking.

Defined like so:
f(x,y,z) =

Code: Select all

1, if z=0, y=0
z!f(z,x,z-1), if y=0 but not z=0
x!f(x!,y-1,z), if y is not 0

ltr_n(x,y,z)=

Code: Select all

ltr_n-1(x,x,x)ltr_n(ltr_n-1(x,x,x),y-1,z) for y > 0, n > 0
ltr_n-1(x,x,x)ltr_n(z,x,z-1) for y = 0, z > 0,  n > 0
ltr_n-1(x,x,x) for y = 0, z = 0, n > 0
f(x,y,z) for n = 0

ç_n(x,y,z) =

Code: Select all

ç_n-1(x,x,x)ç_(n)(ç_n-1(x,x,x),y-1,z), n >0, y>0
ç_n-1(x,x,x)ç_(n)(ç_n-1(x,x,x),x,z-1), n > 0, y = 0, z>0
ç_n-1(x,x,x)ç_(n-1)(ç_n-1(x,x,x),x,x), n > 0, z = 0,y=0
ltr_x(x,x,x), n=0

I hope I defined it right— I edited it a bit, to make it more like what fluffykitty requested.

what’s ç_2(3,3,3)?


Please note that it’s extremely large— the way fluffykitty requested it suggests it grows very fast.

And now, for Mvlltrs(n) (Moosey very large letter function stacked)
Mvlltrs(n)=

Code: Select all

ç_(Mvlltrs(n-1))(3+n,3+n,3+n), n>0
1, n=0

Mvlltrs(0)=1
Mvlltrs(1) = ç_1(4,4,4)
Mvlltrs(2) = ç_(ç_1(4,4,4))(5,5,5)


Then, the logical extension and analog of σM(n)

vlσM(n) (very large sigmoose) =

Code: Select all

Mvlltrs(vlσM(n-1)), n>0
1, n=0

Like its analog, the sigmoose, at n = 2 it far exceeds graham’s number—
It’s Mvlltrs(ç_1(4,4,4)), or a stack of ç_ç_ç... with a length of ç_1(4,4,4). Furthermore, the parameters also eventually become ç_1(4,4,4), so it’s ç_[already far far far far larger than the normal sigmoose(2), and probably larger than sigmoose(larger numbers)](ç_1(4,4,4),ç_1(4,4,4),ç_1(4,4,4))

Or a very very very very [click to expand] large number.

So I nominate vlσM(vlσM(2)) as an absurdly large number, since it’s a stack with a height that already far exceeds graham’s number by a ridiculous amount.
Actually, even the pathetically tiny sigmoose(3) already does that, since it’s a stack with height sigmoose(2).

vlσM(vlσM(2)) is a stack of height vlσM(vlσM(2)-1), which of course far exceeds any reasonable number (not that g_64 is a reasonable number)

So yeah, it’s large.

Next I guess I need a function based on vlσM(n)- maybe

elf(x,y,z) (extremely large [analog of] f(x,y,z))

Code: Select all

1, z=0, y=0
vlσM(z)elf(z,x,z-1), y=0, z >0
vlσM(x)elf(vlσM(x),y-1,z), y>0

Which is Just f(x,y,z) but the factorials are replaced by vlσM’s, which means that I can’t get as far in finding its value for 3,1,4:
elf(3,1,4)=
vlσM(3)elf(vlσM(3),0,4) =
vlσM(3)vlσM(4)elf(4,vlσM(3),3)
Which means now we do this (a stack > graham’s number of layers tall) times to get z to 2, while outputting nested vlσM’s of 4 until we have a simply enormous nest of them. (Precisely vlσM(3) of them)
Yikes.

I submit elf(3,1,4) as a new huge number.

But here’s the really fun part— now we can create analogs of ltr_n(x,y,z) at the extremely large level.

elltr_n(x,y,z) =

Code: Select all

elltr_n-1(x,x,x)elltr_n(elltr_n-1(x,x,x),y-1,z) for y > 0, n > 0
elltr_n-1(x,x,x)elltr_n(z,x,z-1) for y = 0, z > 0,  n > 0
elltr_n-1(x,x,x) for y = 0, z = 0, n > 0
elf(x,y,z) for n = 0

And then elç:
elç(x,y,z)=

Code: Select all

elç_n-1(x,x,x)elç_(n)(elç_n-1(x,x,x),y-1,z), n >0, y>0
elç_n-1(x,x,x)elç_(n)(elç_n-1(x,x,x),x,z-1), n > 0, y = 0, z>0
elç_n-1(x,x,x)elç_(n-1)(elç_n-1(x,x,x),x,x), n > 0, z = 0,y=0
elltr_x(x,x,x), n=0

And so we get really uncomfortably large numbers.

It doesn’t end there:
Melltrs(n)=

Code: Select all

elç_(Melltrs(n-1))(3+n,3+n,3+n), n>0
1, n=0

And now we have come full circle to σM’s analogs again:
elσM(n)=

Code: Select all

Melltrs(elσM(n-1)), n>0
1, n=0

And so we have come to the second analog to the sigmoose(2):
elσM(2) is an extremely absurdly large stack that I can’t put the size of into words.
It’s TOO BIG.


So after all those edits, I submit the elσM function as a really fast growing function.

I could, of course just go to a deeper level of analogs:
(Nameless) level
Very large level (vl)
Extremely large level (el)
Really large level (rl)
Uncomfortably large level (ul)
Painfully large level (pl)
Terribly large level (tl)
Huge level (h)
Very huge level (vh)
Extremely huge level (eh)
Really huge level (rh)
Etc.
But do I need to waste my time defining rhσM(n), a function so fast-growing that I haven’t the slightest intuition on how fast it grows?

[fluffykitty]

Let a "bundle" be a 3d bundle of numbers, in which some locations may be empty (not contain numbers), that can be rotated, cut/separated (parallel to the XY-face, XZ-face, and YZ-face), translated, AND glued together (over a face parallel to the XY/XZ/YZ and over lattice points).

Define a function BUNDLEPARTY(n) that counts the maximum length of a sequence of bundles that satisfies the following conditions:

0. Each number in the bundle is between 1 and n inclusive, or is empty.
1. The i-th bundle can fit in an i by i by i cube without rotation.
2. The i-th bundle cannot be rotated, cut, translated, and have (rot/cut/trans/glue)-d pieces glued together in such a sequence to attain a bundle congruent to a previous bundle.

By congruent I mean a translation of a bundle exists such that the empty parts of each bundle form a congruent object and the same numbers are in the same locations.

Rotation by 90° around axes does not help with fitting into a cube, so that can probably be removed from rule 1. Rule 2 seems to allow you to rearrange numbers arbitrarily, so this function reduces to VECTORPARTY without ordering and with n^3 numbers at each step instead of n. Therefore, using a similar reduction to Kruskal's tree theorem to the one used by VECTORPARTY, BUNDLEPARTY is finite (but due to the increased number of numbers allowed in each step, this does not automatically prove BUNDLEPARTY(n)<TREE(f(n)) for any reasonable f). BUNDLEPARTY(1)=2, BUNDLEPARTY(2)=9, and BUNDLEPARTY(3) is approximately 2652715388102^243~9e3018. I believe the growth rate is approximately tetrational (f(n,n,n) in Moosey's notation, f(2218,n) in my function)

(Nameless) level
Very large level (vl)
Extremely large level (el)
Really large level (rl)
Uncomfortably large level (ul)
Painfully large level (pl)
Terribly large level (tl)
Huge level (h)
Very huge level (vh)
Extremely huge level (eh)
Really huge level (rh)
Etc.

If you have to name that many levels, it's probably time to figure out how to combine all their definitions into one and make a function that diagonalizes over them.

[Moosey]

If you have to name that many levels, it's probably time to figure out how to combine all their definitions into one and make a function that diagonalizes over them.

I suppose i just thought of a bunch of names.
How does the associated ordinal change in the Fast growing hierarchy when we go from verylargesigmoose->extremelylargesgigmoose? I guess that would help a bit with diagonalizing across sigmoose functions:
then we could define sigmoose_n(x):

Code: Select all

sigmoose(x), n=0
vlsigmoose(x), n=1
etc.

and Ideally come up with a general formula for n>0
Then the obvious choice would be to make a mltrs analog for the sigmoose since that would be really fast growing, since it's a stacked bunch of sigmeese (okay, meese is technically not moose plural but I like it nonetheless). I have no idea how to define a general sigmoose though so I'll need some help again.

[fluffykitty]

Adds w. The rule is whenever you nest n times, it adds 1, and whenever you diagonalize, you take the limit (so ltr_n(x,x,x) has FGH level n*2 when you vary x, so when you vary n it has FGH level w, which is the limit of finite ordinals/levels, and this works the same for higher ltr functions but with "w+"s added to the start). Also, remember that ordinal operations are not commutative, so 1+w<w+1 and 2w<w2.

[Moosey]

So, what’s the general formula for any sigmoose?
σMG_n(x)= (sigmoose generic)

Code: Select all

σM(n), n=0
Something involving σMG, n>0

[fluffykitty]

For that you need a single definition for all levels of f, ltr, a definition for all levels of ç, a definition for all levels of Mltrs, and a definition for all levels of σM which call each other recursively. It might simplify things to remove some functions of each level (since you can just add more levels to regain any lost power).

[Moosey]

For that you need a single definition for all levels of f, ltr, a definition for all levels of ç, a definition for all levels of Mltrs, and a definition for all levels of σM which call each other recursively. It might simplify things to remove some functions of each level (since you can just add more levels to regain any lost power).

Yikes! How would you do that?
I’ll need to have a bit of a tutorial
Or do you not know how to do it?

I suppose the simplest compression is

ltr_n(x,y,z) =

Code: Select all

ltr_n-1(x,x,x)ltr_n(ltr_n-1(x,x,x),y-1,z) for y > 0, n > 0
ltr_n-1(x,x,x)ltr_n(z,x,z-1) for y = 0, z > 0,  n > 0
ltr_n-1(x,x,x) for y = 0, z = 0, n > 0
1, for z=0, y=0, n=0
z!ltr_n(z,x,z-1) for y=0, z>0, n=0
x!ltr_n(x!,y-1,z) for y > 0, n=0

But I guess defining çC (ç compressed) and stuff gets rather uncomfortably difficult, even if it’s slightly different (I.e. smaller) compared to ç


While I’m waiting, I’ll define я_n(x,y,z,w)
я_n(x,y,z,w)=

Code: Select all

x^((я_n(я_n(x,y-1,z,w),y-1,z,w))!), y>0
x^я_n(x,x,z-1,w), z>0, y=0
x^я_n(x,x,x,w-1), w>0, z=0, y=0
x^я_n-1(x,x,x,x), w=0, n>0, z=0, y=0
x!, n=0, w=0, z=0, y=0

I don’t think it grows AS fast as ç or something ridiculous like that, but I think it grows fast, since it inevitably evaluates to an enormous power tower.

What’s я_3(3,3,3,3)

[fluffykitty]

Do something similar to going from f,g... to ltr_n but with ltr, elltr, rlltr, ulltr, plltr, tlltr... (since apparently vlltr does not exist)

[Moosey]

Okay, but I don’t know how I would do that— what would I do to make a function which is a generalized version of ltr, elltr, etc.

I guess I’d add another parameter, since that’s one change I needed to generalize f,g,h, and i (to be fair I never defined an h or an i), but I get hung up on how to make other changes. Can you compress elltr to only contain ltr’s or do I need to create compressed versions of the said functions?
I suppose I could start with that by making a modified version of elf(x,y,z):

elfC(x,y,z) =

Code: Select all

1, z=0, y=0
Mvlltrs(z)elfC(z,x,z-1), y=0, z >0
Mvlltrs(x)elfC(Mvlltrs(x),y-1,z), y>0

Which might cut down on # of issues for compressions of elltr, since I can define it In terms of mvlltrs(n):
elltrC_n(x,y,z)=

Code: Select all

elltrC_n-1(x,x,x)elltrC_n(elltCr_n-1(x,x,x),y-1,z) for y > 0, n > 0
elltrC_n-1(x,x,x)elltrC_n(z,x,z-1) for y = 0, z > 0,  n > 0
elltrC_n-1(x,x,x) for y = 0, z = 0, n > 0
1, z=0, y=0, n=0
Mvlltrs(z)elltrC_n(z,x,z-1), y=0, z >0, n=0
Mvlltrs(x)elltrC_n(Mvlltrs(x),y-1,z), y>0, n = 0

Sorry to be needy but could you link that to the definition of Mvlltrs in terms of ç, which can be defined in terms of ltr

Code: Select all

ç_n-1(x,x,x)ç_(n)(ç_n-1(x,x,x),y-1,z), n >0, y>0
ç_n-1(x,x,x)ç_(n)(ç_n-1(x,x,x),x,z-1), n > 0, y = 0, z>0
ç_n-1(x,x,x)ç_(n-1)(ç_n-1(x,x,x),x,x), n > 0, z = 0,y=0
ltr_x(x,x,x), n=0

I guess the problem is I don’t know how to define Mvlltrs in terms of ltr.

If it helps I suppose I could make an even simpler definition of elltrC:

Code: Select all

elltrC_n-1(x,x,x)elltrC_n(elltCr_n-1(x,x,x),y-1,z) for y > 0, n > 0
elltrC_n-1(x,x,x)elltrC_n(z,x,z-1) for y = 0, z > 0,  n > 0
elltrC_n-1(x,x,x) for y = 0, z = 0, n > 0
1, z=0, y=0, n=0
Mltrs(z)elltrC_n(z,x,z-1), y=0, z >0, n=0
Mltrs(x)elltrC_n(Mltrs(x),y-1,z), y>0, n = 0

[Moosey]

Bump
Does anyone have a way to do this definition of elltrC in terms of ltr?

[fluffykitty]

And now, for Mvlltrs(n) (Moosey very large letter function stacked)
Mvlltrs(n)=

Code: Select all

ç_(Mvlltrs(n-1))(3+n,3+n,3+n), n>0
1, n=0

Mvlltrs(0)=1
Mvlltrs(1) = ç_1(4,4,4)
Mvlltrs(2) = ç_(ç_1(4,4,4))(5,5,5)

[Moosey]

And now, for Mvlltrs(n) (Moosey very large letter function stacked)
Mvlltrs(n)=

Code: Select all

ç_(Mvlltrs(n-1))(3+n,3+n,3+n), n>0
1, n=0

Mvlltrs(0)=1
Mvlltrs(1) = ç_1(4,4,4)
Mvlltrs(2) = ç_(ç_1(4,4,4))(5,5,5)

I don’t know how to use that to define elltr/elltrC in terms of ltr though

Once I have that definition it’s trivial to change it in the same way I did with generalizing f and g. I changed f to ltr_(n-1) and g to ltr_n (as you knew), and I’d do the same for the generalized large ltr function, but I just don’t have intuition on defining elltr_n(x,y,z) in terms of ltr_n(x,y,z)

Do you have a solution and are hiding it for the sake of my learning how to do this or are you not able to find a solution either? I find the latter implausible.
At this point I don’t think I can make the missing link; it may be better to share the solution and then let me pick it apart to understand how I define such functions.

Or should I try to define a simpler function involving Mvlltrs, such as vlσM, in terms of ç? (I hardly expect to do this either, so if you know of any comprehensive tutorials, let me know.)

[fluffykitty]

Defining 5 functions per w2 FGH levels (I missed the fact that ç also adds w levels) is unnecessarily complex. Instead, you can use f, ç but with ltr_x(x,x,x) replaced with f(x,x,x), elç but with elltr replaced with the modified ç, etc. Doing that would make it much simpler to create a w^2 level function.

[Moosey]

Okay, so
mç_n(x,y,z) (modified ç)=

Code: Select all

mç_n-1(x,x,x)mç_(n)(mç_n-1(x,x,x),y-1,z), n >0, y>0
mç_n-1(x,x,xm)ç_(n)(mç_n-1(x,x,x),x,z-1), n > 0, y = 0, z>0
mç_n-1(x,x,x)mç_(n-1)(mç_n-1(x,x,x),x,x), n > 0, z = 0,y=0
f(x,x,x), n=0

melç_n(x,y,z)=

Code: Select all

melç_n-1(x,x,x)melç_(n)(melç_n-1(x,x,x),y-1,z), n >0, y>0
melç_n-1(x,x,x)melç_(n)(melç_n-1(x,x,x),x,z-1), n > 0, y = 0, z>0
melç_n-1(x,x,x)melç_(n-1)(melç_n-1(x,x,x),x,x), n > 0, z = 0,y=0
mç_x(x,x,x), n=0

And then
gç_m,n(x,y,z) (generalized ç)=

Code: Select all

gç_m,n-1(x,x,x)gç_m,n(gç_m,n-1(x,x,x),y-1,z), n >0, y>0, m>0
gç_m,n-1(x,x,x)gç_m,n(gç_m,n-1(x,x,x),x,z-1), n > 0, y = 0, z>0, m>0
gç_m,n-1(x,x,x)gç_m,(n-1)(gç_m,n-1(x,x,x),x,x), n > 0, z = 0,y=0, m>0
gç_m-1,x(x,x,x), n=0, m>0
f(x,x,x), m=0

Oh, goody! I have an evil idea!
çs(n) ([generalized] ç stacked)=

Code: Select all

gç_mçs(n-1),mçs(n-1)(n+3,n+3,n+3), n>0
1, n=0

I feel çs grows faster than any functions I’ve defined so far.
Am I correct in thinking it’s at least ω^2 in the heirarchy?
çs(0) =1
çs(1) = gç_1,1(4,4,4)
çs(2) = gç_gç_1,1(4,4,4),gç_1,1(4,4,4)(5,5,5)
I think this is probably already as big as g_64.
But I’m probably wrong.
Then there is the logical çσM(n) =

Code: Select all

çs(çσM(n-1)), n>0
1, n=0

çσM(0) = 1
çσM(1) = çs(1)
çσM(2) = a huge branching mess of height çs(1)— there are 2^çs(1) different little gç_1,1(4,4,4) s at the bottom, in other words



I think I know how to do a generalized gç, too—
Would that be ω^ω in the hierarchy?
And would the generalized ggç be ε_0?

Just to show that I think I’m right—
ggç_p,m,n(x,y,z)=

Code: Select all

ggç_p,m,n-1(x,x,x)ggç_p,m,n(ggç_p,m,n-1(x,x,x),y-1,z), n >0, y>0, m>0
ggç_p,m,n-1(x,x,x)ggç_p,m,n(ggç_p,m,n-1(x,x,x),x,z-1), n > 0, y = 0, z>0, m>0
ggç_p,m,n-1(x,x,x)ggç_p,m,(n-1)(ggç_p,m,n-1(x,x,x),x,x), n > 0, z = 0,y=0, m>0
ggç_p,m-1,x(x,x,x), n=0, m>0
ggç_p-1,x,x,(x,x,x), m = 0, p>0
f(x,x,x), p=0 

So yeah, is ggç ω^ω in the agh? (EDIT: it isn't)

Now, just a quick question:
how big is ggç_3,3,3(3,3,3)
I suppose it’s uncomfortably enormous (perhaps > g64?)

[testitemqlstudop]

3rd

New bundleparty:

1. The i-th bundle can fit in an i by i by i cube without rotation (i.e. no rotating 45 degrees so as to diagonally fit.)
2. The i-th bundle cannot be rotated, cut, translated, and have (rot/cut/trans/glue)-d pieces glued together in such a sequence to attain a bundle congruent to a previous bundle. HOWEVER, at most i operations of (rot/cut/trans/glue) can be done

Is it still finite?

[testitemqlstudop]

Also, BUNDLEPARTY can be made indefinitely huger (and huger very quick) by just increasing D, the dimension of the bundle, by 1 to 4D bundle.

I think there's a limit to D; at large enough D it should become infinite.

[testitemqlstudop]

I had to use Latex so I did this (see both versions)

yxjspxoh.png (16.47 KiB) Viewed 12229 times

Oh and I forgot the closing parentheses for the functions in this one; it should be beta(P(N)) , gamma(P(P(N))), with the correct amount of closing parenthesae.

yxjspxoh2.png (19.42 KiB) Viewed 12228 times

[Moosey]

3rd

New bundleparty:

1. The i-th bundle can fit in an i by i by i cube without rotation (i.e. no rotating 45 degrees so as to diagonally fit.)
2. The i-th bundle cannot be rotated, cut, translated, and have (rot/cut/trans/glue)-d pieces glued together in such a sequence to attain a bundle congruent to a previous bundle. HOWEVER, at most i operations of (rot/cut/trans/glue) can be done

Is it still finite?

I have a feeling that due to “HOWEVER, at most i operations of (rot/cut/trans/glue) can be done”, it’s infinite
I think that it’ll be difficult to make a function like this which is finite for any n but exceeds TREE(n) unless you happen to have a proof that you don’t have to worry about the former. That’s pretty much what TREE(3) has at its side— there’s a proof that it’s finite. There’s a proof that TREE(n) is finite for any positive integer n.

[Macbi]

I believe the fastest growing known computable functions are of the following form:

n ↦ The combined running time of all Turing machines (with no input) such that there exists a proof that they halt in second-order PA using fewer than n symbols

[testitemqlstudop]

I don't think that's total computable, at also, that's known as Busy Beaver.