@eaglgenes101 Yes, f_α+1 = n ↦ (f_α)ⁿ(n)

@eaglgenes101 f_α+ω = n ↦ (f_α+n)(n)

@eaglgenes101 I'm not quite sure I understand what you meant, but f_α∙ω = n ↦ (f_α∙n)(n)

@eaglgenes101 For the most part yes.

Also note: I have no clue how your current code works ;)

@Feeds >.>

@StevenH. also hi sorry I never replied/no it doesn't make sense to me xD

I can figure out how to reach the veblen function ordinals in this manner. How do I get to the Feferman Schutte ordinal from the veblen functions?

Also whicb part are you lost on in my code?

@eaglgenes101 no idea how the f(r,s,t) works.

An example would be nice

@eaglgenes101 Γ0 = Feferman-Schutte ordinal is the limit of 1, φ(1,0), φ(φ(1,0),0), φ(φ(φ(1,0),0),0), ...

f(r,s,t) takes r and applies s to it t times

m'kay

so f(2,x->x+1,5) = (((2)+1)+1)+1) = 5

f(2,g,3) = g(g(g(2)))

w?

w(b)=a->x->x|>f(a,b,x)

w(b) takes an input a and then another input x basically?

w(b)(a)(x) = f(a,b,x)?

w(B) returns a function which, given f, returns another function which takes x, then applies the B higher order function to f x times, then plugs x into the resulting equation

Oh okay

That general pattern is called the m(n) map and only goes up to ε0 = φ(1,0)

erp

lol

good try though, it is a fun one

I couldn't golf it down to 100 bytes in Ruby though

How do I go higher? Create a third order function that diagonalizes the second order function?

Yeah, that gives you m(0), m(1), m(2), m(3), etc.

Each diagonalizes over "lower order" functions

And has a limit ε0

;)

so does m(0), m(m(0)), m^3(0), m^4(0) get anywhere farther?

Or is that still stuck behind the epsilon numbers?

m(m(0)) isn't a thing

erp

m(0) = !

In your thing

m(1) = w

m(2)(f)(g)(h)(n) = f(f(...f(g)...))(h)(n)

I think I could use some literature about this topic

With n iterations of f ofc

I can try to explain the Goodstein sequence if you want.

It goes to the first epsilon number and makes for a good introduction for the Hardy hierarchy.

How should I go farther? Slay some hydras?

the Lifetime of a Worm answers are already hydras

and they are almost the best one can reasonably manage under the restrictions.

If you want, I can explain my program to you. The one Steven H and I used that is.

So what's m(3) and m(n) in general?

m(3)(f)(g)(h)(i)(n) = f(f(...f(g)...))(h)(i)(n)

with n iterations of f

In general m(k) takes k+1 functions as inputs and an n as an input.

Iterates first function n times onto the second function, and then goes from there.

I suppose I could program that using eval now that I think about it...

For some approximations:

Say how do you do the big code block again?

[ctrl]+k?

Julia has variadics and a dynamic type system, if that helps

no idea what that means I'm a math guy

lol

f(x...) turns x into an iterable list within f

Actually wait I can just do that with iterables directly

f_0 = n ↦ n+1
f_1 = m(0)(f_0)
f_2 = m(0)(m(0)(f_0))
f_3 = m(0)(m(0)(m(0)(f_0)))
f_ω = m(1)(m(0))(f_0)
f_ω+1 = m(0)(m(1)(m(0))(f_0))
f_ω+2 = m(0)(m(0)(m(1)(m(0))(f_0)))
f_ω+3 = m(0)(m(0)(m(0)(m(1)(m(0))(f_0))))
f_ω2 = m(1)(m(0))(m(1)(m(0))(f_0))

And as for the big code block, I just use the gui, highlight the text in question, and select the two curly brackets

I dunno how to do it in chat

Highlight all the text and do [ctrl]+k

Or just add 4 spaces to the beginning of every line of interest.

Let's say I can wrap my head around how Julia does things and successfully program a list n -> x, where x is a list consisting of a number, then a first order function, then a second order function, then a third order function, and so on, n times. Could I use this to break out of Cantor normal form?

