Your number is, in fact, not bigger!

For all your silly time-killing forum games.

Moderators: jestingrabbit, Moderators General, Prelates

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Feb 23, 2015 4:56 am UTC

Okay, so my notation runs out before I catch up to WarDaft.

What I'm going to do now is abuse spaces. This works because I can basically make my notation run out before it starts, then I get rid of spaces, and I can nest with spaces and without spaces.

And so, base rules:

n+ = n+n+...+n+n for n plus signs

0+ = 0
1+ = 2
2+ = 6
3+ = 12

What I do now is using the string rules before reaching n+0+, as follows:

A space only counts when it separates equal elements.

n+ 0+ = (n+)+...)+)+ for n plus signs

n+ 0+ 0+ = (n+ 0+)+...)+ 0+)+ 0+ for n+ 0+ plus signs

n+ 0+ 0+ 0+ = (n+ 0+ 0+)+...)+ 0+ 0+)+ 0+ 0+ for n+ 0+ 0+ plus signs

n+ 1+ = n+ 0+ 0+... 0+ for n+ 0+ spaces

n+ 1+ 0+ = (n+ 1+)+...)+ 1+)+ 1+ for n+ 1+ plus signs

n+ 1+ 0+ 0+ = (n+ 1+ 0+)+...)+ 1+ 0+)+ 1+ 0+ for n+ 1+ 0+ plus signs

n+ 1+ 0+ 0+ 0+ = (n+ 0+ 0+)+...)+ 0+ 0+)+ 0+ 0+ for n+ 1+ 0+ 0+ plus signs

n+ 1+ 1+ = n+ 1+ 0+... 0+ for n+ 1+ spaces

The basic rules is that a rightmost 0+ nests the function like that while a rightmost 1+ becomes a series of 0+s. Unless the 1+ is preceded by a +0...

n+ 0+ 1+ = n+ 1+ 1+... 1+ for n+ 1+ spaces.

n+ 0+ 0+ 1+ = n+ 0+ 1+ 0+ 1+... 0+ 1+ for n+ 0+ 1+ spaces.

n+ 0+ 0+ 0+ 1+ = n+ 0+ 0+ 1+ 0+ 0+ 1+... 0+ 0+ 1+ for n+ 0+ 0+ 1+ spaces.

n+ 2+ = n+ 0+ 0+...0+ 0+ 1+ for n+ 0+ 1+ spaces

Reduction rules:

n+ 0+ m+ = n+ m+ m+... m+ for n+ m+ spaces.

n+ 0+ 0+ m+ = n+ 0+ m+ 0+ m+... 0+ m+ for n+ 0+ m+ spaces.

n+ 0+ 0+ 0+ m+ = n+ 0+ 0+ m+ 0+ 0+ m+... 0+ 0+ m+ for n+ 0+ 0+ m+ spaces.

n+ m+ = n+ 0+ 0+...0+ 0+ 1+ 2+ 3+ 4+ ... (m-1)+ for n+ 0+ 1+ 2+...(m-1) spaces

String rules:

n+ a+ b+ c+... is string X and the rest is string Y, where X ends on an element equal or higher to the rightmost element on Y.

Reducing Y:

X 0+ 0+...n 0+s... 0+ m+ = X 0+ 0+...n-1 0+s... 0+ m+ 0+ 0+...n-1 0+s... 0+ m+ 0+ 0+...n-1 0+s... 0+ m+ ... For X 0+ 0+...n-1 0+s... 0+ m+ spaces

If Y is:

X string m+

Where the string is not X 0+ 0+...n 0+s... 0+ m+, then, reduce the string, and return:

X {reduced string} m+ {reduced string} m+ {reduced string} m+ ... for X {reduced string} m+ spaces.

Where {reduced string} may be another string m+ so {reduced string} may be {reduced string} m+ {reduced string} m+ {reduced string} m+ ... for X {reduced string} m+ spaces itself.

Examples:

X 0+ 0+ 0+ 1+ 2+ = X string{0+ 0+ 1+} m{2+} = X string{0+ 1+ 0+ 1+ 0+ 1+...} m{2+} = X 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ ...

X 0+ 0+ 0+ 1+ 2+ 3+ = X string{0+ 0+ 1+ 2+} m{3+} = X string{X 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ ...} m{3+} = X 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ ... 3+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ ... 3+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ 0+ 1+ 0+ 1+ 0+ 1+... 2+ ... 3+...

And:

{n}+ = n+ n+

Reaches f_φ(1,0)(n)

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Feb 23, 2015 8:19 pm UTC

No, wait, I think I need the n+ to work as a counter of iterations, so I have to leave it alone.

Make

n+ {0+}+ = n+ n+

Now, applying the same rules we have:

n+ {0+}+ {0+}+ = n+ {0+}+ n+ = φ(1,0)*2

n+ 0+ {0+}+ = φ(1,0)*ω

n+ 0+ {0+}+ 0+ {0+}+ = {φ(1,0)*ω2

n+ 0+ 0+ {0+}+ = φ(1,0)*{ω^2}

n+ 1+ {0+}+ = φ(1,0)*{ω^ω}

n+ {0+ 0+}+ = n+ n+ {0+}+ = φ(1,0)^2

n+ 0+ {0+ 0+}+ = {φ(1,0)^2}*ω

n+ {0+}+ {0+ 0+}+ = n+ n+ {0+ 0+}+ = {φ(1,0)^3}

n+ 0+ {0+}+ {0+ 0+}+ = {φ(1,0)^ω}

n+ 0+ 0+ {0+}+ {0+ 0+}+ = {φ(1,0)^{ω^2}}

n+ {0+ 0+ 0+}+ = n+ {0+}+ {0+ 0+}+ = {ω^φ(1,0)+1}

n+ {0+ 0+} {0+ 0+ 0+}+ = {ω^ω^φ(1,0)+1}

n+ 0+ {0+ 0+} {0+ 0+ 0+}+ = {φ(1,1)}

n+ 0+ 0+ {0+ 0+} {0+ 0+ 0+}+ = {φ(1,2)}

n+ 1+ {0+ 0+} {0+ 0+ 0+}+ = n+ {0+}+ {0+ 0+}+ = {φ(1,ω)}

n+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = n+ {0+}+ {0+ 0+}+ = {φ(1,φ(1,0)}

n+ 0+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = n+ {0+}+ {0+ 0+}+ = {φ(1,φ(2,0)}

n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = n+ {0+}+ {0+ 0+}+ = {φ(2,1)}

n+ {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(2,φ(1,0))}

n+ {0+ 0+ 0+} {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(2φ(2,φ(1,0)))}

n+ 0+ {0+ 0+ 0+} {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(3,0)}

n+ 0+ {0+}+ {0+ 0+ 0+}+ {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(1,φ(3,0))}

n+ {0+ 0+}+ {0+ 0+ 0+}+ {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(2,φ(3,0))}

n+ 1+ {0+ 0+}+ {0+ 0+ 0+}+ {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(3,1)}

n+ {0+}+ {0+ 0+}+ {0+ 0+ 0+}+ {0+ 0+ 0+ 0+}+ = n+ 1+ {0+}+ {0+ 0+} {0+ 0+ 0+}+ = {φ(3,φ(1,0))}

n+ {0+ 0+ 0+ 0+ 0+}+ = {φ(3,φ(2,0))}

n+ {0+ 0+ 0+ 0+}+ {0+ 0+ 0+ 0+ 0+}+ = {φ(4,0)}

n+ {0+ 0+ 0+ 0+ 0+}+ {0+ 0+ 0+ 0+ 0+ 0+}+ = {φ(5,0)}

n+ {1+}+ = n+ {0+ 0+ ... 0+ 0+}+ for n+ {0+}+ spaces = {φ(ω,0)}

n+ {1+}+ {1+}+ = {φ(ω,0)}*2

n+ 0+ {1+}+ = φ(ω,0)*ω

n+ 0+ {1+}+ 0+ {1+}+ = {φ(ω,0)*ω2

n+ 0+ 0+ {1+}+ = φ(ω,0)*{ω^2}

n+ 1+ {1+}+ = φ(ω,0)*{ω^ω}

n+ {0+}+ {1+}+ = n+ n+ {0+}+ = φ(ω,0)*φ(1,0)

n+ {1+ 0+}+ = n+ {0+ 0+ ... 0+ 0+}+ {1+}+ for n+ {1+}+ spaces = φ(ω,0)^2

n+ {1}+ {1+ 0+}+ = φ(ω,0)^3

n+ 0+ {1}+ {1+ 0+}+ = φ(ω,0)^ω

n+ 0+ 0+ {1}+ {1+ 0+}+ = φ(ω,0)^{ω^2}

n+ {0}+ {1}+ {1+ 0+}+ = ω^{φ(ω,0)+1}

n+ 0+ {0}+ {1}+ {1+ 0+}+ = {φ(1,φ(ω,0)+1)}

n+ {0+ 0+}+ {1}+ {1+ 0+}+ = {φ(1,φ(1,φ(ω,0)+1))}

n+ 0+ {0+ 0+}+ {1}+ {1+ 0+}+ = {φ(2,φ(ω,0)+1)}

n+ {0}+ {0+ 0+}+ {1}+ {1+ 0+}+ = {φ(2φ(2,φ(ω,0)+1))}

n+ {0+ 0+ 0+}+ {1}+ {1+ 0+}+ = {φ(3,φ(ω,0)+1)}

n+ 0+ {0+ 0+ 0+}+ {1}+ {1+ 0+}+ = {φ(3(φ(3,φ(ω,0)+1))}

n+ {0}+ {0+ 0+ 0+}+ {1}+ {1+ 0+}+ = {φ(4,φ(ω,0)+1)}

n+ {1+ 0+ 0+}+ = n+ {0+ 0+...0+ 0+}+ {1}+ {1+ 0+}+ for n+ {0+}+ {1}+ {1+ 0+}+ spaces = {φ(ω,φ(ω,0)+1)}

n+ {1+ 0+}+ {1+ 0+ 0+}+ = {φ(ω,φ(ω,φ(ω,0)+1))}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*2

n+ 0+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*ω

n+ 1+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*ω2

n+ {0}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*φ(1,0)

n+ {1+ 0+ 0+ 0+}+ = n+ {0+ 0+...0+ 0+}+ {1+ 0+}+ {1+ 0+ 0+}+ for n+ {0+}+ {1+ 0+}+ {1+ 0+ 0+}+ spaces = ψ(Ω)*φ(ω,0)

n+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{φ(ω,0)^2}

n+ 0+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{φ(ω,0)^3}

n+ 1+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{φ(ω,0)^ω}

n+ {0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{ω^{φ(ω,0)+1}}

n+ 0+ {0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(1,φ(ω,0)+1)}

n+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = n+ 0+ {0+...0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = for n+ 0+ {0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ spaces = ψ(Ω)*{{φ(ω,φ(ω,0)+1)}

n+ {1}+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω(φ(ω,φ(ω,0)+1))}

n+ 0+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)^2

n+ 0+ 0+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)^ω

n+ {0+} {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ω^{ψ(Ω)+1}

n+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = φ(ω,(ψ(Ω)+1))

n+ {1+ 0+}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = φ(ω(φ(ω,(ψ(Ω)+1)))

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+1)

n+ 1+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+ω)

n+ {0}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+φ(1,0))

n+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+φ(ω,0))

n+ 0+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+ω^{φ(ω,0)+1})

n+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+{φ(ω,φ(ω,0),0)})

n+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω2)

n+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω3)

