User blog:SuperSpruce/The T Array Function Part 5: Arbitrary Comma T Function (ACT)

Here is the T array function, which now includes Double Comma arrays. This should reach ψ(Ωω).

Attempt 1 at definition

A string is any expression in the outer brackets that is a number, comma, dimensional separator, or bracket with any subscript.

An entry is a integer greater than or equal to 0.

#, #' , % , and %' are any strings (can be empty) @ is any non-empty string.

$ is any number of opening brackets (can be 0 opening brackets)

Entry a is at Layer x, where x is the amount of curly braces an entry is enclosed by. The base layer is x=0.

Parentheses disambiguate certain expressions; they do not mean a different array altogether.

Rules: [APPLY IF POSSIBLE BEFORE STARTING SCANNING PROCESS]

1. Base Rule: Tn[0]=n+1

2. Recursion Rule: Tn[$a#]=TT ... T T n[$a-1#] [$a-1#] ... [$a-1#] [$a-1#] with n T’s.

3. Tailing Rule: [@{#}0]=[@] There cannot be anything after the 0. This rule still applies when the brackets are braces (denoting dimensional separators). {#} can be a n’th-degree separator (n comma or {%,,...,,}) as well.

4. Preceding rule: [0[ = [[ (delete the 0)

5. Fixed-Point Rule: [0] in an expression inside the outer brackets becomes n. For example: Tn[ [0] ]=Tn[n].

6. Meta-Fixed-Point Rule: [0]g becomes n{n{n{.....{n{n,,,...,,,}n,,,...,,,}.....}n,,,...,,,}n,,,...,,,}n with n sets of curly braces, and there are g-1 commas at the end of the dimensional separators.

7. Comma Rule: {0,,,...,,,} (with g commas after the 0) becomes g commas (no entries between them).

However, the other rules will require a scanning process to check when they will be applied.

Now comes the scanning process. Start at the first entry in the brackets.

A. If the entry is 0, jump to the next entry at that layer. Then check that entry (return to the beginning of step A).

B. If the entry is not 0, then check what is immediately before it.

Ba. If a comma is immediately before it, then apply the catastrophic rule. The process ends.

Bb. If g commas (where g is an integer so that g≥2) is immediately before it, apply the meta-catastrophic rule. The process ends.

Bc. If a [ is immediately before it, check what is immediately before that.

Bd. If that is a comma, return to step Ba. If that is g commas (g≥2), return to step Bb. If that is a [, return to step Bc. If that is a }, go to step C.

C. If a } is immediately before it, follow these steps. The initial array will be [#{@}$c%]. Note that the array can have any subscript.

Ca. Turn [#{@}$c%] into [#{@}1{@}$c-1%]. Note that both {@}'s are the same.

Cb. Then jump to the first entry of the former {@}. This will be denoted as d in {$d#’}

Cc. If d is not a 0, apply the dimensional array rule. The process ends.

Cd. If d is a 0, jump to step A.

Dimensional Array Rule and Catastrophic Rules:

8. Dimensional Array Rule: Tn[#{$d#'}1%]=Tn[#n{$d-1#'}n{$d-1#'}n...n{$d-1#'}n{$d#'}0%] with n n’s. The process ends.

9. Catastrophic Rule: Follow these steps. One starts with [%0,$a#]. There is no subscript of the shown brackets.

9a. Take the n from Tn and label it as s. The Tn still exists; we’re basically just copying n and calling it s. s will change later, but n will not change with it.

9b. Now find the innermost pair of brackets with no subscript that surrounds the 0 in the [%0,$a#]. That pair of brackets is the brackets shown in the [%0,$a#].

9c. Let M1 = [%0,$a-1#] and Mr+1 = [%(Mr),$a-1#].

9d. Now do this with Ms. Note that Mstakes place of the 0 in the [%0,$a#].​​​​​​​

9e. The process ends.

10. Meta-Catastrophic Rule: Follow these steps. One starts with [%0,,,...,,$a#]g (with g commas). Note that whenever I denote ,,,...,, in this rule ,,,...,, means g commas.

10a. Take the n from T_n and label it as s. The T_n still exists; we’re basically just copying n and calling it s. s will change later, but n will not change with it.

10b. Now find the innermost pair of brackets with a subscript of g that surrounds the 0 in the [%0,,,...,,$a#]g. That pair of brackets is the brackets shown in the [%0,,,...,,$a#]g.

10c. Let M1 = [%0,,,...,,$a-1#]2 and Mr+1 = [%(Mr),,,...,,$a-1#]g.

10d. Now do this with Ms. Note that Mstakes place of the 0 in the [%0,,,...,,$a#]g.

10e. The process ends.

Comparisons will be in a separate page that I will make later. When I make it, I will provide a link from here to it.

Feel free to correct me on this complicated notation if I’m wrong!