Ordinality?

Simply Beautiful Art

19:25

Heyo @StevenH.

Shall we start from the top?

Steven H.

Howdy! I realized that my recursion was broken and fixed it just now, so I'll be using the new one moving forwards.

Simply Beautiful Art

Yeah sure

So we start with 26 letters

Then you permutate them and interpret them as base 256 digits.

Permutation(26 letters) ~ 26! ~ 26^26

Steven H.

Yup

Simply Beautiful Art

base 256 ~ 256^(26^26)

factorial ~ 256^(26^26)! ~ 27^27^27^27

Generate all the permutations of all the permutations of...
                         ... (repeat Q times) Q, then turn that into a string
                         and take the result as a number.

Steven H.

and then we do "C`.pF"

that 27^27^27^27 times

Simply Beautiful Art

19:29

So we start over with 26 letters?

And permutate it 27^^4 (faster notation) times?

Steven H.

yup

Except the second iteration it'll be a number

Simply Beautiful Art

If so, then the result is approximately 27^^^(27^^4)

Or no

Hm

Steven H.

Sorry, no I misunderstood

Simply Beautiful Art

Yeah, it should be ~ 27^^^27^^4?

Let's do it with 2 letters?

Permutate("AB") -> "A", "B", "AB", "BA"?

Steven H.

only full permutations, so "AB", "BA"

Simply Beautiful Art

19:32

Okay

Steven H.

pyth.herokuapp.com/?code=.p%22abc%22&debug=0

Simply Beautiful Art

okay

pyth.herokuapp.com/?code=.p.p"abc"&debug=0

And we apply this .p Q times?

Steven H.

Yup, and then we do the stringification/base256 interpretation

and then repeat all that 27^^4 times

Actually, you know what, I can do a little better

I'm going to set Q to be the 27^^4 before it enters into that statement

Simply Beautiful Art

Then the result should be
~ 27^^^27^^4

42 secs ago, by Steven H.

I'm going to set Q to be the 27^^4 before it enters into that statement

Effect?

Oh, we're doing permutations of Q?

then
~ (27^^4)^^^27^^4

I think

Steven H.

All right. So we set Q to ~ (27^^4)^^^27^^4, and then iterate from 0 to ~ (27^^4)^^^27^^4 separately (counting up using f_0)

Each iteration, we define a function y

(that's what the L's for, it specifically defines a function named y)

Simply Beautiful Art

19:40

ah

Steven H.

I'll grab the current iteration of it right now: L&b=+Q.v*"C`.pF".!C`.pC`ytb

Ah, the backticks are breaking it

Simply Beautiful Art

> and then iterate

Iterate what?

Don't mind

I can read it from the main post

Steven H.

Iterate what doesn't matter because I don't ever use the loop variable in the loop statement

Technically it's an integer N, but Q>>>>>N so no point in using N ever

Simply Beautiful Art

lol, okay

Steven H.

Each iteration it defines a new y and then does a lot of repetitions of that, basically

Simply Beautiful Art

19:44

Hm

Do you have a really small known value of y?

e.g. y(1) or y(0)?

Steven H.

It memory errors on y(1)

Simply Beautiful Art

And then this y behaves from there like y(Q) = all_that_string_stuff(y(Q-1))?

RIP whatever lol

Steven H.

y(0) is the base case, will return Q

err

0

Simply Beautiful Art

more or less, y(Q) will basically apply the string stuff above Q times?

Steven H.

y(b) does the string stuff y(b-1) times to Q, adds the result to Q, and sets Q to the new result before returning it

Simply Beautiful Art

19:48

Oh hm, your number is probably going to be a bit bigger than I had thought :D

Steven H.

:D

Simply Beautiful Art

Oh, okay

Hm, let's see...

Steven H.

It builds a string that has y(b-1) instances of the string stuff, which gets autofilled with Qs when I execute it with .v

that's why I need Q to be the variable I'm using for all of the large-ordinal storage

Simply Beautiful Art

string_stuff(x) ~ 10^^^(x^^4) ~ 10^^^x
y(b) ~ 10^^^^y(b-1) with a Q on top

y(b) ~ 10^^^^^b

And apply this y thing 230 times

score ~ 10^^^^^230

I think

The particular base 10 is insignificant compared to the exponent btw

Steven H.