n+ 0+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ωω)

n+ {0}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω*φ(1,0))

n+ {1}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω*φ(ω,0))

n+ 0+ {1}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω*{ω^φ(ω,0)})

n+ {0}+ {1}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω*{φ(ω(φ(ω,0),0)})

n+ 0+ {0}+ {1}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω^2)

n+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω^3)

n+ 0+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω^ω)

n+ {1}+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{φ(ω,0)})

n+ 0+ {1}+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{φ(φ(ω,0),0)})

n+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω)

n+ 0+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+1)

n+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+ω)

n+ {0}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+φ(1,0))

n+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+φ(ω,0))

n+ 0+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+φ(φ(ω(ω,0),0))

n+ {0}+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+Ω)

n+ 0+ {0}+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+Ωω)

n+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+{Ω*φ(1,0)})

n+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+{Ω*φ(ω,0)})

n+ 0+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+{Ω*φ(ω(φ(ω,0),0)})

n+ 1+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+{Ω^2))

n+ {0}+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+{Ω^φ(1,0)))

n+ 0+ {0}+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}+{Ω^φ(ω,0)))

n+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}2)

n+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}3)

n+ 0+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}ω)

n+ {0}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}*φ(1,0))

n+ {1}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}*φ(ω,0))

n+ {0}+ {1}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω}*φ(ω(φ(ω,0),0))

n+ {1+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω+1})

n+ 0+ {1+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω+ω})

n+ {0}+ {1+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω+φ(1,0)})

n+ {1}+ {1+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω+φ(ω,0)})

n+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω+φ(φ(ω,0))})

n+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω2)})

n+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω3)})

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ωω)})

n+ {0}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω*φ(1,0))})

n+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω*φ(ω,0))})

n+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^{Ω*φ(φ(ω,0)))})

n+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^2)

n+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^3)

n+ 0+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^ω)

n+ {0}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^{φ(1,0)})

n+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^{φ(ω,0)})

n+ {0}+ {1}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^{φ(φ(ω,0)),0})

n+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^Ω)

n+ {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω^Ω}2)

n+ 0+ {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω^Ω}ω)

n+ {0}+ {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω^Ω}*φ(1,0))

n+ {1}+ {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω^Ω}*φ(ω,0))

n+ {0}+ {1}+ {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω^Ω}*φ(φ(ω,0),0))

n+ {1+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}+1)})

n+ 0+ {1+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}+ω)})

n+ {0}+ {1+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}+φ(1,0))})

n+ {1}+ {1+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}+φ(ω,0))})

n+ {0}+ {1}+ {1+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}+φ(φ(ω,0),0)})

n+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}2})

n+ 0+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}ω})

n+ {0}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}*φ(1,0)})

n+ {1}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}*φ(ω,0)})

n+ {0}+ {1}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}*φ(φ(ω,0),0)})

n+ {1+ 0+}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^(Ω+1))

n+ 0+ {1+ 0+}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^(Ω+ω))

n+ {0}+ {1+ 0+}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^(Ω+φ(1,0)))

n+ {1}+ {1+ 0+}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^(Ω+φ(ω,0)))

n+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^(Ω+φ(ω(φ(ω,0),0)))

n+ {1+ 0+ 0+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ(Ω^Ω^Ω^Ω)

(which is probably incorrect but I should reach ψ(Ω^Ω^Ω^Ω) at {1+ 0+ 0+ 0+ 0+ 0+ 0+ 0+}+)

Define:

n+ {1+ 1+} = n+ {1+ 0+ 0+...0+ 0+} with n+ {1+ 0+} spaces.

Send:

6+ {1+ 1+}

For ψ(Ω^Ω^Ω^Ω^Ω)(6)

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Feb 23, 2015 9:33 pm UTC

Now, let's see if that makes sense, I have:

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)

And:

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω+1)

Let's check what happens at each step:

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ = ψ(Ω)+1

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ 0+ = ψ(Ω)+2

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 1+ = ψ(Ω)+ω

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0}+ = ψ(Ω)+φ(1,0)

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0}+ {0}+ = ψ(Ω)+{φ(1,0)*2}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ {0}+ = ψ(Ω)+{φ(1,0)*ω}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0+ 0+}+ = ψ(Ω)+{φ(1,0)^2}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0+ 0+}+ {0+ 0+}+ = ψ(Ω)+{(φ(1,0)^2)2}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ {0+ 0+}+ = ψ(Ω)+{(φ(1,0)^2)ω}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 1+ {0+ 0+}+ = ψ(Ω)+{(φ(1,0)^2)ω^ω}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0}+ {0+ 0+}+ = ψ(Ω)+{φ(1,0)^3}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ {0+}+ {0+ 0+}+ = ψ(Ω)+{φ(1,0)^ω}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0+ 0+ 0+}+ = ψ(Ω)+{ω^{φ(1,0)+1}}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+}+ = ψ(Ω)+{φ(ω,0)}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ {1+}+ = ψ(Ω)+{φ(ω,0)*ω}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0+}+ {1+}+ = ψ(Ω)+{φ(ω,0)*φ(1,0)}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+}+ = ψ(Ω)+{φ(ω,0)^2}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+}+ {1+ 0+}+ = ψ(Ω)+{φ(ω,0)^3}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {0+}+ {1+}+ {1+ 0+}+ = ψ(Ω)+{ω^{φ(ω,0)+1}}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)+{φ(ω(φ(ω,0)+1)}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)+{φ(ω(φ(ω(φ(ω,0)+1))}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*2

n+ 0+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*ω

n+ 0+ 0+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*ω2

n+ 1+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{ω^2}

n+ {0}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*φ(1,0)

n+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*φ(ω,0)

n+ 0+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{φ(ω,0)*ω}

n+ {0}+ {1}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{φ(ω,0)*φ(1,0)}

n+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{φ(ω,0)^2}

n+ {1+ 0+ 0+ 0+}+ 0+ = ψ(Ω)*{φ(ω,0)^2}+1

n+ {1+ 0+ 0+ 0+}+ 1+ = ψ(Ω)*{φ(ω,0)^2}+φ(1,0)

n+ {1+ 0+ 0+ 0+}+ {0+}+ = ψ(Ω)*{φ(ω,0)^2}+φ(1,0)

n+ {1+ 0+ 0+ 0+}+ 0+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}+1}

n+ {1+ 0+ 0+ 0+}+ {0+}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}+φ(1,0)}

n+ {1+ 0+ 0+ 0+}+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}+φ(ω,0)}

n+ {1+ 0+ 0+ 0+}+ 0+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}+{φ(ω,0)}ω}

n+ {1+ 0+ 0+ 0+}+ {0}+ {1+}+ {1+ 0+}+ {1+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}+{φ(ω,0)*φ(1,0)}}

n+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}2}

n+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}3}

n+ 0+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}ω}

n+ {0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^2}*φ(1,0)}

n+ {1+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^3}}

n+ 0+ {1+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{φ(ω,0)^ω}}

n+ {0}+ {1+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{{ω^{φ(ω,0)+1})}}

n+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)*{φ(ω,φ(ω,0)+1)})}}

n+ 0+ {1+ 0+}+ {1+ 0+ 0+ 0+}+ = ψ(Ω)^2

And, well, with this recount this notation actually goes ahead of the other one, so I should be fine.

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Tue Feb 24, 2015 12:09 am UTC

Maybe I'm missing something, but I don't see any rules that would make two adjacent {..}+ terms multiply their ordinal value together. That's just a weird operation to have.

Considering that you yourself are getting two different results... I call shenanigans.

Also, ψ(Ω) = φ(2,0), if you're meaning to use the ψ function I was using for pacing.

Also, you are definitely counting up to Ω wrong, no matter what ordinal collapse function you are using. I'll assume you were aiming for the one I was using to keep the rest of this sane.

n+ {0}+ {1}+ {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^Ω^Ω}*φ(φ(ω,0),0))

n+ {1+ 0+} {1+ 0+ 0+ 0+ 0+ 0+}+ {1+ 0+ 0+ 0+ 0+ 0+ 0+}+ = ψ({Ω^({Ω^Ω}+1)})

The first line looks like you're aiming for a limit of ψ({Ω^Ω^Ω}*φ(1,0,0)), AKA ψ({Ω^Ω^Ω}*ψ(Ω^Ω)). ψ(Ω^(Ω^Ω+1)), however, is the limit of ψ(Ω^Ω^Ω), ψ(Ω^Ω^Ω*ψ(Ω^Ω^Ω)), ψ(Ω^Ω^Ω*ψ(Ω^Ω^Ω*ψ(Ω^Ω^Ω))), ..., it is decidedly not ψ({Ω^Ω^Ω}*φ(1,0,0)).

Also, (0[;]1), where I am modifying my previous notation, where the functionality provided by (0[X;]a) is now provided by (0[a,X;]0), IE the terms in the square brackets are being bumped back by one and the responsibility of the trailing place is inserted at the front. The translation really is that simple, since act almost identically anyway. (0[;]1) is now (<0[>;<]0>) for ψ(φ(1,Ω+1)).
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Tue Feb 24, 2015 6:13 am UTC

