ConwayLife.com

fluffykitty wrote:All versions of MATRIXPARTY(3) and CUBEPARTY(3) are infinite. The sequence is

Code: Select all

|2|
|1 1|
|1 1|

followed by extensions of

Code: Select all

|1 1 0 0 0|
|1 0 1 0 0|
|0 1 0 1 0|
|0 0 1 0 1|
|0 0 0 1 1|

(Element (x,y) is 1 iff x=y=0, x=y=max, or abs(x-y)=1)

testitemqlstudop wrote:

fluffykitty wrote:All versions of MATRIXPARTY(3) and CUBEPARTY(3) are infinite. The sequence is

Code: Select all

|2|
|1 1|
|1 1|

followed by extensions of

Code: Select all

|1 1 0 0 0|
|1 0 1 0 0|
|0 1 0 1 0|
|0 0 1 0 1|
|0 0 0 1 1|

(Element (x,y) is 1 iff x=y=0, x=y=max, or abs(x-y)=1)

No, cubeparty is finite.
I said you can take the cube, CUT it, TRANSLATE it, and ROTATE it, and if after some cutting/rotating/translating one piece (one cut piece) matches a previous cube it's disallowed.

testitemqlstudop wrote:Yes you can cut out the middle through this process: cut front side, cut behind side, cut top, cut bottom, cut left, cut right, and then you have the middle.

| a b c |
| d e f |
| g h i |

| a c |
| g i |

3

1--2

1. That the second term in the sequence is not a minor of graphs containing isolated islands each consisting of a single label, but for which different islands can have different labels (as in the following example):

   Code: Select all

   2--2--2--2--2
   
   1--1--1
   
   2  2  2
   
   1  1

   Hence the sequence that would have generated SSCG(3) now generates a far larger number, although probably not approaching the order of SSCG(4) or even TREE(3).
   
   And,
2. That taking the second term to be

   Code: Select all

   2-2

   can actually lead to very long sequences consisting of vanilla-SSCG-type graphs with a single substituted 2-labeled node, similarly to the following:

   Code: Select all

   3

   Code: Select all

   2--2

   Code: Select all

   2  2  2

   Code: Select all

   2  2

   , followed by the optimal SSCG(5) sequence with one arbitrary node in each graph labeled as 2 instead of 1 (for instance). This gives a phenomenally weak lower bound for LSSCG(3) as SSCG(SSCG(5)+4)+SSCG(5)+4. (Obviously the singly-substituted version of SSCG(5) will almost certainly be much larger than the standard SSCG(5).)
   
   Eliminating the

   Code: Select all

   2  2

   term and continuing with a doubly-substituted sequence yields a much stronger lower bound (possibly an actual approximate value) for LSSCG(3) on the order of SSCG(SSCG_s(SSCG_s(4, 2),1)), with SSCG_s(M, N) referring to the exactly-N-times-substituted version of SSCG(M) with at most one substitution per island, but even determining any kind of bound on SSCG_s(4, 2) or whether or not it is greater than SSCG(4) is too much for my ability to visualize.

fluffykitty wrote:It's probably at most w^3.

fluffykitty wrote:You either need infinitely many arguments (which will lead you down the array notation path) or more complex methods.

fluffykitty wrote:Well, you can do something like my f function, where you encode FGH levels as numbers, or do stuff like VECTORPARTY or TREE. I don't think there's any other way to get high FGH levels without doing one of those or using array notation methods like in BEAF.

fluffykitty wrote:One thing that may be useful is that p(a,b)=2^a*(2b+1) is different for all (nonnegative integer) values of a and b, so you can encode two numbers into one. Also, it never outputs 0, so you can do something different in that case. Using that, you can encode arbitrary binary trees into nonnegative integers.

fluffykitty wrote:One possible method of encoding ordinals as binary trees is to use a leaf node to represent 0 and a branch node to represent b+w^a, where a and b are its children. For example, 1=0+w^0 would be (()()) using a linear representation of trees. 2=1+w^0=(()(()())), w=0+w^1=((()())()), w+1=w+w^0=(((()())())()), etc. Using this representation, you can get a function that grows faster than any FGH level below e0 (=w^w^w^...). For levels of the form 0 or a+1, you can do what you normally do, and for other levels you can use fundamental sequences. The rules for fundamental sequences are (b+w^(a+1))[n+1]=((b+w^a)+w^(a+1))[n], (b+w^a)[n]=b+w^(a[n]) if the previous rule doesn't apply, and (b+w^a)[0]=b if the previous rules don't apply. The useful property of fundamental sequences is that for any ordinal a, an ordinal b is less than a if and only if it is less than a[n] for some n. If you set n=x, then the resulting function will eventually outgrow any instance with lower ordinal input for large enough x, since a[x] will eventually be greater than any ordinal less than a. A method like this one is used in my f, but with a much stronger ordinal notation based on ordinal collapsing functions.

Moosey wrote:

fluffykitty wrote:trees

So how would I use that to make a vgç function? Or would it be better just to define a new, simpler function?

fluffykitty wrote: A good start would be to make a function for computing fundamental sequences in this tree representation. Also, if possible, simplifying functions is usually a good idea.

()

(()())

(ord(1), ord(0))

(ord(0), ord(1))

(ord(2), ord(0))

(ord(0),ord(2))

(ord(1), ord(1))

(ord(0),ord(3))

(ord(3),ord(0))

(ord(0),ord(4))

(ord(1),ord(2))

(ord(0),ord(5))

(ord(2)ord(1))

(ord(0),ord(6))

(ord(1),ord(3))

we all know what’s going on for a Mersenne not-necessarily-a-prime

(ord(4),ord(0))

(ord(0),ord(8))

(ord(1),ord(4))

(ord(0),ord(9))

(ord(2),ord(2))