Linear Threes Notation

Introduction to 2TN with examples...

T[n] = 3^n

T[1,2] = 3

so T[3] = 27, T[T[3]] = 7,625,597,484,987, T[T[T[3]]] = 3^^4

T^(n)[1] = 3^^n

T[2,2] = 3^^(T[1,2]) = 3^^3

T[3,2] = T^(T[2,2])[1] = 3^^3^^3

T[n,2] = T^(T[n-1,2])[1] = 3^^^n

T[2,3] = T[3,2]

T[3,3] = T[T[3,2],2]

T[4,3] = T[T[T[3,2],2],2]

Binary Threes Notation

2TN rules:

• Base case: T[n,1] = 3^n

• Degenerative case: T[1,n] = 1

• Reduction case: T[2,n] = T[3,n-1]

• Recursive case: T[a,b] = T[T[a-1,b],b-1]

Alternative Representations:

• T[a,b] = {3,a,b} in BEAF/BAN. 

• T[a,b] = s(3,a,b) in SAN.

Trio Threes Notation

3TN rules:

• Binary reduction: 3TN[a,b,1] = 2TN[a,b]

• Degenerative case: T[1,b,c] = 3

• Recursive case: T[a,b,c] = T[T[a-1,b,c],b-1,c]

• Prime Reduction case: T[2,b,c] = T[3,b-1,c]

• Full Reduction case: T[2,1,c] = T[3,3,c-1]

Alt. representation:

• T[a,b,c] = {3,a,b,c} in BEAF/BAN

Linear-Threes Notation

Full Ruleset:

• Deleter case: T[a,b,c,...,x,y,z,1] = T[a,b,c,...,x,y,z]

• Degenerative case: T[1,b,c,...,x,y,z] = 3

• Recursive case: T[a,b,c,...,x,y,z] = T[T[a-1,b,c,...,x,y,z],b-1,c,...,x,y,z]

• Reduction case: (array starts with 2) T[2,1,1,...,1,1,a,b,c,...,x,y,z] = T[3,3,3,...,3,3,a-1,b,c,...,x,y,z]  

(Note: the number of ones can also be zero here, this works for any case that starts with 2)

• Catastrophic case: T[2,1,...,1,1,z] = T[3,3,...,3,3,z-1]

Alt. representation:

• T[a,b,c,...,x,y,z] = {3,a,b,c,...,x,y,z} in BEAF/BAN.

Extended Threes Notation

Threes notation reaches a new level with the multi-comma delimiter, allowing deeper recursive expansion-

Base rules:

Basic Multi-commas:  

• T[a,,2] expands to T[3,3,3,...,3,3,3] (With a-1 occurences of 3.)

• Equivalent representations:

T[a,,2] = {3,a(1)2} BEAF = {3,a[2]2} BAN.

Recursive Expansion in L3N

Basic Application of L3N rules

• Example: T[3,2,,2] = {3,3,2(1)2} = {3,{3,2,2(1)2}(1)2} = {3,{3,3(1)2}(1)2} = {3,{3,3,3}(1)2} = {3,3^^^3(1)2} = {3,tritri(1)2}.

• Another Example: T[4,2,,2] = {3,4,2(1)2} = {3,{3,3,2(1)2}(1)2}

A small little explanation...

• As a little convention here (to simplify the ruleset definitions) let any a,b,c,...,x,y,z array with more than 0 entries and can also have multi-commas be #.

Extended Threes Notation Deleter Case