Remember, y(b) starts always with Q instances of permutation on whatever Q is (which is the new Q that was set from y(b-1)) , and then it repeats that y(b-1) times. The number of times it's doing the repetition isn't the same as the number it's starting from (Q, in this case)

And also, we're not just applying it 230 times

Simply Beautiful Art

19:54

gosh dang it lol

So y(b) applies the iteration y(b-1) times?

Steven H.

Yeah

Simply Beautiful Art

Then y(b) ~ 10^^^^^b :P

Steven H.

We're applying y((y(y(...y(Q))))))))))))) Q times, [and then applying it to Q again that many times,] (repeat the last statement 228 times).

Simply Beautiful Art

New Q each time, correct?

Steven H.

:P Fair enough, I keep forgetting the old value of Q is insignificant compared to the new - yeah, new Q each time

or whatever the new value was set from the last time y got called

Simply Beautiful Art

19:57

In function iteration notation, you're applying Q = (y^Q)(Q) 230 times?

Steven H.

Yeah

Simply Beautiful Art

K

Steven H.

And then that's just one iteration of the for loop :D

Simply Beautiful Art

(y^x)(x) ~ 10^^^^^^x
230 times ~ 10(^7)230

for loop does what here?

Steven H.

Repeat that, starting from defining y, each of the (27^^4)^^^27^^4 times that the for loop iterates

Simply Beautiful Art

19:59

(p.s. does it bother you how fast I do these mind boggling large num calculations?)

Oh, okay

230 is a fixed value?

Steven H.

Yeah, at that point I got tired of thinking about how to use more evals to make that dynamic

I could probably make it bigger just by making it Q times, but :P

Simply Beautiful Art

Haha, same. Have you seen the end of my code?

Steven H.