Oh, I see. Actually, it all makes sense if you replace each Ω with a φ(1,0,0) so actually 6+ {1+ 1+} would go up to φ(1,0,0)^φ(1,0,0)^φ(1,0,0)^φ(1,0,0)^φ(1,0,0)(6), not ψ(Ω^Ω^Ω^Ω^Ω)(6). Oops.

I just find the Ω notation very confusing.

Is it

ψ(Ω) = φ(2,0)

ψ(Ω^Ω) = φ(1,0,0)

ψ(Ω^Ω^ω) = φ(1,0,0,...0,0)

?

How does it jump like that?

Anyway, the last rewrite of my function seemed to be pure failure, let's try this one:

(First, the reasoning is to get rid of clutter - using n+1 instead of n so that I reach the same values of all my other notation)

n 0 = n+n+...n+n with n plus signs

n 00 = ((n 0) 0) 0 for n+1 parentheses

n 000 = ((n 00) 00) 00 for n+1 parenthesis

Always that parentheses appear below they're n+1 sets instead of 2.

n 1 = n 000 for n+1 0s

n 1000 = ((n 100) 100) 100 (where 000 is a string of n+1 0s and 00 is a string of n 0s)

n 11 = n 1000 for n+1 0s
n 111 = n 11000 for n+1 0s

n 01 = n 111 for n+1 1s

n 001 = n 010101 for n+1 01s
n 0001 = n 001001001 for n+1 001s

n 2 = n 0001 for n+1 0s

000 is a string of n+1 0s and 00 is a string of n 0s

n 2000 = ((n 200) 200) 200

n 21 = n 2000
n 211 = n 21000
n 2111 = n 21000

111 is a string of n+1 1s

n 22 = n 2111
n 222 = n 22111
n 2222 = n 222111

222 is a string of n+1 2s

n 02 = n 222
n 002 = n 020202 for n+1 02s
n 0002 = n 002002001 for n+1 002s

n 12 = 000200020002 for n+1 0002s

xxx is a string of n+1 x

n 102 = 121212

n 1002 = 102102102

n 10002 = 100210021002

n 112 = 100021000210002
n 1112 = 110002110002110002
n 012 = 111211121112
n 0012 = 012012012
n 00012 = 001200120012

n 3 = 00012
n 4 = 000123
n 5 = 0001234

n [0] = n n = φ(1,0)

All previous string may appear in [X]