• T[#(,n)1] = T[#] where (,n) denotes any number of commas.

Advanced Reduction Rules: Bilinear Threes Notation (2L3N)

Multi-Level Recursive Reduction

• T[a,,n] = T[3,3,...,3,3,,n-1] with a-1 3s involved.

• Example decompositions:

• T[3,,2] = T[3,3]

• T[4,,2] = T[3,3,3]

• T[3,,3] = T[3,3,,2]

• T[3,,4] = T[3,3,,3]

Divergence from BEAF/BAN

Extended Threes introduces recursive behaviors beyond conventional BEAF/BAN notation

1. Deep Recursion Cases:

• Decomposition Case: T[n,,1,2] = T[3,,T[n-1,,1,2]]

• Special Case: T[1#] = 3 also applies so...

2. Self-Referential Growth

Example:

• T[3,,1,2] = T[3,,T[2,,1,2]] = T[3,,T[3,,3]]

• T[3,3,,1,2] = T[T[3,2,,1,2],2,,1,2]

Definitions

1. Degenerative case: T[1#] = 3

2. Deleting case: T[#(,n)1] = T[#]

3. Reduction case: T[a,,1,c] = T[3,,T[a-1,,1,c],c-1]

4. Chaotic case: T[a,,b,c] = T[3,3,3,...,3,3,3,,b-1,c] with a-1 3s

5. Decomposition case: in T[L(,n)#] where L is a linear array (e.g.  4,3,9 for example) and # is any linear or multi comma array.

w^(w+2) level to w^w2 level

Rules:

• Degenerative case: T[1#] = 3

• Deleting case: T[#1] = T[#]

• Chaotic Reduction case: T[p,,0,1,...,1,a,L] = T[3,,p,3,...,3,a-1,L]

• Chaotic case: T[p,,a,b,c,...,x,y,z] expands to T[3,3,3,...,3,3,3,,a-1,b,c,...,x,y,z] w/ p-1 3's.

• Decomposition case: T[L,,#] expands to T[expand(L),,#] (use L3N rules)

This is enough to formalize the notation to w^w2 level, but not enough to reach the end of planar arrays...

Trilinear Threes Notation (3L3N)

Core Definitions and Recursive Expansion

1. Base Case:

   • Trilinear notation follows the recursive multi-comma delimiter system.

   • Zero-Based Expansion Rule: T[a,,0,,1,,...,,1,,2] = T[a,,a,,a,,...,,a,,1] (Then apply the Deleter case to reduce one entry.)

• Correction for Invalid Arrays: T[a,,1,,1,,...,,1,,2] = T[a,2,,0,,1,,...,,1,,2] (This is theoretically invalid, but included for clarity.) 

2. Decomposition Case:

   • The deletion rule persists: T[#(,n)1] = T[#] (Where (,n) denotes any number of commas.)

3. Recursive Strength:

   • Extends decomposition from bilinear cases into nested transformations: T[a,,n,,m] = T[3,3,...,3,,n-1,,m-1] (With a−1 occurrences of 3.)

Higher-Level Recursive Rules

1. Self-Referential Growth

Examples:

• • Trilinear recursion: T[3,,1,2,,2] = T[3,,T[2,,1,2,,2]] = T[3,,T[3,,3,,2]]

  • Apeirotly nested trilinear recursion: T[3,3,,1,2,,2] = T[T[3,2,,1,2,,2],2,,1,2,,2]

  • Linearly nested trilinear recursion: T[3,,2,2,,2]

  • Use more structures similarly

• Reduction Cases

  • Degenerative case: T[1#] = 3

  • Deleting case: T[#(,n)1] = T[#]

  • Chaotic Reduction: T[a,,1,c,,2] = T[3,,T[a-1,,1,c,,2],c-1,,2]

  • Extended decomposition: T[L,,#,,2] = T[expand(L),,#,,2] (Using L3N rules.)

Comparative Strength Analysis

1. Growth Rate Comparison:

   • Previous notation reached w^(w2)level.

   • 3L3N extends to w^(w3) and a system to go beyond.

2. Deep Recursion Patterns:

   • Recursive self-replication enables structures equivalent to tetrated transfinite exponentiation.

   • Notation supports higher-plane arrays without being restricted by previous decomposition methods.

Conclusion

Trilinear Threes Notation (3L3N) solidifies hierarchical recursion while ensuring deep nesting patterns continue beyond bilinear constructs. This notation bridges between extended transfinite recursion and higher-order decomposition methods applicable in large-scale ordinal growth modeling.

All of this is still part of ex3N!!

Multidimensional Threes Notation (MD3N)

Formalized Unresolved Definitions in Trilinear Threes Notation (3L3N)

As we wrap up, let's refine and categorize some currently unformalized expressions, ensuring a precise recursive structure within Trilinear Threes Notation.

Core Structural Expansions

• Recursive Nesting and Pattern Alignment

  • We can have T[3,,3...3,,3] w/ p-1 a's as T[p,,,2]

• Basic Transformations and Equivalency Mapping

  • T[3,3,,,2] = T[3,,,3] = T[2,,,,2]

  • T[3,3,3,,,2] = T[4,,,3]

Pattern-Based Accelerated Enumeration

Given the increasingly complex growth, let's optimize by leveraging transfinite shorthand representations to generalize:

• Recursive Multi-Level Expansion

  • T[3,,,3,3], T[3,,,3,,3]

  • T[3,,,3,3,3,3], T[3,,,3,,,3]

  • T[3,,,3,,3,,3,3], T[3,,,3,,,3,,,3]

• Chaotic and Degenerative Transformations

  • T[3,,,,3] = T[3,,,3,,,3] = T[3,,,3,,3,3,3] = [too chaotic]

Naming Large Ordinals Using These Expressions

With the refined notation, let's systematize ordinal classification based on recursive depth and transfinite exponentiation. This provides a framework for mapping large transfinite constructs, pushing beyond previous hierarchical growth limits.