ConwayLife.com

Create fast growing array notations!

My first submission:

https://testitem.github.io/colg/arnot.html

You don't have a greed rule
TESTITEM YOU COULDN'T COME UP WITH ENOUGH RULES TO USE ALL WORDS ENDING IN -EED! YOU HAVE FAILED THE GOOGOLOGY GODS SOMEHOW

Also you used ampersands and whatever the heck these (@) are called interchangeably

Anyways, here was my first array notation I completed for multidimensional arrays, which is f_w2(n)-ish, according to fluffykitty.

Here's an extension of your rules For instance, &[5[§1]5] =
(Take a deep breath. For brevity I shall drop many &'s)
[5[§0]5[§0]5[§0]5[§0]5[§0]5] =
6@[5[§0]5[§0]5[§0]5[§0]5] =
(6 @ (6 @ 6 @ (6 @ (6 @ 6)))
(6 @ (6 @ 6 @ (6 @ ([6,6,6,6,6,6])))
...
Of course, f(x) = &([x[§x]x]) >= the f(x) you made (x@x), but...

Can anyone create a dco-based array? (and I don't mean, "make its base function dco(some ordinal+n)", I mean make it really nontrivally involve dco & ordinals)
For the sake of brevity with power, use the standard rules for fundamental sequences and not mine up to Γ_0. (I.e. feel free to use anything up to dco(the smallest ordinal we don't have a definition of fundamental sequences for + n)

Obviously there are trivial ones like "that array function we just defined, but using dco(Γ_0+n) instead of the successor function!", which would hardly add any power to the dco(Γ_0+n)

So that we don't clutter the sandbox with a zillion different googology-related threads, could we also use this thread for investigating ordinal related hierarchies?

Note: to make sure we are on stable, well-defined ground, assume all hierarchies use the fundamental sequence rules which work for n up to the largest a mentioned in each use of the hierarchy. (And, unless specified otherwise, suppose all other ordinal-based things, like dco, do as well)

Hierarchy #1: dco-based hierarchy a (i.e. #1)
Hierarchy #2: PkmnQ's multi-ordinal hierarchy:
Ę_m_n(x) = Hierarchy #3: a hierarchy that is totally appropriate for this thread, based on pkmnq's. I shall call this one "ah", or (linear) array hierarchy, for obvious reasons.

Represented as ah_n{a,b,c,d...} (finitely many entries in array)
TERMINOLOGY TIME!!!!
n is the argument
the array shall be called ü
the final argument in the array is called the "point"
the value of the function is called the hierarch
$_a shall indicate any quantity (including 0) of any arguments (we-don't-care-what-they-are kind of arguments). If a is the same thing, $_a is the same thing in all occurrences in the rules. A rule can be invoked multiple times with different $_ns however.

RULES:
1. If ah is iterated, it is assumed that ah^a_n ü = ah_ah_ah_ah_...n ü ü ü ü... with a copies of ü and ah.
Formally, define g(a,n,ü) =
ah_g(a-1,n,ü) ü, a > 1;
n, a = 0.
ah^a_n ü = g(a,n,ü)
2. ah_n{$_0,z} = ah_n{$_0}, z (the point) = 0
3. ah_n{} =n+1. That is, if ü is empty, then the hierarch = n+1
4. ah_n{a+1,$_1} = ah^n_n{a,$_1}
5. ah_n{a,$_2} = ah_n{a[n],$_2}, a a lim ord
6. ah_n{0,0,0,...a+1,$_3} = ah_(n+1){a+1,a+1,a+1,...a,$_3}, for any nonzero quantity of 0s (including, say, 1 or 2), as long as the quantity of a+1s in the resulting array is the same. (Note: did you notice the n+1? I added it because it is more like pkmnQ's thing that way, while keeping it more powerful than the fgh for multiple array entries, and also because WHY NOT)
7. ah_n{0,0,0,...a,$_4} = ah_n{a,a,a,...a[n],$_4}, a a lim ord, for any nonzero quantity of 0s, as long as the quantity of as in the resulting array is the same.

FORMALIZATION OF LAST 2 rules:
let # represent concatenation.
Specifically, {$_5}#{$_6} = {$_5,$_6}
a@b =
{a}#(a@(b-1)), b > 1
a, b = 1

formalization + relief from ALL THIS CAPITAL LETTER MADNESS here:
6. ah_n ((0@b)#{a+1,$_3}) = ah_(n+1) (((a+1)@b)#{a,$_3}), for any b > 0
7. ah_n ((0@b)#{a,$_4}) = ah_n ((a@b)#{a[n],$_4}), a a lim ord & b > 0


Question: what is the growth rate of f(n) = ah_n ((0@n)#{w+1}) ?
I have a feeling that it is very fast

Extra question: how about for larger ordinals instead of w+1, like gamma_0 or (gamma_0) +1?

Moosey wrote: October 22nd, 2019, 6:31 pm PkmnQ's multi-ordinal hierarchy:
Ę_m_n(x) =

Code: Select all

x, m=0 and n=0
Ę_m_n[x](x), n a limit ord
Ę_m_n-1(x+1) n not a limit ord
Ę_m[x]_m(x), n=0 and m a limit ord
Ę_m-1_m(x+1), n=0 and m not a limit ord

I used the E with a tail because I was experimenting with stuff, not sure if this is the right place to mention it.