x.times{

In terms of how fast, I imagine you're a lot more practiced with this than I am. I don't have any background in large numbers whatsoever

Practice builds speed

Simply Beautiful Art

final result? ~ 10(^7)((27^^4)^^^27^^4)

Yeah true. I also have a good eye for recursions like this

In terms of the fast growing hierarchy, this is approximately f_8(Q)

You can approximate Q ~ f_4(f_3(4))

Steven H.

I... I have a ways to go then

Simply Beautiful Art

20:03

Huh?

Oh, yeah

x'D

But creativity is fun nonetheless

Steven H.

Indeed

Simply Beautiful Art

Would you like to know how finite values of the fgh works?

It's not too terrible, I could definitely explain it here.

Steven H.

Sure

Simply Beautiful Art

f_0(n) = n+1
f_k(n) = apply n times f_(k-1) to n

That's all it does

x'D But it gets really big really fast

Steven H.

So f_1 is n+n?

Simply Beautiful Art

20:06

f_1(n) = n+1+1+1+... = n+n = n*2
f_2(n) = n*2*2*2*... = n*2^n = n<<n

Yeah

And then you get to f_3 and above

It's as strong as the Ackermann function

Then you get to this silly f_w(n) = f_n(n).

It doesn't seem like much, but then you have f_(w+1)(n) = n applications of f_w to n.

Steven H.

Is that what I'd get if I actually bothered to eval *"yF" Q?

Or am I misreading

Simply Beautiful Art

e.g.
f_(w+1)(2)
= f_w(f_w(2))
= f_w(f_2(2))
= f_w(2<<2)
= f_w(8)
= f_8(8)
...

I'm not sure if it's what you'd get

But without two arguments, it's pretty hard getting this far.

Btw, if you know Graham's number, it's approximately f_(w+1)(64).

eval *"yF" Q
Does this call yF Q times?

Steven H.

It's basically what I did 230 times, except Q times instead

Simply Beautiful Art

It wouldn't improve your number significantly :(

could you do something like eval *"eval *"yF" Q" Q?

If you could, each application of eval would probably move you up one step in the fast growing hierarchy

Steven H.

I fail to see the difference between that and eval *"yF" (Q^2)

Simply Beautiful Art

20:15

I meant that it should apply eval *"yF" Q a lot of times

The difference is that the value of Q goes up after each eval

Steven H.

Ah

Simply Beautiful Art

Makes a big difference lol

Steven H.

I think there's a trick I could use for that, but I couldn't do that vanilla, eval is only for one expression

Simply Beautiful Art

Unfortunate lol

Could you reapply the L line?

With the new Q value?

Steven H.

The L line, thankfully, pretty much auto-updates with Q

because y(1) returns Q+(whatever y(1) was going to return before)

Simply Beautiful Art

20:20

No, I mean on the L line, you've got something along the lines of for 0..Q do ...

The Q in the for gets fixed.

Steven H.

Ah

Simply Beautiful Art

So apply that a whole bunch

and you move up one level in the fgh

Steven H.

I could, probably, but it's easier to .v+"s["*".v*\"yFC`\"Q"

Simply Beautiful Art

translate :P

Steven H.

which is the trick I was talking about

basically eval (summing Q versions of eval *"yF" Q )

Simply Beautiful Art

20:22

k

Q times ~ 10(^7)Q

final result ~ 10(^8)(original Q) ~ f_9(Q)

Q = (27^^4)^^^27^^4

Woo

Amazing how much a subtle change can do

Steven H.

And now I have ~440 free bytes to work with!

pyth.herokuapp.com/…

Simply Beautiful Art

x'D

So beyond f_(w+1) there lies f_(w+k), and beyond that lies f_(w2)(n) = f_(w+n)(n), and beyond that lies...

Steven H.

Curiousity... what happens if I move that inside the definition of y

Simply Beautiful Art

Move what inside y?

Steven H.

.v+"s["*".v*\"yFC`\"Q"

Simply Beautiful Art

20:28

I'm afraid you'll most likely get an infinite loop.

y(Q) = recursion over y(x), where x<Q

Steven H.

Hm...

Simply Beautiful Art

Always follow that rule to ensure a terminating recursive function

Steven H.

.v+"s["*".v*\"yFC`\"tb"tb

now it's b-1 instead of Q

Simply Beautiful Art

Hm...

Then it's weaker, unless b is able to spike up a lot.

Or hm

Steven H.

I mean, I'll keep the outside version too that iterates over Q

And b starts at Q

With numbers this large I doubt -1 makes a difference

Simply Beautiful Art

20:30

Wait, explain it to me more broken down

-1 makes all the difference, it's how you go down to your base case to end the program :P

Otherwise you'll fail to terminate most likely

Steven H.

L&b=+Q.v*"C`.pF".!C`.pC` .v+"s["*".v*\"yFC`\"tb"b

So the string_stuff(TM) y(b-1)+y(b-1)+...+y(b-1) times, where there's `b` instances of `y(b-1)`

Simply Beautiful Art

And b = Q initially

Do you reapply this multiple times?

Steven H.

b = Q when we call it outside, yeah

We apply it as
.v+"s["*".v*\"yFC`\"Q"

Simply Beautiful Art

FYI, there's not much affect in doing y(b-1) + y(b-1) + ...

unless that comes naturally, it's enough to just do the string_stuff

Steven H.

reason why I can't just say it's a multiplication is because each of those is going to return more than the last, seeing as it relies on the value of Q and each also sets Q

Simply Beautiful Art

20:35

Ah

y(b) isn't a function per se, but an operation that changes the global Q?

Steven H.

It's both

Simply Beautiful Art

or whatever yeah

Steven H.

Well, not in the mathematical sense I guess

Simply Beautiful Art

I managed to reach f_(w^3)(65000) using a global Q like you did, and 3 arguments in a function like you're y(b).

In Ruby I mean

Steven H.

Yeah, but I think it helps a little that you know the stuff :P

Simply Beautiful Art

20:37

Why not do y(b-1) + y(b-1) + ... Q times?

Or is it the same? O.o

@StevenH. Yeah it does :P

Though if you give it a good look, the fast growing hierarchy really isn't terribly complicated.

Steven H.

I... I could

I could do it Q times

Simply Beautiful Art

Would probably work out better? :P

Steven H.

Maybe, yeah

I can't think of anything exciting to fill the space with now

Simply Beautiful Art

haha

512 bytes is a lot for a codegolf site, isn't it?

Steven H.

I have 418 bytes of space and nothing to do with them >_>

I mean, it's not a lot for Java

but for Pyth it's a ton

Simply Beautiful Art

20:49

Does Pyth support arrays?

or lists

Steven H.

Yeah, that's how it's representing the permutations

Simply Beautiful Art

Oh right

Steven H.

Pyth can do basically anything Python can do, it just has a bunch of builtins that make it easier for me to work with than Python

Simply Beautiful Art

Oh, right x'D

Steven H.

:D

Simply Beautiful Art

20:51

Well

I'll say that in my experience, if you want to come anywhere near me, arrays will become almost necessary.

I basically write really big ordinals like w^w in terms of arrays and throw them into a function

Steven H.

almost?

Simply Beautiful Art

Almost = sure, it's possible to do this stuff without arrays, but you'll probably kill urself over how difficult it would be.

23

Q: Output the simplified Goodstein sequence

A number is in base-b simplified Goodstein form if it is written as b + b + ... + b + c, 0 < c ≤ b The simplified Goodstein sequence of a number starts with writing the number in base-1 simplified Goodstein form, then replacing all 1's with 2's and subtracting 1. Rewrite the result in base-2...

Instead of writing a number in base b as b+b+b+...+c, imagine writing it as (b^k)*a_k + (b^k-1)*a_k-1 + ... + a_0

From there apply all the same rules

The resulting sequence grows to be as long as f_x(n), where x = w^w^w^w^...n powers of w.

Variations of this can go even further.

But there's a really big scary limit to how far you can go with this

And it's far below my number.

You don't mind me talking about this?

Steven H.

Not at all

I mean, that's what I made the room for

Simply Beautiful Art

A number is in base-0,b SGF if it is written as b + b + ... + b + c, 0 < c ≤ b

The 0,n SG sequence takes a number in base-0,1 SGF, changes all the 1's into 2's, and subtracts 1. You then write the result in base-0,2 SGF, and change all the 2's into 3's and subtract 1. Repeat until you hit zero.

G(0,n) is the amount of "subtracts 1" are required for you to reach zero, starting at n.

A number is in base-1,b SGF if it written as G(0,b) + G(0,b) + ... + b + b + ... + c, 0 < c ≤ b

G(1,n) is how many "subtracts 1" are required for this to reach zero, where b->b+1 and you can use G(0,b), starting at n in base 1.

G(2,n) allows for things written in the form G(1,b) + G(1,b) + ... + G(0,b) + ... + b + ... + c

etc.

Steven H.

Can I have a concrete example for, say, G(1,9)?

Simply Beautiful Art

21:04

How fast does G(n,n) grow? :-)

