Then one kid (who wants to be a mathematician) gave (as by far the winning answer):

[font="Georgia"]f[sub]?_G[/sub](G)[/font]
[font="Georgia"] [/font]
He even defined the wainer and veblen hierarchies, and graham's number (and the definition for knuth's up-arrows)


Needless to say I was very impressed. Especially seeing how I had to do some pretty hefty research only to figure out what the feferman-schutte ordinal was and if it could actually be used in the diagonalization function.

Pretty good answers, this is high school?

I'll admit I have absolutely no idea what the above function means. Anyone care to elaborate on it?

Wouldn't you also be disqualified if someone quoted this formula since it would no longer be a finite number?

Your eval() function can handle quote tags?

Mine isn't quite finished yet, so it currently only really works with simple posts featuring non infinitely recursive positive mathematical expressions. I'd post it, but I'm busy writing up a paper on how I solved the halting problem.

[quote name='sooner123' timestamp='1311953556' post='4842187']
Then one kid (who wants to be a mathematician) gave (as by far the winning answer):

[font="Georgia"]f[sub]?_G[/sub](G)[/font]

He even defined the wainer and veblen hierarchies, and graham's number (and the definition for knuth's up-arrows)


Needless to say I was very impressed. Especially seeing how I had to do some pretty hefty research only to figure out what the feferman-schutte ordinal was and if it could actually be used in the diagonalization function.

Pretty good answers, this is high school?

I'll admit I have absolutely no idea what the above function means. Anyone care to elaborate on it?
[/quote]

Happy to.

f[sub]0[/sub](n) = n + 1
f[sub]a+1[/sub](n) = f[sub]a[/sub][sup]n[/sup](n)
f[sub]a[/sub](n) = f[sub]a[n][/sub](n), if a is a limit ordinal

limit ordinals are ordinals that are basically supremums. example: omega (the smallest countable infinity) = supremum (1, 2, 3, 4, ... ad infinitum)

so for example

f[sub]1[/sub](n) = 2n
f[sub]2[/sub](n) = n*2[sup]n[/sup]
and so on
for f[font=sans-serif][size=2][/font][font=sans-serif][size=2]? is. [/font][font=sans-serif][size=2]? = {1 ,2, 3, ...}. so the nth element is n[/font]
[font=sans-serif][size=2]so f[/font][font=sans-serif][size=2]?(n) = f[sub]n[/sub](n)[/font]
[font="sans-serif"]at this level, we're dealing with a function that is on the order of iterated knuth's arrows[/font]
[font="sans-serif"]f[/font][font=sans-serif][size=2]?[sup]2[/sup](n) is on the order of iterated conway's chained arrows[/font]
epsilon nought is the supremum of the tetrations of omega: {[font=sans-serif][size=2]?, [/font][font=sans-serif][size=2]?^[/font][font=sans-serif][size=2]?, [/font][font=sans-serif][size=2]?^[/font][font=sans-serif][size=2]?^[/font][font=sans-serif][size=2]?, ...}[/font]
[font="sans-serif"]epsilon_1 is the supremum of the tetrations of epsilon_nought[/font]
[font="sans-serif"]epsilon_(a+1) is the supremum of the tetrations of epsilon_a[/font]
[font="sans-serif"]zeta nought is the supremum of the nested subscripting of episilon nought: supremum {epsilon_nought, epsilon_(epsilon_nought), epsilon_(epsilon_(epsilon_nought)), ...}[/font]
[font="sans-serif"]generalizing this progression from omega to epsilon to zeta, we get the bivariate phi function. taking the supremum of phi's fixed points we get the trivariate, the first fixed point of which is [/font][font=Georgia][size=2]?_0 [/font][font="sans-serif"]which is known as the ferman-schutte ordinal which (i think) is the largest named countably infinite ordinal. it's used as the proof theoretic strength of a bunch of techniques and mathematical frameworks like transfinite recursion.[/font]
[font="sans-serif"]
[/font]
[font="sans-serif"]anyways, evaluating the fundamental sequence for the ordinal this kid gave is perfectly finite, but pretty much unimaginable. it makes graham's number look like planck's constant.. to some unimaginable power.[/font]

what about this ?

try 1:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64;
}


if this were to be run in a app,
although, it'll proberblly will overflow the UINT64 on the first iteration.


try 2:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64 * i;
uint64 *= uint64 * uint64;
}



uint64_t max = std::numeric_limits<uint64_t>::max();


what about this ?

try 1:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64;
}


if this were to be run in a app,
although, it'll proberblly will overflow the UINT64 on the first iteration.


try 2:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64 * i;
uint64 *= uint64 * uint64;
}


far less than a googleplex. and utterly tiny compared to the stuff yielded by diagonalization of rapidly growing functions.

[quote name='ryan20fun' timestamp='1312026809' post='4842494']
what about this ?

try 1:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64;
}


if this were to be run in a app,
although, it'll proberblly will overflow the UINT64 on the first iteration.


try 2:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64 * i;
uint64 *= uint64 * uint64;
}


far less than a googleplex. and utterly tiny compared to the stuff yielded by diagonalization of rapidly growing functions.
[/quote]

as far as i can tell .
that will loop foreever and ever armen, the problem is that that wont get larger then 18446744073709551615.
if it were to be done without limit as in UINT64 has no size limit, it would only stop when you cant do the next calculation.

so if i looked at it this way:
that is an infinite loop, right ?

correct ?

n+1 where n is the largest number currently put forth in the thread.

try 2:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64 * i;
uint64 *= uint64 * uint64;
}

[/quote]
I believe your "try 2" results in zero. The first line of the first loop iteration will zero the value of "uint64", the second operation cubes 0 and the loop will then terminate in the next iteration as 1 < 0 is false.

try 2:

UINT64 uint64 = 18446744073709551615;
for: UINT64 i = 0; i < uint64; i++ )
{
uint64 *= uint64 * i;
uint64 *= uint64 * uint64;
}


I believe your "try 2" results in zero. The first line of the first loop iteration will zero the value of "uint64", the second operation cubes 0 and the loop will then terminate in the next iteration as 1 < 0 is false.
[/quote]

your right, i tried running that and the result when i told VS to break all was 1.
so this would be smaller then those other replies, but what is a googleplex ?
a take on Google ?