n [00] = φ(0(φ(1,0))
n [000] = φ(0(φ(0(φ(1,0)))
n [1] = φ(1,1)
n [[0]] = φ(1,φ(1,0))
n [[[0]]] = φ(1(φ(1,φ(1,0)))

n 0,0 = n [[[0]]] = φ(2,0)
n [0,0] φ(1(φ(2,0))
n [[0,0]] φ(1φ(1(φ(2,0)))
n [[[0,0]]] φ(1(φ(1φ(1(φ(2,0))))

n 0,0,0 φ(2,φ(2,0))

n 1,0 φ(3,0))
n [1,0] φ(1,φ(3,0)))
n [[1,0]] φ(1(φ(1,φ(3,0))))
n 1,0,0 φ(2,φ(3,0))
n 1,0,0,0 φ(2,φ(2,φ(3,0)))
n 1,1 φ(3,φ(3,0))
n 0,1 φ(4,0)
n 0,1,0,1 φ(4,(φ(4,0))
n 0,0,1 φ(5,0)
n 0,0,1,0,0,1 φ(5,(φ(5,0))
n 0,0,0,1 φ(6,0)
n 2,0 φ(ω,0)
n 2,2 φ(ω2,0)
n 0,2 φ(ω^2,0)
n [0],0 φ(φ(1,0),0)
n [2,0],0 φ(φ(ω,0),0)
n [[2,0],0],0 φ(φ(φ(ω,0),0),0)
n 0-0 φ(1,0,0)

I'm looking forward to a definitive base notation, if this is clear enough this could be it.

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Tue Feb 24, 2015 3:39 pm UTC

The way it can jump like that is because Ω (just Ω, no Ω^Ω or anything) is bigger than every ordinal it is used to define.

ψ(a) = φ(1,a) for a up to φ(2,0) where ψ(φ(2,0)) = φ(1,φ(2,0)) = φ(2,0), but it stops here because the ψ function can't make zetas on it's own, so it can't 'use' ψ(2,0) when it's first given it as an argument. But it can use Ω, and since Ω is larger than φ(2,0), we eventually count up to ψ(Ω), which is still φ(2,0), but since it can use Ω, ψ(Ω+1) can reference the value of ψ(Ω), which is φ(2,0), so it can construct φ(2,0)+1, φ(2,0)*2, φ(2,0)^φ(2,0)^φ(2,0)... up to φ(1,φ(2,0)+1), then you have ψ(Ω+a) = φ(1,φ(2,0) + a) (specifically the epsilon numbers between zeta 0 and zeta 1). So then you can make the numbers up to the limit of a -> (Ω+a), for any ψ value which is a finite number of applications of the ψ function. So we are limited to ψ(Ω+a), ψ(Ω+ψ(Ω+a)), ψ(Ω+ψ(Ω+ψ(Ω+a))), which approaches but is never equal to φ(2,1). φ(1,φ(2,0) + φ(2,1)) = φ(1,φ(2,1)) = φ(2,1), which isn't any bigger than the 'a' we started with. This continues for all a > φ(2,1) with ψ(Ω+a) = φ(2,1), until ψ(Ω*2) still equal to φ(2,1). However, ψ(Ω*2+1) can construct Ω*2, so it can use the value of ψ(Ω*2) in its constructions, allowing it to make φ(2,1)+1 up to φ(1,φ(2,1)+1), which is the value of ψ(Ω*2+1).

The engine behind all this is the constructor function, C(a), defined by C(a,n).
C(a,0) = {0,1,ω,Ω} for all a
C(a,n+1) = C(a,n) U {x+y, x*y, x^y, ψ(z) for x,y,z in C(a,n), z < a}
C(a) is then the union of C(a,n) for all natural numbers n.
ψ(a) is then the smallest ordinal C(a) was not able to build.

So the constructor function works something like so:
C(0,0) = {0, 1, ω, Ω}
C(0,1) = {0, 1, 2, ω, ω+1, ω*2, ω*ω, ω^ω, Ω, Ω+1, Ω+ω, Ω*2, Ω*ω, Ω*Ω, Ω^ω, Ω^Ω} - there simply *are* no ordinals less than 0, so it does not apply ψ to anything.
At this point, it's also important to remember how ordinal operations really works. If a * ω < b, then a + b = b. 1 + ω = ω, because ω is the first fixed point of a -> (1 + a), so applying the a -> (1+a) function to it does not increase it any further (since applying a function to a fixed point, by definition, simply returns what it was applied to). Likewise, ω^2 is the first fixed point of a -> (ω + a), so ω + ω^2 is again just ω^2. φ(2,0) is the first fixed point of a -> φ(1,a), so applying φ(1, ) to φ(2,0) yields only φ(2,0). Hope that's enough of a refresher, continuing on...

C(0,2) = {0, 1, 2, 3, 4, ω, ω+1, ω+2, ω+3, ω*2, ω*2+1, ω*2+2, ω*3, ω*ω, ω*ω+1, ω*ω+2, ω*ω*2, ω*ω*ω, ω*ω*ω*ω, ω^ω, ω^ω+1, ω^ω+2, ω^ω*2, ω^ω*ω, ω^(ω*2), ω^ω^ω, Ω, Ω+1, Ω+2, Ω+3, Ω*2, Ω*2+1, Ω*2+2, Ω*3, Ω*ω, Ω*ω+1, Ω*ω+2, Ω*ω*2, Ω*Ω, Ω*Ω+1, Ω*Ω+2, Ω*Ω*2, Ω*Ω*ω, Ω*Ω*Ω, Ω*Ω*Ω*Ω, ...}

I wrote this one out mostly exhaustively so you could see what's really going on inside it. It is painstakingly constructing every ordinal it can, and it will make every single ordinal less than epsilon 0 at some C(0,n). Of note, C(0,n) will definitely contain ω^^(n+1).

So, since it has made every ordinal less than epsilon 0, ψ(0) must be epsilon 0.

C(1,0) is still {0,1,ω, Ω}
C(1,1) has one difference, {0, 1, 2, ω, ω+1, ω*2, ω*ω, ω^ω, ψ(0), Ω, Ω+1, Ω+ω, Ω*2, Ω*ω, Ω*Ω, Ω^ω, Ω^Ω} = {0, 1, 2, ω, ω+1, ω*2, ω*ω, ω^ω, ε0, Ω, Ω+1, Ω+ω, Ω*2, Ω*ω, Ω*Ω, Ω^ω, Ω^Ω}
So now we'll have:
C(1,2) = {... ε0+1 ... ε0*2 ... ε0*ω ... Ω*ε0 ... Ωε0 ... } since we make every ordinal we can through addition, multiplication, and exponentiation.
C(1,3) = {... ω^(ε0+1) ... }
C(1,4) = {... ω^ω^(ε0+1) ... }
C(1,5) = {... ω^ω^ω^(ε0+1) ... }
C(1) will thus contain all of the ordinals up to, but not including ε1

Because of our "but not including" we know that ψ(1) = ε1.

And so, we'll find for each of the following statements, we can find some n such that:

C(2,n) contains ψ(1)+1
C(3,n) contains ψ(2)+1
C(ω,n) contains ψ(k)+1 for all k < ω, so ψ(ω) = εω
C(ω+1,n) contains ψ(ω)
C(ψ(1)+1,n) contains ψ(ψ(1))
C(ψ(ψ(1))+1,n) contains ψ(ψ(ψ(1)))

However, at C(φ(2,0)+1), we don't get φ(2,0). This is because we don't reach φ(2,0) until ψ(φ(2,0)), it's never in C(φ(2,0)+1,n) for any n, so we can't ask[i/] for it until we [i]have it, a circular impossibility.
C(Ω+1) changes this though. C(Ω+1,0) right away has Ω. So it can query ψ(Ω) and get φ(2,0). It can then add, multiply, and exponentiate φ(2,0) with all of its contents, and reach the next epsilon number.
C(Ω*(1+a)) can be queried to obtain φ(2,a), so long as it takes only finitely many applications of the a -> ψ(Ω*(1+a)) function to get it. So we can get φ(2,0), φ(2,φ(2,0)), φ(2,φ(2,φ(2,0))), etc, but we can't apply it infinitely many times and get φ(3,0), So ψ(Ω*φ(3,0)) = φ(3,0), and again we have the problem that we aren't able to construct φ(3,0) so that we can query for it.

In general, if you have some ordinal function (not recursive function, this is an ordinal function like the Veblen function not the hierarchy function based on it!) something like f(a) = ψ(ΩΩ^Ω*3+Ω*a), then
f(a) = ψ(ΩΩ^Ω*3+Ω*a)
f(f(a)) = ψ(ΩΩ^Ω*3+Ω*ψ(Ω^(Ω^Ω*3+Ω*a)))
f(f(f(a))) = ψ(ΩΩ^Ω*3+Ω*ψ(Ω^(Ω^Ω*3+Ω*ψ(Ω^(Ω^Ω*3+Ω*a)))))
And the first fixed point of a -> f(a) = the first fixed point of a -> ψ(ΩΩ^Ω*3+Ω*a) = ψ(ΩΩ^Ω*3+Ω*Ω) = ψ(ΩΩ^Ω*3+Ω^2)

And so yes, it is true that:
ψ(Ω) = φ(2,0)

ψ(Ω^Ω) = φ(1,0,0)

ψ(Ω^Ω^ω) = φ(1,0,0,...0,0).

If you define φ(a@b) to be an a in the b-th place, then φ(1,0,0,...0,0) = φ(1@ω) = φ(φ(0@0)@(φ(0@φ(0@0))) using only the characters {φ,(,),0,@} to describe ordinals -- φ(0@0) being φ0(0) = ω^0 = 1,
In general ψ(Ω^Ω^a * b) = φ(b@a), and ψ(Ω^Ω^Ω) is the limit of what you can describe using {φ,(,),0,@}, AKA the limit of taking an ordinal and sending a 1 to that place in the Veblen function.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Tue Feb 24, 2015 3:47 pm UTC

Here's an idea vytron. Why dont you fix, JUST the mistakes that people point out, instead of discarding everything you just did everytime someone quotes a portion of your text?

Do you really expect me to make the effort to learn how your stuff works every other day?
Because that is sort of the reason i'm not even trying to understand what you are doing as i was trying before.
I can't even agree or disagree with your claims. Because being involved enough to do so means i will have wasted my time three days from now when you discard your current notations

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Tue Feb 24, 2015 6:30 pm UTC

Daggoth wrote:Here's an idea vytron. Why dont you fix, JUST the mistakes that people point out, instead of discarding everything you just did everytime someone quotes a portion of your text?

Do you really expect me to make the effort to learn how your stuff works every other day?
Because that is sort of the reason i'm not even trying to understand what you are doing as i was trying before.
I can't even agree or disagree with your claims. Because being involved enough to do so means i will have wasted my time three days from now when you discard your current notations

That's why I started generally ignoring the specifics and just beating the claim.

It was obvious, however, that a claim of ψ(Ω^Ω^Ω^Ω^Ω)(6) was wrong.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Wed Feb 25, 2015 2:58 am UTC

My same query applies, is anyone checking WarDaft or Daggoths claims? I kind of get the feeling that this thread is mostly people making claims and no one actually looking at anything besides the bottom line. I've given WarDaft a few gut checks here and there but haven't looked much into the specifics as their notation passed my cursory scans for accuracy. I admit I don't understand Daggoths notation at all.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Wed Feb 25, 2015 3:04 am UTC

n 21 = n 2000
n 211 = n 21000
n 2111 = n 21000

111 is a string of n+1 1s

n 22 = n 2111
n 222 = n 22111
n 2222 = n 222111

222 is a string of n+1 2s


I have a theory that Maybe he has just been trolling from post 1 of this thread
Here n 211 = n 21000
and n 2111 = n 21000
So apparently no matter how many 1's you stack here they all collapse to a fixed amount of THREE zeroes
indicated by the comment below
"111 is a string of n+1 1s"
seems like the same is going on below with
"222 is a string of n+1 2s"

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Wed Feb 25, 2015 3:34 am UTC

What is there not to understand?, its all concatenated in a single post's spoiler
here http://forums.xkcd.com/viewtopic.php?p=3743611#p3743611




¿0¡0!0?n is the base case. it boils down to knuths just as flavor.

¿X¡X!N?n is self recursion. Its same as f_ordinal+N(n)
¿X¡X!0?n boils down to basically ¿X-1¡X!N?n with a few extra sprinkles but basically
¿1¡X!X?n is ordinal*2
¿2¡X!X?n is ordinal *3
Next step is chains
look up rule 4 in my spoiler. it covers all possible cases ( i think )
¿0¡X!0¡X!0?n is ordinal^2
¿0¡X!0¡X!0¡X!0?n is ordinal^3
Next step is increasing by 1 in the separator
¿0¡X+1!0?n is (ordinal)^ω
Next step is to make the separator nested (rule 5)
¿0¡P¡X!Q!0?n
The base case here is the limit of the previous step.
Which, by the way was (((...ordinal)^ω)^ω)...^ω) also representable as ordinal^ω^ω
Here, the +1 from the previous step goes where the ordinal+N would have gone in the regular separator. Labeled that place Q for you
So a +1 in the Q place is still (ordinal)^ω. ^ω^ω, that brings us to ω^{ω+1} (from multiplication of the exponents)
The limit of THAT is to make Q a number of the kind R¡X!S itself. thats ω^ω2
At this point adding 1's to S still does ordinal^ω. Applied to (ordinal^(ω^ω2))^ω, its another +1 but adding 1's to R makes
+ω's in the exponent.
i could go on. but you begin to see the pattern here.

Much as going up the tower of omegas gets increasingly tedious because of the algebra of exponents,
Nesting the separators makes for more and more inbetween steps before reducing the important parts.
Think of
¿A¡B¡C¡D¡E!F!G!H!I?N
I and A still are + and * respectively, but
H can be of the form K¡L¡M¡N!O!P!Q itself. ( The cascading will cause at most one less level of nesting than the main separator)
In fact, the rules allow for H to have even more nesting levels than the separator it's nested in. It won't occur through the natural reductions but the rules are prepared to handle something like that if you set it as the starting point.

Double separators i havent finished estimating for size. but i'm pretty confident
¿0¡0!¡0!0?n which boils down to an arbitrarily deep nested separator is easily beyond fε0(n+2)

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Wed Feb 25, 2015 5:04 am UTC

I make no claims about your notation Daggoth. I was just admitting that I hadn't looked at it at all, and I'm wondering if anyone actually has. On an intellectual level, WarDaft concerns me more, as they're claiming much more, and the greater the claim, the greater the evidence required. But both of your claims are believable. Nonetheless, it does seem like the three of you are just posting verbose claims to higher ordinals with nobody actually checking them. If that's the case, why bother with the functions at all, let's just play "post the largest ordinal"

To be clear, I'm making no claims that anyone is incorrect. I'm just concerned that the claims are going unchecked, changing the game from "make a big number" to "make the biggest claim"
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Wed Feb 25, 2015 1:29 pm UTC

It started to feel like a Sisyphean task to watchdog Vytron's notation, find something wrong with it and he starts over, negating any work you've done to understand everything so far.

As for no one challenging my claims... there's not a lot I can do about that.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Wed Feb 25, 2015 1:47 pm UTC

Then stay in the thread and be that guy

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Wed Feb 25, 2015 3:49 pm UTC

Thanks WarDaft.

WarDaft wrote:In general ψ(Ω^Ω^a * b) = φ(b@a), and ψ(Ω^Ω^Ω) is the limit of what you can describe using {φ,(,),0,@}, AKA the limit of taking an ordinal and sending a 1 to that place in the Veblen function.


Then I don't see how can I ever reach ψ(Ω^Ω^Ω) with my notation, as it seems ψ(Ω^Ω^x) describes the possible expansions of it :shock:. Can you explain how your notation goes from ψ(Ω^Ω^Ω) to ψ(Ω^Ω^Ω^Ω) and what intermediate values your symbols represent? I think I need to see how's it done in detail to not get stuck there (as, a full implementation of "Illusory Space" would only get me to ψ(Ω^Ω^Ω) by my understanding - in fact, at the limit of the Illusory Space's boxes, it seems 1[1][1]...k+1 boxes...[1][1] advances like ψ(Ω^Ω^{δ+1}) where 1 reaches ordinal δ, but by definition 1 can never reach Ω, throwing all my claims about Illusory Space I've been doing over the years to the waste bin...)

Daggoth wrote:Because being involved enough to do so means i will have wasted my time three days from now when you discard your current notations


Um, okay, I can think of two answers here, I think you can choose the one that you find most pleasing.

1
Spoiler:
I haven't seen you "involved enough" in any notation, we have my notation, WarDaft's, and GoogolyMaster's notation. They don't rewrite their notation every now and then, so what's your pretext to not get involved with other people's notations?


2
Spoiler:
Do you really think I've been managing to come up with entirely new notations every three days?

No, they're all the same, I've just been working in the way it looks like, but all of them use the same rules. I've been trying to polish it so it looks better, but all of them can be mapped to each other, so if you find a flaw in one of them it applies to all the others.

See, the main thing with my notation is the XY rules, I can write them in many manners, but mike was able to see that none of my notations were reaching epsilon_0 when I claimed because of wrong base rules, and it didn't matter that the last version he checked looked differently, the flaw was till apparent.

So, if you can show I don't reach φ(3,0), or φ(ω,0), or φ(φ(ω,0),0), or φ(1,0,0), φ(1,0,1), φ(1,1,0), φ(3,0,0), φ(φ(ω,0),0,0), φ(1,0,0,0)... in any of my notations then your analysis will hold for all of them, because all use the same rules.


(for people adverse to spoilers, I explain all my notations use the same rules and should be equivalent, so you can ignore my latest rewrites and because all my notations can be mapped to each other the flaws of old versions carry over to new ones.)

Daggoth wrote:So apparently no matter how many 1's you stack here they all collapse to a fixed amount of THREE zeroes


Read my post again carefully, there's:

"xxx is a string of n+1 x"

Which means:

n 112 = 100021000210002

Translates to:

1 112 = 1 10021002
2 112 = 2 100021000210002
3 112 = 3 100002100002100002100002
4 112 = 4 10000021000002100000210000021000002

WarDaft wrote:It started to feel like a Sisyphean task to watchdog Vytron's notation, find something wrong with it and he starts over, negating any work you've done to understand everything so far.


Every time I "drop" my notation I just go and write things differently, but don't "start over".

For instance:

Suppose I write a notation that allows:

n = δ_0
n n = δ_0*2
n n n = δ_0*3
n~n = δ^2
n~n~n = δ^3
n [n] = δ_1
n [[n]] = δ_δ_0
n [[[n]]] = δ_δ_δ_0

Or something, and then add:

n 0-0 = n [[...[n]...]] = δ_δ_...δ_δ_0

But later realize that I want to make the leftmost 0 control the next stage, so now there's ambiguity, I have:

n n n-0

Having two possible interpretations:

n n <n-0>
n <n n>-0

One is the <n n>th step of X-0, the other is just ^ing the nth step of X-0.

The solution?

I "drop my notation" and make something like:

n = δ_0
n n = δ_0*2
n n n = δ_0*3
n~n = δ^2
n~n~n = δ^3
n [0-n] = δ_1
n [0-[0-n]] = δ_δ_0
n [0-[0-[0-n]]] = δ_δ_δ_0
n [0 0-0] = [0-[0-...[0-n]...]] = δ_δ_...δ_δ_0

Now there's no ambiguity because X-0 always appears with a [ before X.

Does this mean that one's wasted one time figuring out the original notation? Because, they can be translated into each other (up to the ambiguous part) which I call "mapping", I use different symbols for the same values, if you have figured out how a former notation works you'd have figured out all its possible representations.

But all these are the same:

3[[0],[0],[0,0],[0,0,0]] = 3[[0],[0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0,0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0,0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0,0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0],[0,0],[0,0,0]]

3[0,0,00,000] = 3[0,00,0,00,0,00,0,00,000,0,00,0,00,0,00,0,00,000,0,00,0,00,0,00,0,00,000,0,00,0,00,0,00,0,00,000]

3[+][+][+,+][+,+,+] = 3[+][+,+][+][+,+][+][+,+][+][+,+][+,+,+][+][+,+][+][+,+][+][+,+][+][+,+][+,+,+][+][+,+][+][+,+][+][+,+][+][+,+][+,+,+][+][+,+][+][+,+][+][+,+][+][+,+][+,+,+]

3[+],[+]2[+]1[+][+]1[+][+][+] = 3[+],[+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+][+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+][+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+][+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+]1[+][+]1[+][+][+]

3[0,0,1,2] = 3[0,1,0,1,0,1,0,1,2,0,1,0,1,0,1,0,1,2,0,1,0,1,0,1,0,1,2,0,1,0,1,0,1,0,1,2]

3,0,0,1,2 = 3,0,1,0,1,0,1,0,1,2,0,1,0,1,0,1,0,1,2,0,1,0,1,0,1,0,1,2,0,1,0,1,0,1,0,1,2

3+0+0+{0}+{0+0}+ = 3+0+{0}+0+{0}+0+{0}+0+{0}+{0+0}+0+{0}+0+{0}+0+{0}+0+{0}+{0+0}+0+{0}+0+{0}+0+{0}+0+{0}+{0+0}+0+{0}+0+{0}+0+{0}+0+{0}+{0+0}+

3+ 0+ 0+ {0}+ {0+0}+ = 3+ 0+ {0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ {0+0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ {0+0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ {0+0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ 0+ {0}+ {0+0}+

Are they not? I just switch where the boxes appear, and where the nestings appear, and whether you nests more 0s before a 1 appears, and what separates or represents meaningful numbers, but it's the same notation as the one I had in September 2014.

3 0012 = 3 010101012010101012010101012010101012

^It's the latest incarnation, but it's doing nothing novel, so it's not like 3 0012 appears and one has to relearn how it works from scratch.

mike-l wrote:To be clear, I'm making no claims that anyone is incorrect. I'm just concerned that the claims are going unchecked, changing the game from "make a big number" to "make the biggest claim"


The biggest claim on the thread was my ψ(Ω^Ω^Ω^Ω^Ω)(6) and it didn't last much as WarDaft shot it down easily. At least there has always been good faith (i.e. I've never sent a notation that I knew didn't reach what I claimed - I've just been proved wrong in my claims) so I wouldn't be concerned unless people start sending stuff that they know don't reach what they claim, but I think all current participants are sending claims for what they really think.

BTW I kind of got stuck trying to catch up to WarDaft (his jump might have been overkill) so you're welcome to come back to the thread and attempt to beat him. As you can see, I just didn't go and make a bigger claim than his, as I currently have no idea how to go up to some ψ(Ω^Ω^{Ω+ω})(n) in my way to ψ(Ω^Ω^{Ω2})(n), so the thread isn't just about showing some symbols and claiming they beat the current champion, the biggest challenge is to convince oneself that one is sending a number that is, in fact, bigger than the champion.

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Wed Feb 25, 2015 4:16 pm UTC

Actually i did read googologymasters notation carefully
to be honest i learnt alot from it you can see my posts from before he showed up i was struggling to get past omega^omega. I also "stole" his way of writing rules for it instead of just stating all posible reductions

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Wed Feb 25, 2015 4:37 pm UTC

Then choose second spoiler as my answer :)

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Wed Feb 25, 2015 11:53 pm UTC

Technically, every recursive notation is really just a mapping to ordinals.

That doesn't make them all easily readable, and there may be new errors introduced with a new format that we don't notice at first.

I'll type up something later about how my notation works, and what is required when dealing with ordinal collapse.

Long story short, ordinal collapse is to the Veblen function as 'predicative' ordinals are to the extended Ackermann function.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Thu Feb 26, 2015 1:07 am UTC

WarDaft wrote:That doesn't make them all easily readable


(I for one, find Daggoth's notation very hard to read)

Could you tell me which one of my notations is more easily readable? I probably should stop rewriting and stick with one that already works.

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Thu Feb 26, 2015 5:18 pm UTC

Ok, so unless I completely misunderstand the reduction rules, here's what Vytrons notation should reach.

The reduction rule amounts to: if a notation consisting of smaller terms precedes a larger term, you reduce the ordinal represented by the smaller term, and then duplicate both this reduced term and the larger term.

Caveat: I realize after typing this that I often used commas in place of pluses, will edit later

Eg: Something like {0} + 0 + {0+0} + {0+0+0}, the smaller part is the first three terms, but again these 3 consist of a smaller term preceding a larger one. So to reduce {0} + 0 + {0,0} you take the smaller terms {0} + 0 and reduce that. This is not the above case, so you just reduce the last term, which is 0 disappears. So it reduces to {0}. Now you repeat that followed by the {0+0}, giving {0} + {0+0} + {0} +{0+0} + ... +{0} + {0+0}. That now goes before the {0+0+0} and the whole string is repeated.

So what does this look like as ordinals? When we have terms of equal size, we just fully evaluate what's to its right, so this just gives ordinal addition. Eg 2+1 just gives w^w + w. So repetition amounts to multiplication, and as long as the number of repetitions is an increasing function of n, this is multiplication by w. Thus the reduction rule on ordinals is that you reduce the preceding ordinal and multiply the whole thing by w. If the preceding ordinal is alpha (=a) then reducing that fully multiplies by w a times, ie you multiply by w^a.

Now the reduction rules for single terms need to be picked in such a way that they exceed any fixed ordinal for smaller notations as long as n is sufficiently large. This is only difficult for limit notations, for a successor notation, just take the previous notation and precede that by its reduction. This will always eventually surpass any fixed notation with smaller terms by induction.

Now suppose a is represented by single term T, we can see what the next term, S, represents. (Eg if T = n, S = n+1, if T = {X}, S = {X + 0}). S will be the smallest ordinal not representable as a finite number of terms less than S. Similarly T is the smallest ordinal not represent able as finite terms less than T. Each T will be preceded by a finite number of terms less than T (possibly none) and so the sequence of terms ending at each T will be less than a*w^a, and these values can be added together, but being strictly less than this limit ordinal, will never reach it. Thus S = a*w^a. If a is an epsilon number this is just a^2, otherwise this is w^a.

So now we can see that n = w^^n. {0} being the limit of these is e_0. {0+0} is e_0^2, {0+0+0} = w^e_0^2 = e_0^e_0, and in general {0+0+...+0} = e_0^^(n-1). Thus {1} = e_1, {1+0} = e_1^2, {1+0+0} = e_1^e_1, {1,1} = e_2, etc. Note that these values are significantly less than Vytrons claims past {0+0}
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Thu Feb 26, 2015 6:07 pm UTC

To go further, we can see how far the notation gets if we allow arbitrary notation in the braces, including other braces, to get to something like what Vytron has been calling 00 = {{{...{0}...}}}

We want to see what {X} is in terms of the ordinal represented by X. So far we have
X ~ 0, {X} ~ e_0
X ~ 1,{X} ~ e_0^2
X ~ n+2, {X} ~ e_0^^{n-1}
X~ w, {X} ~ e_1
X ~ w*n, {X} ~ e_n
X ~ w^2, {X} ~ e_w

From there we can get that X~w^n, {X} ~ e_{w^(n-1)} and so by X~w^w we should be at {X}~e_{w^w}. I believe this trend continues, where the map X->{X} sends a->something less than e_a, but achieving equality at all multiples of w^w. Thus the growth overall is essentially a->e_a, and hence 00 = {{..{0}..}} should be zeta_0. Not 100% on this though.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Fri Feb 27, 2015 9:19 pm UTC

Thanks mike, your analysis seems correct. I guess I'll wait to see WarDaft to show his intermediate values up to ψ(Ω^Ω^Ω^Ω) and try to come up with a way to represent them in my notation.

(I have challenged his number, the current unchallenged claim is mine here which matches mike's analysis at n[~[0]~] =ζ_0 where ~ is [~[ is n repetitions of [[[...[[[ and ]~] is n repetitions of ]]]...]]] and claims to go up to f_{ψ(Ω^Ω^{ψ(Ω^Ω^{ψ(Ω^Ω^ω)})})}+(6) which would be the current champion)

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Sun Mar 01, 2015 2:01 am UTC

Vytron wrote:Thanks mike, your analysis seems correct. I guess I'll wait to see WarDaft to show his intermediate values up to ψ(Ω^Ω^Ω^Ω) and try to come up with a way to represent them in my notation.

(I have challenged his number, the current unchallenged claim is mine here which matches mike's analysis at n[~[0]~] =ζ_0 where ~ is [~[ is n repetitions of [[[...[[[ and ]~] is n repetitions of ]]]...]]] and claims to go up to f_{ψ(Ω^Ω^{ψ(Ω^Ω^{ψ(Ω^Ω^ω)})})}+(6) which would be the current champion)


Alright, so the same analysis more or less applies, but the progression is different.

Overall, it looks like it goes:
Add +0+
Put things in {}
Concatenate 0s
Introduce larger integers
Concatenate anything.

Also the starting point is n+0+ is at w, but as far as the reduction rules go it's the same as 1. It's best to thing of +0+ as being a 1, and just remember that whatever ordinal a notation represents should be added to w (which becomes irrelevant at {0} and beyond)

--------------
At a very high level, we can just look at how strong the notation is by considering the order on terms, and knowing the rules that if S is the successor term to T which grows at a, then S grows at a^2 if a is an epsilon number and w^a otherwise. Let's consider the function from ordinals to ordinals defined as follows: f(0) = 1. f(a+1) = f(a)*w^f(a), and f(lim a_n) = lim f(a_n).

The first term is +0+, which has strength f(0) = 1. The next term is {0} which has strength f(1)=w, then {0+0} which has strength f(2) = w^w, and so on. But any of these ordinals that are being constructed can be fed back into f. So the limit of braces is going to be the first fixed point of f. That seems to be zeta_0. Certainly f(w) = e_0, f(w2) = e_1, and in general f(w(1+n)) = e_n for n finite, but it should be true for arbitrary n. In this case z_0 is indeed the first fixed point. Below this agrees with what I get.

Now there is the term 00 with strength zeta_0. Plugging this back into braces should get us to the next fixed point, so concatenating 0s should count through zeta numbers.

Putting in 1 to mean 00....00 I don't think actually helps much given the next step of allowing arbitrary concatenations of previously constructed terms, which I think should get us to the first fixed point of the zeta numbers, ie phi(3,0).

------
Anyway, looking at the specifics

At the beginning, {0+...+0} with k 0s behaves exactly as k does in my previous analysis, so is w^^{k+1}

{{0}} is the limit of these, so yes, e_0

From here I think you actually underestimate a bit.

n+{{0}+0}+ is the next term that can be written, so should be e_0^2, which is what you say, but then {{0}+0+0} follows and should now be e_0^e_0, and in general {{0}+0+...+0} should be e_0^^k for k +0s. Basically what's happening is that each subsequent term is at least w^a where a is the previous term, just at e_0 that isn't any bigger. But as soon as you surpass it, you continue jumping up faster.

This then gets us to {{0}+{0}} being at e_1, and in general {{0}+..+{0}} is e_k for k+1 {0}s.

It looks like the same type of thing as before should occur, where we will 'catch up' to {T} ~ e_a when T ~ a, and so it follows that 00 ~ z_0.

Feeding this back into {}, {00} is the next single term after 00, so it should be z_0^2, and then {00+0} will be z_0^z_0, and we'll keep climbing as before, but here is where your growth rapidly accelerates and I disagree (though what I think we're at is far enough ahead that you don't actually pass it until a little after {000}). I believe, as above that 00...000 should be z_k when there are k+2 0s, but you shoot through the veblen hierarchy.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Sun Mar 01, 2015 2:38 am UTC

Anyway, here's a number that's certainly much bigger than Vytron's. I still haven't looked much at WarDaft's, but this should fall pretty short of his claims and only be about Gamma_0, unless my analysis of Vytron's number above is wrong. In any case, this subsumes Vytron's notation.

So the main difficulty in Vytron's notation is coming up with new ways of putting terms together. I'm simply going to automate this process. Basically I'm going to enumerate types of parentheses.

A term is either 0 or [T|T,T...T] where each T is a term. The T before the | is the level of the term, and they are ordered so that the level takes precedence (if a term is a higher level, then it is higher overall).

[0| X] behaves exactly as Vytron's +s and {} do, though for simplicity I'll treat terms as functions start at 0(n) = n+1.

So
[0|X,0](n) = [0|X]^n(n), where X is any sequence of terms, with the convention that [0|X] is 0 if X is empty.

Clearly [0|0,0,...0] is just f_k.

But then you can put any of these as terms, so we have our braces, you can do things like (using the same reduction rules as Vytron)

[0| [0|0]](n) = [0|0,0,...0](n) (Corresponding to Vytron's n+{0}+ = n+0+0+...0+)
[0| 0, [0|0]](n) = [0|[0|0],[0|0],...,[0|0]](n) (Corresponding to Vytron's n+0+{0}+ = n+{0}+{0}+...+{0})

And of course you can nest within nesting, so
[0| [0| [0| ... [0|0] ... ]]] corresponds to {{...{0}...}}

Vytron then introduces concatenation as the next way of combining terms, and I cover all of this and more by just incrementing the prefix.

[ [0|0] | 0 ](n) = [0| [0| [0| ... [0|0] ... ]]]

Since Vytron's notation can't nest concatenations (this is different than concatenating with nested elements), this already surpasses his power. But I can put any term I want at all as a prefix.

So [ [0|0,0] | 0 ](9) should handily beat Vytron's number, but I can define F(n) = [...[[[0|0] | 0] | 0]... | 0] (note F gives back a term, which is a function). Then F(n)(n) should grow at Gamma_0, and I can send F(9)(9).

Allowing multiple prefixes gets to the Small Veblen Ordinal, and adding indexes to the prefixes should get to the Large Veblen. This still falls short of WarDafts claims though.


(Admittedly I've been very non-explicit about how any of the reduction works)
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Sun Mar 01, 2015 3:08 am UTC

Actually by that point the more complicated rules about how prefixes behave aren't adding anything anymore. (Basically we're climbing the Veblen hierarchy but starting with a more powerful function, but this converges quickly back to the standard hierarchy. So you can use an arguably less complicated set of rules like the old tree construction I made (which also gets to Gamma_0). The explicit separator for levels makes extension to the small Veblen easier than with the tree construction though.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Sun Mar 01, 2015 3:58 am UTC

WarDaft wrote:Okay, time to drag things into the 21st century!

< > are the repeater operator, such that <X> means the string X repeated n times
( ) denote an array, which is to be evaluated lazily, rather than immediately.
[;] is an advanced delimiter. : and ; will not work the same, so I'm not re-using :.
Capitals represent any number of terms (including zero), lower case represent exactly one term.
{ } represent special rules for decrementing a term.

n|0 = n
n|X = n+1|X--
(0)-- = 0
(b)-- = (b--)
(X,0,0)-- where X contains no non-zero terms = <(X,>0<)>
(X,0,b,Y)-- where X contains no non-zero terms = <(X,>0<,b--,Y)>
(a,X,0,b,Y)-- where X contains no non-zero terms, and b does not contain square brackets = <(a--,X,>(a--,X,0,b,Y)<,b--,Y)>
(a,b,X)-- = <(>(a--,b,X)<,b--,X)>
Terms containing [;] are considered non-zero.
(0[;]0,X) = (<0,>X)
(a,0[;]0,X)-- where X is all zero = (<0,>(a--,0[;]0,X),X)
(a,b[;]0,X)-- = (<0,>(a--,b[;]0,X),b--[;]0,X)
(0[;]b,X)-- = <(>0<[;]b--,X)>
(a,0[;]b,X)-- = <(>(a--,0[;]b,X)<[;]b--,X)>
(a[;]b,X)-- = <(>0<[;]b--,a--[;]b,X)>
(a,b[;]c,X)-- = <(>(a--,b[;]c,X)<[;]c--,b--[;]c,X)>
(0[a;]0,X)-- = <(0[a--;]>0<,X)>
(a,0[b;]0,X) = <(0[b--;]>(a--,0[b;]0,X)<,X)>

(0[0;]0) = ψ(Ω^Ω^Ω)
(0,0,0[0;]0) = ψ(Ω^(Ω^Ω+1))
(0,0,0,0[0;]0) = ψ(Ω^(Ω^Ω+Ω))
(0,0,0,0,0[0;]0) = ψ(Ω^(Ω^Ω+Ω^2))
(0[;]0,0[0;]0) = ψ(Ω^(Ω^Ω+Ω^ω))
(0,1[0;]0) = ψ(Ω^(Ω^Ω*2))
(0,0,1[0;]0) = ψ(Ω^(Ω^Ω*2+1))
(2[0;]0) = ψ(Ω^(Ω^Ω*3))
(0[0;]1) = ψ(Ω^(Ω^(Ω+1)))
(0[1;]0) = ψ(Ω^(Ω^(Ω*2)))
(0[0,0;]0) = ψ(Ω^(Ω^(Ω^2)))
(0[1,0;]0) = ψ(Ω^(Ω^(Ω^2+Ω)))
(0[0,0,0;]0) = ψ(Ω^Ω^Ω^3)
(0[0[0;]0;]0) = ψ(Ω^Ω^Ω^Ω)


So it seems your advanced delimiter gets parsed by the forum and makes things look funky. It would seem that just using [] would serve the same purpose.

Still trying to work though all the details, though I like your shorthands of -- for reducing and <> for repeating. Not sure what you mean by "evaluated lazily". Also I assume n -- = n-1, or equivalently that n is shorthand for <(>0<)>? (talking here about things like (2[0;]0), this should be the same as ( ((0))[0;]0 ) yes?

Edit: So I'm working through just the early cases and trying to figure out how they behave. So far I have (under a pseudo slow growing hierarchy, and with some abuse of notation) <(> 0 <)> = n, (a,0) = w(1+a), (0,1) = w^w. (So (0,1) is at w on the usual FGH). But (w^w,0) is just the same expansion as w^w, just twice as long. So this seems to be an equivalent notation.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Sun Mar 01, 2015 4:45 pm UTC

I'm cleaning it up, and building a longer, more detailed explanation in another browser tab. 'n' is indeed shorthand for <(>0<)>, because it's far more readable, they are functionally equivalent.

If it's causing errors, I guess I'll switch back to colons rather than semi-colons.
Last edited by WarDaft on Mon Mar 02, 2015 5:44 am UTC, edited 1 time in total.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Mar 02, 2015 2:45 am UTC

mike-l wrote:Since Vytron's notation can't nest concatenations (this is different than concatenating with nested elements), this already surpasses his power. But I can put any term I want at all as a prefix.


Thanks mike, so it seems that the strongest version of my notation that I had was the one that allowed nested concatenation. I basically worked like you say, but with - instead of |s. It's here.

Basically, once:

[T|T,T...T]

Lives out, I introduce:

[T|T|T,T...T]

Then

[T|T|T|T,T...T]

Etc.

Where n,00 = n[T|T...T|T,T...T] for n |s (in that notation I don't use the 00 symbol before then.)

I dropped that approach because it seemed unable to catch up WarDaft's, but it seems all my future attempts were weaker.

mike-l wrote:Actually by that point the more complicated rules about how prefixes behave aren't adding anything anymore. (Basically we're climbing the Veblen hierarchy but starting with a more powerful function, but this converges quickly back to the standard hierarchy. So you can use an arguably less complicated set of rules like the old tree construction I made (which also gets to Gamma_0). The explicit separator for levels makes extension to the small Veblen easier than with the tree construction though.


Yes, I have estimated the limit of the notation to be ψ(Ω^Ω^Ω), because ψ(Ω^Ω^X) can enumerate all the possible expansions we can think of (even if they add something.) So I guess I'll just have to make my notation do what WarDaft is doing.

Meanwhile:

WarDaft's notation has been taken down (he's cleaning it up.)
My notation has been taken down (mike has shown my latest rewrites have a critical flaw)
Daggoth maxes out at φ(102,100)100 (that's been his highest claim so far)

So GoogologyMaster is the current champion with φ(ω^ω,0,0). Note he doesn't actually send a number, proper, but his {1 [1,2 \ 2 ¬ 2] 2} is enough to be the biggest unchallenged number on the thread.

In the meantime I'll beat it.

My notation works like mike explains here.

Differences:

He has: [X](n)

I have:

n,X

He has:

[0|X]

I have:

[0-X]

And finally, I have stuff like:

n,[0-X],[0-X],[0-X],[0-X]

n,0,[0-X] = n,[0-X],[0-X]...[0-X],[0-X]

But it doesn't make any difference on the growth.

n,[[0-0]-0-0] = n[0-...[0-[0-0-0]-0]...-0] for n+1 [s.

I send:

4,[[0-0]-0-0]

Where n,[0-X-0] is nested concatenation.

Should growth at: φ(ε_0,0,0)(4), and beat GoogologyMaster (making me the unchallenged champion.)

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Mon Mar 02, 2015 6:08 pm UTC

Just a brief meta thought. Perhaps the rule about computatability should be reworded that you must be able to describe your number using computable functions. The reason being that every integer is computable. So, I could arguably submit BB(BB(9)). BB is not computable, but it's output is an integer, and so it is computable being a finite number of applications of n+1.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Mon Mar 02, 2015 6:34 pm UTC

Is there an alternative way to describe the number BB(BB(9)) that does not involve Busy beavers?

mike-l
Posts: 2758
Joined: Tue Sep 04, 2007 2:16 am UTC

Re: Your number is, in fact, not bigger!

Postby mike-l » Mon Mar 02, 2015 6:41 pm UTC

Reasonably no, but theoretically I could simply write it down. It's a finite string of digits.
addams wrote:This forum has some very well educated people typing away in loops with Sourmilk. He is a lucky Sourmilk.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Mar 02, 2015 7:28 pm UTC

Um, if BB(BB(9)) is a function that produces a finite number and you can prove it's the biggest one, I don't see what would be the problem with it? Busy Beavers have basically been banned from other big number threads due to their uncomputability, but I don't think their power has been explored at all? Would love to see how a/what Busy Beaver exactly beats WarDaft (i.e. explain how a busy beaver you use passes ψ(Ω^Ω^Ω^Ω).)

Daggoth
Posts: 52
Joined: Wed Aug 05, 2009 2:37 am UTC

Re: Your number is, in fact, not bigger!

Postby Daggoth » Mon Mar 02, 2015 8:45 pm UTC

But is there a way to predict, or approximate what BB(BB(9)) will be, maybe from the differences in size of BB(BB(9)-1), BB(BB(9)-2),... could you "model" what BB(BB(9)) will be?

Does the growth of BB numbers have a way to be represented recursively (i.e. with an ordinal or similar method?)?

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Mar 02, 2015 9:09 pm UTC

But is there a way to predict, or approximate what BB(BB(9)) will be


There ought to be a way, lest there's a biggest n in BB(n) that can be approximated, and you just send that (instead of aiming for the biggest thing you can send you send the biggest thing you can explain.)

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Mar 02, 2015 9:44 pm UTC

And, anyway, Busy Beavers aren't that impressive.

For instance:

BB(10) < g2

Where g2 is is the second step to get to Graham's Number at step 64.

So:

BB(BB(9)) < BB(g2)

My function produces much higher values at:

n,00 = n,[0-0-...-0-0] for n -s

So, my function grows faster than Busy Beavers for a small enough n. That is, you can always find an n big enough so that BB(n) > n,00 of my function (or for any extension of my function - because BB grows faster), but to beat my number you need at least that n.

So, suppose I send:

g2,00 = g2,[0-0-...-0-0] for g2 -s.

Grows at ψ(Ω^Ω^ω)(g2) or φ(1,0,0,...,0,0)(g2) for g2 0s.

Is g2 big enough that:

BB(g2)

Is larger?

Probably, but there's a point at which BB(n) < n,00 (for instance, BB(3)=6, 3,00 = φ(1,0,0,0)(3)), a point at which BB(n) = n,00 (where BB catches up), and a point in where BB(n) > n,00. You'd have to show that g2 is over this n, and good luck with that.

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Mon Mar 02, 2015 9:54 pm UTC

We do not know that BB(10) is less than g2.

We do not have concrete values for anything larger than BB(4). BB(10) could be larger than every number in the serious bigger number thread.

There is no possible way to approximate the BB function, at all. It is literally not something you can do.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Mon Mar 02, 2015 10:11 pm UTC

We do not know that BB(10) is less than g2.


What I meant to say is that nobody has proven that BB(10) is bigger than g2.

BB(10) could be larger than every number in the serious bigger number thread.


Or, it could be smaller than g2. We have no idea.

But we should not assume it's larger.

We know BB(12) must be larger than g1, we have no idea if it's larger than g1*2 or some higher value, otherwise its lower bound would be known to be larger, but it's not, and we know BB(12) > BB(10), so who knows if g_g_64 (the g_64th step of the Graham Sequence) is enough to beat BB(20) - it might.

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Mon Mar 02, 2015 10:57 pm UTC

Okay Vytron, here goes, I'll try not to skip anything.


So, only two parts of my notation were used so far.

First off, every array enclosed in parenthesis acts more or less exactly like an ordinal.
Second, this will be based on the Hardy Hierarchy.
Third, a[n] will refer to the n-th item from the fundamental sequence for a. In terms of arrays, I explicitly constructed these via the use of < > and --
The fundamental sequence of an ordinal δ, if you are not familiar, is a sequence of ordinals such that the least ordinal greater than every ordinal in the sequence is δ.
A fundamental sequence for ω could be chosen to be {0,1,2,3...}, as the least ordinal greater than every finite number is indeed ω. We could also choose {2,4,6,8...} as the least ordinal greater than every even finite number is still ω.
The former is considered more canonical, but there isn't anything actually fundamental about it.
Letters inside arrays will refer to arrays, those same letters outside ordinals will refer to the ordinal value of those arrays.

A refresher (and slight update, to make proofs easier):
n|0 = n
n|X = n+1|X--
(b)-- = b
(X,0,0)-- where X contains no non-zero terms = <(X,>0<)>
(X,0,b,Y)-- where X contains no non-zero terms = <(X,>0<,b--,Y)>
(a,X,0,b,Y)-- where X contains no non-zero terms, and b does not contain square brackets = <(a--,X,>((a--,X,0,b,Y))<,b--,Y)>
(a,b,X)-- = <(>((a--,b,X))<,b--,X)>
(X,0--) = (X) .. that is, if we attempt to decrement a 0 at the end of an array, we simply chop it off the array.
Terms containing [:] are considered non-zero.
(0[:]0,X) = (<0,>X)
(a,0[:]0,X)-- = (<0,>((a--,0[:]0,X)),X)
(a,b[:]0,X)-- = (<0,>((a--,b[:]0,X)),b--[:]0,X)
(0[b:]0,X)-- = <(0[>b--<:]0,X)>
(a,0[b:]0,X)-- = <(>((a--,0[b:]0,X))<[b--:]0,X)>
(a[b:]0,X)-- = <(>(a--[b:]0,X)<[b--:]0,a--[b:]0,X)>
(a,b[c:]0,X)-- = <(>((a--,b[c:]0,X))<[c--:]0,b--[c:]0,X)>
(0[0,a:]0,X)-- = <(0[>0<,a--:]0,X)>
(a,0[0,b:]0,X) = <(0[>((a--,0[0,b:]0,X))<,b--:]0,X)>

I believe this should all be updated correctly.

Since it's reduction is deferred, (0,0) can be used in place of ω in a quite literal way. Reducing it at step n will create a new construct that will take n reductions to eliminate.

(a) = a+1
(a,0) functions like a + ω, e.g. (1,0)-- = (((((((1))))))), requiring us to chew through n outer braces to reduce the inner value.


((a,0),0) is likewise a + ω*2, since we must perform two ω[n]-time reductions.
(a,1) applies this +ω function n times. This gives us a +ω^2 function.
Likewise (a,2) gives us a +ω^3 function.
(a,b+1) applies +b ω[n] times, so it is the +b*ω function.
This is working in the Hardy hierarchy, so it actually is this simple right now.

We desire now to prove that (a,b) is the a+ω^(1+b) function. This should give you an idea of what you should be aiming towards.

Assume (a,c) is the a+ω^(1+c) function for c < b (we can do this, via transfinite induction)
Every ordinal is either a limit ordinal (= sup{c[0],c[1],c[2]...}), successor ordinal (= c+1), or zero.
Suppose b = c+1, a successor ordinal. We have that (a,c) gives us +ω^(1+c), so (a,(c)) is +ω^(1+c)*n = +ω^(1+c)*(ω[n]) = +(ω^(1+c)*ω)[n] = +ω^(1+c+1)[n], thus it is true for successor ordinals.
For limit ordinals, we have (a,b)-- = (a,b--) that is, (a,b)[n] = (a,b[n]), and so it must be sup{a+ω^(b[0]), a+ω^(b[1]),...) as n can range over any finite value and (a,b) is greater than all of them, thus, it is true for limit ordinals as well.
(a,0) as shown is a+ω = a + ω^(1+0) thus it is true for zero.
Since we have it for zero, successor, and limit ordinals via transfinite induction, we have it for all ordinals, and (a,b) = a + ω^(1+b).

If you try to make sense of things for these three cases, it should keep you fairly on track, even if you don't do a rigorous proof. That will come with practice.

Anyway, so, (a,b) gives us the +ω^(1+b) function, and as I mentioned (0,0) functions very literally like ω, that means (a,(0,0)) gives us the a+ω^ω function.

So, we can construct ω^ω via (0,(0,0)), and ω^ω^ω via (0,(0,(0,0)))

(0,0,0) is naturally the limit of this sequence and so is ε0
(0,((0,0,0))) is ω^(ε0+1) exactly now, rather than approximately. (Before, it would have been (0,(1,(0,0,0))) where we closely approximated this value)
You can see this because it reduces to ((..((0,(0,0,0)),(0,0,0)...),(0,0,0)) which matches what we expect for ε0*ω, which is equivalent to ω^(ε0+1)
We proved this, but of course, it doesn't hurt to see examples.

Since, (0,a) is always ω^a (proofs really are handy), we are now well on our way to higher epsilons.
(0,(0,0,0)) is still basically ε0, it produces slightly larger values, but n+1|(0,0,0) > n|(0,(0,0,0))
(1,0,0) = <(0,>((0,0,0))<)>, IE exactly the sort of fundamental sequence we need for ε1
And indeed, with a proof basically exactly like the last one, we'll find that (a,0,0) is εa
So ((0,0,0),0,0) is ε_εa, and as such <(>0<,0,0)> is the sequence for ζ0.
(0,1,0) is the token that reduces to <(>0<,0,0)> and thus (0,1,0) = ζ0.

At this point, it should be fairly obvious that this is just a barely white-washed version of the multi-argument Veblen function, constructed from fundamental sequences instead of limits.
Of note, the difference between this function and the extended Ackermann function is little more than in this notation, nested arrays are differed to be reduced further later, where as in the Ackermann notation, they are reduced immediately and a number value is inserted.

So (0,0,1) is Γ0 and (0,0,...0) = φ(1...,0,0) with equal term counts.
Next we need a way to reach transfinite positions in φ. We do this by having, well, a position parameter.
(0,...0) for 1 in a finite position k+1 causes the array to nest into position k. For limit positions, it is the supremum of a fundamental sequence for that limit.
We specify φ(1@ω) with the array (0[:]0)
φ(1@ω)[n] = φ(1@n) is a perfectly good fundamental sequence
(0[:]0) = (<0,>) which is at most off by one position from φ(1@n) and thus it is a functionally equivalent fundamental sequence for φ(1@ω)
So, to have φ(1@(ω+1)), we need to be able to enumerate fixed points of a -> φ(a@ω)
(0[0:]0) = <(>0<[:]0)> = ((..((0[:]0)[:]0)..)[:]0), which is exactly what we want.
Likewise, (a,0[0:]0) = ((..(((a--,0[0:]0))[:]0)..)[:]0), and so (a,0[0:]0) enumerates the fixed points of a -> φ(a@ω)

In a not entirely rigorous sense, we can say that (x,0[b:]0) enumerates the fixed points of a -> (a,0[b--:]0). It is not rigorous because when b represents a limit ordinal, we are not counting fixed points exactly but supremums. The Veblen function also does this however, so we have satisfactory fundamental sequences for all positions.

As such, the first fixed point of a -> (0[a:]0) IE (0[0,0:]0) is ψ(Ω^Ω^Ω), which, if the highest champion otherwise is φ(ε0,0,0)(4), is total overkill and I'll just dial things back to a mere 2|(0,0,0,0), being f{φ(1,0,0,0)}(2)
Last edited by WarDaft on Tue Mar 03, 2015 5:50 pm UTC, edited 2 times in total.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.

User avatar
Vytron
Posts: 429
Joined: Mon Oct 19, 2009 10:11 am UTC
Location: The Outside. I use She/He/Her/His/Him as gender neutral pronouns :P

Re: Your number is, in fact, not bigger!

Postby Vytron » Tue Mar 03, 2015 12:23 am UTC

Thanks WarDaft, I found it very interesting that our notations are very similar in our way to ψ(Ω^Ω^ω), in fact, if in your notation you used []s instead of ()s, -s instead of ,s - and did things from right to left instead of from left to right, we'd have several values that look the same and produce similar values!

Oddly enough, it has came to mike-l to show proofs of the reaches of my number, here I'm quoting him:

A term is either 0 or [T|T,T...T] where each T is a term. The T before the | is the level of the term, and they are ordered so that the level takes precedence (if a term is a higher level, then it is higher overall).


In the notation I'll use, We have n,x. If there's no box in x then it works like mike says for his [0|x](n)

,0s are used for nestings, i.e.:

n,0,0,0,0 for n 0s returns (((n,0,0,0,0),0,0,0,0),0,0,0,0 for n nestings and -1 zeroes, this is equivalent to ordinal +1.

n,x,0 then gives any ordinal +1 for any number of ,0s.

n,0 can be anything like n+1 or whatever.

n,{0} returns n,0,0,0,0,0 for n 0s and so:

n,x,{0} is ordinal +ω for ordinal x.

The series:

n,x,{0},{0}, n,x,{0},{0},{0}, n,x,{0},{0},{0}

Then have ordinal x+ω2, x+ω3, x+ω4

n,x,0,{0} = n,x,{0},{0},{0},{0} for n {0}s

Is x+ω^2

Now, any ordinal y here:

n,x,y

Can appear multiple times for ordinal multiplication:

n,x,y,y = n,x,y*2
n,x,y,y,y = n,x,y*3

And:

n,x,0,y = n,x,y,y,y for n ys.

So a 0 before y gives multiplication by ω

n,{0,0} returns n,0,0,0,{0} for n 0s, so this is ω^ω

n,{0,0,0} returns n,0,0,0,{0},{0,0} for n 0s, so this is ω^ω^ω

n,{{0}} returns n,{0,0,0} for n 0s, so this is ε_0

n,x,{{0}},y is now multiplying by ε_0, so:

n,{{0},0} = n,{0,0,0}{{0}} for n 0s is ε_0^2

n,{{0,0}} is ε_1

n,{{{0}}} is ε_ε_0

n,[0-0] = n,{...{{0}...}} for n nestings is ζ_0

And things move along now as in mike-l's examples, so we have:

n,[0,0-0] = n,[0-[0-[0-0]]] for n nestings is φ(3,0)

n,[{0}-0] is φ(ω,0)

n,[[{0}-0]-0] is φ(φ(ω,0),0)

n,[0-0-0] = n,[[{0}-0]-0] for nestings is φ(1,0,0)

n,[0-0-0-0] = n,[[{0}-0-0]-0-0] for nestings is φ(1,0,0,0)

n,[0-0-0-0-0] = n,[[{0}-0-0]-0-0] for nestings is φ(1,0,0,0,0)

And:

n,1 = n,[0-0-0-0] for n -s

Oh yeah, I don't introduce higher integers than 0 until now.

n,1 = φ(1@ω) so that k,1 = φ(1@k)

n,1,{0} enumerates the fixed points of n,1,0,0...0,0 (a -> φ(a@ω))

n,1,0,{0} enumerates the fixed points of n,1,{0},{0}...{0},{0}

n,1,{0,0} would enumerate all the fixed points of n,1,0,0...k 0s...0,0,{0} where each enumerates the fixed points of n,1,0,0...k-1...0,0,{0},0,0...k-1...0,0,{0},0,0...k-1...0,0,{0} for n strings. So would be at ψ(Ω^Ω^Ω)?

I'll send:

5,1

For f{φ(1,0,0,0,0,0)}(5)

User avatar
WarDaft
Posts: 1583
Joined: Thu Jul 30, 2009 3:16 pm UTC

Re: Your number is, in fact, not bigger!

Postby WarDaft » Tue Mar 03, 2015 12:59 am UTC

I generally agree with you up to n,{0,0} = ω^ω, with caveats about being careful about making sure your notation terminates properly because I'm not going to prove that...

But then:
n,0,{0,0} = ω^ω*ω = ω^(ω+1)
n,0,0,{0,0} = ω^(ω+1)*ω = ω^(ω+2)
n,{0},{0,0} = ω^ω*ω^ω = ω^(ω*2)
n,0,{0},{0,0} = ω^(ω*2)*ω = ω^(ω*2+1)
n,0,0,{0},{0,0} = ω^(ω*2+1)*ω = ω^(ω*2+2)
n,{0,0,0} = n,<0,>{0},{0,0} = ω^(ω*3), not ω^ω^ω

Remember the exponent laws, ω^a*ω^b = ω^(a+b)

Of course, the [-] notation totally compensates for this, because it doesn't even matter if you start with the function (+1) or f(a) = ζa, the [-] notation on its own is strong enough to reach φ(1@5).
So naturally I'm going to say 2|(0[0;]0) for φ(1@(ω+1)) (AKA φ(φ(0@0)@(φ(φ(0@0)@0)+φ(0@0)) if expressed hereditarily in φ@) and we'll take a closer look at how you deal with transfinite positions in a bit.
All Shadow priest spells that deal Fire damage now appear green.
Big freaky cereal boxes of death.


Return to “Forum Games”

Who is online

Users browsing this forum: No registered users and 32 guests