G(1,9) says take 9 and write it in base 1.

Steven H.

So 1+1+1+1+1+1+1+1+1

Simply Beautiful Art

Before hand, let's deal with G(0,1)

No, that would be G(0,9)

1
send 1's to 2's -> 2-1 = 1
send 2's to 3's -> 1-1 = 0

So G(0,1) = 2 steps

Steven H.

okay

Simply Beautiful Art

G(1,9) would start out as follows:

G(0,1) + G(0,1) + G(0,1) + G(0,1) + 1

-> G(0,2) + G(0,2) + G(0,2) + G(0,2) + 2 - 1

Steven H.

Oh

OH

Simply Beautiful Art

21:06

So you can see where this is going?

:D

Steven H.

Upwards. Quickly.

Simply Beautiful Art

Oh, and the first index on G never changes

Meh, it's not terribly terrible actually

IIRC G(0,n) = 2n

Or no

Steven H.

I mean, before all this I thought n! increased quickly

Simply Beautiful Art

lol

Jeez, I used to remember the exact formula for G(0,n)

Steven H.

I'm sure it's on OEIS

Simply Beautiful Art

21:09

G(0,2)
1+1
2+1
3
3
2
1
0

It's probably not actually

grows way too fast

G(0,2) = 6

Speculation: G(0,n) = 2^(n+1)-2

Yup

Found that formula

Steven H.

hurrah

Simply Beautiful Art

Well anywho, I'll just tell you... G(1,10) is probably already way bigger than your number.

That's how crazy this scheme is.

Let's try G(1,2)

G(0,1)
G(0,2)-1 = 5 = 2+2+1
3+3
4+3
5+2
...
7
7
6
...
0

Not too bad.

14?

Oh right

G(1,10) is probably smaller than your number x'D

But G(10,10) is definitely bigger

Steven H.

Well then

Simply Beautiful Art

G(1,3):
G(0,1)+1
G(0,2)+1
G(0,3)
G(0,4)-1 = 29 = 4*7+1
5*7
6*6+5
...
11*6
12*5+11
...
33*5
...
67*4
...
1087
1087
1086
...
0

G(1,3) = 2176

It grows, like, exponentially exponentially.

That is, G(1,n+1) ~ 2^G(1,n)

Crazy notations huh?

Very innocent looking sequences at first