f_ω1 = (m(1)(m(0))(f_0)
f_ω2 = m(1)(m(0))(m(1)(m(0))(f_0))
f_ω3 = m(1)(m(0))(m(1)(m(0))(m(1)(m(0))(f_0)))
...
f_ω² = m(1)(m(1)(m(0))(f_0))

There's no need to actually use Cantor normal form since we're writing a program.

And you are saying you plan on making the m(k) map function?

If so, yes, it aligns naturally with the fast-growing hierarchy's diagonalization.

Would employing q(n)= [number, number -> number, (number -> number) -> (number -> number), ...etc] and then m(n)(q(n)...), where the splatting plugs in arguments from the end successively to the beginning, get me farther?

I don't think so?

And I get that my score is actually f_ω³(127)?

yes, was about to say that :P

Basic recursive schemes will only get you so far

.-.

Time to break out the visitor pattern and have a visitor count the number of branches of the ordinal fundamental sequence tree?

Probably :P

Basically you have normal arithmetic:

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

Note: addition and multiplication are not commutative.

(Which is equivalent in power to hydra slaying, if my intuition is correct and the tree traversals of the visitor are equivalent to the tree transforms of the hydra slayer)

(I'm not really good with hydras, so I can't help you much there)

In essence, whenever ω is at the right-most of an expression, you replace it with n, where n is the argument.

Time to cook up an ordinal fundamental sequence cookbook

For example,

f_ω^ω (2) = f_ω^2 (2)

Replacing the literally right-most ω with 2.

then ω^2 = ω^(1+1) = ω*ω

replace the right-most ω with 2 again:

f_ω*2 (2)

ω*2 = ω*(1+1) = ω+ω

replace the right-most ω with 2 again:

f_ω+2 (2)

Ends with +k for finite k, so we iterate after subtracting 1.

f_ω+1 (f_ω+1 (2))

f_ω+1 (f_ω (f_ω (2)))

mhm

f_ω (2) = f_2 (2)

and the rest is pretty straightforward.

Try writing out f_ω^(ω^ω) (2)

one step at a time so I can point out if you've made a mistake

= f_ω^(ω^2)(2)

=f_ω^(ω*ω)(2)

=f_ω^(ω*2)(2)

=f_ω^(ω+ω)(2)

So far so good?

mhm

=f_ω^(ω+2)(2)

=f_ω^(ω+1)(f_ω^(ω+1)(2))

no

Has to be f_(x+1)

for the iteration step

Otherwise you have to apply da rulez

Argh

Lemme try again

f_ω^(ω+ω)(2)

=f_ω^ω*ω^ω(2)

no

well yes

but you don't want to expand like that

f_ω^(ω+ω)(2)

programming that is much harder than strictly following the rules I laid out (at least in my opinion)

Note: I only complained about you iterating earlier.

Keyword: only

Okay, well what was the rule for reducing ω^(ω+n) again?

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

And then ω^(ω*n)?

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

ω is a limit ordinal, so I can't really take one from it without causing problems

What step are you on?

Yeah

Your a^(b+1) rule doesnt do much about ω^(ω+ω)

If ω is on the right-most side, replace it with n.

f_ω^(ω+2)(2)

f_ω^(ω+1)*ω(2)

mhm

f_ω^(ω+1)*2(2)

=f_ω^(ω+1)+ω^(ω+1) (2)

=f_ω^(ω+1)+ω^ω*ω (2)

mhm

=f_ω^(ω+1)+ω^ω+ω^2(2)

mhm

mhm

=f_ω^(ω+1)+ω^ω+ω+2(2)

=g(g(2)), where g(x)=f_ω^(ω+1)+ω^ω+ω+1(2)

well anyways seems like you get it

At this rate, if I expanded the whole thing out, my ctrl key would be broken by the time I get to a finite number

ofc, it wouldn't be interesting otherwise ;P

My approaching to reaching the Fefermann-Schutte ordinal is a rather natural extension to this

cuz u know, why stop at exponentiation

<.<

I think I'll be using fundamental sequence traversals for bignums beyond the 100-character one

>.>

I'm going to need that indirection to get anywhere far

I still want some scaffolding so that I don't accidentally point a structure back at itself and create an infinite loop. Are there typed lambda calculi that can reason beyond epsilon zero?

@eaglgenes101 you mean the m(n) extended beyond ε0?

Hell, I might just use a proof system and treat it as a programming language via the curry howard isomorphism

>.>

So diagonalizing over m gets me... where exactly?

Epsilon zero?

@eaglgenes101 yes

f_ε0(n) = m(n)(m(n-1)(m(n-2)(...m(1)(m(0)(f_0))...)))(n)

er wait no, it's not that

f_ε0(n) = m(n)(m(n-1))(m(n-2))(...)(m(1))(m(0))(f_0)(n)

there we go

I'm cooking up an ordinal cookbook for bignum challenges

o.o

Julia is more strongly typed than python in that if you want a composite type, you can't just stick attributes on a generic object

You have to declare it explicitly

mhm

Ruby duck typing ftw

:P

In return, the runtime has a far easier time figuring out types since new types can't just be formed out of nowhere

runtime not really practical here tho :P

Coming up with a good ordinal type hierarchy that works well with Julia is a nice change of challenge

>.>

How far have you gone?

(or will go?)

You can find me somewhere before the church kleene ordinal

lol

Is it just me, or does repeated diagonalization have a pattern of alternating between ω-limits and fixed points?

*increasing layers of metadiagonalization

editing on the phone is a pain

That's pretty much how it works

meanwhile trying to create the m(n) map in Ruby

YEHAAAA

I did it!

AFAICT it works

Let k(a,0) = a and k(a,n) = k(a!,n-1). how can I rank k(9,505)?

(for reference this is the program, and the first ! invokes the function)

@ConorO'Brien ! is the normal factorial?

If so, k(9,505) ≈ 9↑↑505 ≈ f_3(505) in the fast-growing hierarchy.

Um

In other words, it'll be at the bottom of the leader-board.

Hmm ok

xD yeah sorry

I think could be second if I tried

sorry that sounded rude

lol