Welcome to STAN, or Spels terrible array notation
Introduction To STAN[]
STAN stands for Spels terrible array notation, because i'm pretty sure that this is a pretty bad notation, but please continue reading, because i would like feedback on it.
Anyways, this is a pretty fast growing function. I don't really know how big, but it's definitively possible to analyze. If any of you analyze it, say it in the comments, or DM me on discord, and i will update this.
Definition[]
So, you wanna know how the function works? Well, it comes in 3 parts, the size, the length and the τ recursor. (Each one increasing the number range very significantly, but the τ recursor will simply justr make the other 2 parts look tiny in comparison.)
The Size Part[]
So basically, we have the base rule that T(a) = a^2. Then, you might wonder what we are gonna do next. well, an array can have however many entries it wants. We call the entry amount "size", and thats where the name of this part of the definition comes from.
To have more than 1 entry, we have the rule that We plug the entire array into the second last entry, and the amount of times we do it is decided by the final entry. When we're done with that, we reduce each mention of the final entry by one, and increase every mention of the second last entry by one. When the last entry is 1, it can be removed.
So, that's it for the size part. Pretty simple.
The Length Part[]
Here we can use multiple sets of parantheses. like T(a)(b)(c). NOTE: whenever we name a varible withinin one of these sets of brackets, that variable can be a single value, or it can be an entire array. (That array can only use size part) The sets of paratheses are gonna be named "arguments". The amount of arguments is named "The Length" of the notation. (That's where the name of this section comes from.) This part is also pretty simple. Basically, we take the second last argument, and repeat whatevers inside of it. The amount of times we repeat is simply the final argument. After that, we reduce the final entry of the final argument by 1. So for example: T(3)(3) = T(3,3,3)(2) = T(3,3,3,3,3,3)
So now you know the length part! After this comes the really juicy part.
THE τ RECURSOR[]
So we have a varible called the τ recursor, or for short, τ. This number is outside all other realms of numbers. So it doesn't have a quantity, or an ordinal value. It basically exist separate from everything else. We can still perform operations on it though. Wwe have the rule that whenever we have a "limit", we simply replace the thing we increase to get to it with something. We will discuss what that "something" is later on. But whatdo i mean with "limit"? Well, we have τ, right? We can add onto τ however much we want, but no matter what we do, we will never reach τ2, so τ2 is a limit. When i say "the thing we are increasing", i mean the thing that is the colsest to getting to it. So basically, the "increaser" of τ2 is τ+n, where n is any number. τ3 is τ2+n. τ^2 is τn, hopefully tou see the pattern. So how do we integrate this into the function?
Well, we denothe it by (some stuff)_(τ stuff), where (some stuff) is replaced with any array. (That array can't include the τ recursor), and (τ stuff) should be replaced with τ and whatever operations we do on it. Example: T(2,5,3)(5,6,4,3,5)(2,7,8,9)_τ5+2 (This is an completely arbitrary number by the way)
We have the base recursion rule that (some stuff)_τ is T(3)(3)(3)... with a lenth of (some stuff). As you can see, this already blows up the numbers.
Well, (some stuff)_τ+n is simply just T(3)(3)(3)...(3)_τ+(n-1) with a length of (some stuff).
Remeber when i talked about the limits and how we would replace the "increaser" with something? Well, we replace it with (some stuff). For example, (some stuff)_τ2 is simply just (some stuff)_τ+(some stuff).
There, the entire definition is done! I am really sorry if i couldn't make you understand the notation, you can ask me questions and give me feedback via the comments or discord.