G(0,n) = 2n

And then you get to G(1,n) lol

And this is where I'd introduce G(1,0,n)

In base-1,0,b write a number as G(b,b) + G(b,b) + ... + G(n,b) + ... + G(n-1,b) + ...

where n<b

And then you can see this gets a wee bit crazier

Steven H.

New strategy inspired (partially?) by this: define a new variable Y -> [Q,Q,Q,Q....Q] (where that's of length Q), and (Y = [Y]*Q)_Q... Oh dear

Simply Beautiful Art

21:21

lol, what's that supposed to do?

(Y = [Y]*Q)_Q

Steven H.

In ruby I guess it'd be Q.times{Y=[Y]*Q}

Simply Beautiful Art

Oh, so we're doing Y = [Y,Y,Y,..]

Steven H.

yeah

Simply Beautiful Art

:| But what's that supposed to do?

>.>

Just make a lot of nested Q's?

Hm, gtg, will be back before the next hour probably.

Steven H.

A lot of nested references to Q. After we set it up, we can reduce on some other fast-growing function and at each point update Q

Well, fast-growing function of two variables

Simply Beautiful Art

21:24

:P

Btw, you know the Ackermann function?

Steven H.

I've heard of it

Simply Beautiful Art

The simplicity of recursion is astounding, as it beats your current number.

Look it up, fairly simple rules, but much much big

Ack(n,n) ~ f_w(n)

Steven H.

That's probably pretty efficient for me to do, actually

in terms of bytes

M?G?HgtGgGtHgtG1hH

g is the Ackermann function there

M?G?HgtGgGtHgtG1hH).v*"gF"Q

Simply Beautiful Art

21:45

back

And great

Steven H.

Let a(b) = g(...g(g(g(0,1),2),...b), where g is still the Ackermann function. I'm doing a_Q(Q)

Simply Beautiful Art

Funny that you do that

4

A: Largest Number Printable

Haskell - Ackermann function applied to its result 20 times - 99 characters This is the best haskell solution I can come up with based on the ackermann function - you may notice some similarities to n.m.'s solution, the i=round$log pi was inspired from there and the rest is coincidence :D i=rou...

A similar Ackermann nesting thing

And you could most likely manage to make an Ackermann post there

Steven H.

I'm at 122 bytes right now, so I'd have to cut out a lot of things

Simply Beautiful Art

Yeah

The main reason I'm hosting this challenge is because 100 bytes is just too small to do anything serious.

Steven H.

with the ackermann nesting that I'm doing, how do I stack up against famous numbers?

Simply Beautiful Art

21:51

a(64) < Graham's number < a(65)

Not many more famous numbers in this area until you get way bigger.

g(n,n) ~ f_w(n)

a(n) ~ n applications of n=g(n,n) ~ n applications of n=f_w(n) = f_(w+1)(n)

Repeated applications of n=a(n) will get you up to f_(w+2)(n)

etc.

Generalized enough and you can get to f_(w2)(n) = f_(w+n)(n)

Steven H.

I'd hope that I'm a little bigger than g(n,n) with the nesting

But I guess not enough to stack up against f_(w+3)?

Simply Beautiful Art

Nope

Steven H.

Funnily enough, it's more byte-efficient for me to do the nesting than to not do the nesting

so I'm keeping it regardless

Simply Beautiful Art

You'd have to generalize some function such that a(k,n) = n nestings of n=a(k-1,n), where a(0,n) = a(n)

If you'd like a tip from me on how I did one of my past programs...

In ruby, I took advantage of something along the lines of n.times{puts all the functions in here}

Steven H.

By the way, I have no clue how ψ_0(X(Ω_(M+X_(Ω_(M+1)^Ω_(M+1)))))+29 compares to any of the numbers we've been talking about

Simply Beautiful Art

21:56

Haha

Yes... you have no clue indeed....

Want to try and just start comprehending the madness of that?

Steven H.

Sure :P

Simply Beautiful Art

Btw

Did you know that my program doesn't apply any sort of n.times{} in the major portions of my code?

I'll show you the Hardy hierarchy, which is what I implemented.

H(0,n) = n
H(x+1,n) = H(x,n+1)
H(x,n) = H(x[n],n) if x is a limit

Steven H.

> if x is a limit

elaborate?

Simply Beautiful Art

ω (w) is a limit

remember how f_ω(n) = f_n(n)?

Transcript for