The notation made by Aarex Tiaokhiao. This notation based on BHAN, but it have stronger growth rate, and I am trying to make stronger than AMHAN. This notation split to stages.
Click here for AAHAN notation!
Alpha AHAN is a first stage of AHAN extensions. This list shows all the extensions from Simple into 2-Nested Hypernested Expandal.
The first extension of AHAN in all. Set # as the rest of the array that is the same as other #s.
I analyzed with AAN and found out A<n,m,#> is same as a(n,m,#), depends both #s are the same.
Now, in the array: '0(1)1', which expands into '0,0,...,0,0,1' with the number depends on the first entry.
Then let call the comma, and all of possible (A), where A is the array; as the separators.
But we can go further: '0(1)a', => '0,0,...,0,0,1(1)a-1' with the number depends on the first entry.
Then: '0(a)b', => '0(a-1)0...0(a-1)0(a-1)1(a)b-1' with the number depends on the first entry.
Finally: '0(A)a', => '0(B)1(A)a-1', which A is the input and B is A but it is processed by 'the process'.
These all of above in this chapter are in 'the process', so we can add 1 more rule in 'the process', 'Else, go to second non-zero entry, then set the previous entry with the first entry and decrease the entry by 1.
Also: A<n,m(a)b #> = A<n,m(a-1)0...0(a-1)1(a)b-1 #> with m-1 0s after the first entry and before (a); and A<n,m(a)b #> = A<n,m,0(a)b #>.
I analyzed with AAN and found out A<n,#> is same as a(n,n,#), depends both #s are the same again, but (n), in AHAN, is equal to {n} in AAN.
In BHAN, \ is so much weaker: //a\^1_b// = //a(a(...(a(a)a)...)a)a// with 2b-1 'a's.
In AHAN, \ is so much stronger: '# 0\a' => '# 0(# 0(...(# 0(# 0(0)1\a)1\a)...)1\a)1\a' with n ()s nested, where n is the first entry of A<>.
We can put () after \, like '0\(1)1' = '0\0\0...0\0\1' with n 0s.
Note: A<a,b(0\d)c\d> is the same as A<a,b(0\d)c+1>.
I analyzed with AAN and found out A<n,#> is not the same as a(n,n,#), depends both #s are the same, but \, in AHAN, is equal to ; in AAN.
We can put a subscript on \ because we have it on BHAN. Define \ as the legion mark for (_), because it expands to nested ()s in '# 0\a' => '# 0(# 0(...(# 0(# 0(0)1\a)1\a)...)1\a)1\a'.
How about \\? But wait, there is //a\\^b_c// = //a\^c_c\^c_c\^c_c\^c_c...// with b '\^c_c's. So we need to set \_2 as the legion mark for \(_), as '# 0\_(2)a' => '# 0\(# 0\(...(# 0\(# 0\(0)1\_(2)a)1\_(2)a)...)1\_(2)a)1\_(2)a'.
We can go further, as setting \_n as the legion mark for \_(n-1)(_), as '# 0\_(n)a' => '# 0\_(n-1)(# 0\_(n-1)(...(# 0\_(n-1)(# 0\_(n-1)(0)1\_(n)a)1\_(n)a)...)1\_(n)a)1\_(n)a'!
Note: \_0(n) can be reduced to (n). A<a,b(0\_(d)e)c\_(d)e> is the same as A<a,b(0\_(d)e)c+1>.
In BHAN, there is superscript on \^a_b, so we need to define that expression. Define \^1_0 as the legion mark for 0\_(_)1, and I am lazy to define as 'rules' definition.
But we can have double leveled backslash rules as we have \^a_b as the legion mark for 0\^a_(b-1)(_)1, and \^a_0 as the legion mark for 0\^(a-1)_(_)1:
There is multiple \^a_b BHAN separators without in-between arrays. So... let do this. Call the first \^n_m as the leader backslash.
Then \^0_0\ is legion mark for 0 \^(_)_0 1, \^0_1\ is legion mark for 0 \^0_0\(_) 1, \^0_0\_A is legion mark for 0 \^0_(_)\_A-1 1, etc.
We can have superscript only for \^a_b, but what is \^a? To define, '0,n' can be changed into '(\),n-1' on every \^a. Then...
But we need to define (\) and arrays on (\_):
Note: A^(0) = A.
Sometimes, \^() have the stronger limit, as changing \^(0(0\_(a)b)c) into the legion mark for 0\^(0(0\_(a-1)(_)1\_(a)b-1)1(0\_(a)b)c-1)1.
There is some problems on AHAN, like \^(0(0\_(2)(1,1))1), but I will fix it later.
In the nutshell: \\ is 2-separator of \^(), and \\ drops down into nested \^(_).
In not the nutshell: \^(0\\a) is legion mark for 0\^(_\\a-1)1.
Then \\(), \\_1\ (legion mark for \\_1(_)), \\_1\_a, \\_1\^a_b, \\_1\^a_b\^c_d, \\_1\^A, then:
Then we can define \\^(). Like '0,n' => '(\),n-1' inside of \^(), we change '0,n' into '(\\),n-1' instead, which is really strong. But how we solve (\\)?
I know, let set L as \, \\, \\\, etc. Then L^(#(0L^(# (\\))a)) is legion mark for 0 L^(#((\^(_))L^(# (\\))a-1)) 1. Let set \\ as Second Backslash mark of anything you want.
We can define higher backslash, like ...(\^(n-1))^(0...\^(n)a) is (\^(n-1)) mark for...(\^(n-1))^(((\^(n-1))^(_)...\^(n)a-1), where (\^n) expands into \\\\... with n \s, and all '...'s are same. But how?
Define \ mark as legion mark and \\ mark as Second Backslash mark. Then \\\ is \\ mark of 0\\^(_)1, as \\\ mark; \\\\ is \\ mark of 0\\\^(_)1, as \\\\ mark, etc.
Now, define '0,1' maps into '(L),1' inside of L^(_), where both Ls, in this rule, are (\^n) and both are the same! HAHAHA!
We can easily define (A^+n) drops down into (\^n)^(A). We can define (0^+0,1) which is stronger.
(0^+0,1) is \\ mark of (0^+(_)). Then (0,1^+0,1) is \\ mark of ((0^+(_))^+0,1) and (0^+0,2) is \\ mark of (0^+(_),1). Finally, we can define (0^+\) as legion mark of 0(0^+_)1, (0^+#...\\) as \\ mark of 0(0^+#...\^(_))1, and (0^+0^+1), as \\ mark of (0^+_).
Then, ^+_1\ is defined as legion mark of 0^+(_)1, and (0^+_2 1) does the same. Finally, #(A#^+1) is same as #\^(A).
Finally we can reach the limit, as ^+\ is \\ mark of 0^+^(_)1, and (0^+^+1) does the same, but how we fill the gap from ^+_((0^+_((0^+_((...))1))1)) and ^+^1_0?
I know, define (0^+^1_(0)1) as mark of ^+_(\), as legion mark for 0^+_((_))1. Then, (0^+^1_(0)A) would be same as (0^+A), but \ changed into ^+_(\).
Then we can build ^+^(A). ^+^(...0,n) is equal to ^+^(...(^+),n-1), and A^(# (^+)) works like ^+, but \ changed into A^(# (\)).
The next step will be ^(+A).
Update: I found the stronger ^+^(A)! Let (#1 0,A^+^(#2 0,B)1) will be legion mark for (#1 (#1 0^+^(#2 (_),B-1)1),A-1^+^(#2 0,B)1)... but ^+^(A,B #) work the same.
I will revamp this.
But how we get ^(+2)? It is easy, it works like ^+, but with new ^+s instead of \s. #_1^(+2) and #^(+2) works the same as ^(+2).
Then we can reach ^(+0,1) by defining ^(+N) that works like ^+ but with new ^(+N-1) instead of \s. Then ^(+0,1) can defined by works like ^+ but on ^(+(_)), but how?
(0^(+0,1)1) works like \\ but on ^(+(_)), then (# 0,A^(+0,1)1) works like \\ but on (# (^(+(_))),A-1^(+0,1)1). This how I made this part of AHAN stronger than the original, but I replaced that into the new one.
Then ^(+# 0,A) works like ^(+0,1) but on ^(+# (_),A-1) instead of ^(+(_)), ^(+\) works like \\ but on ^(+_), and ^(+#_1\) works like \\ but on ^(+#_1(_))!
So then, we can reach double plus signs, ^(++) works like ^(+0,1) but on ^(+_) instead of ^(+(_)).
And how I define the rest of this part: ^(+N#) works like ^+ but with new ^(+N-1#)s instead of \s; and ^(#+N) works like ^(+0,1) but on ^(#_+N-1) instead of ^(+(_)).
The limit of this part is ^(++++...)
It is easy to convert +-space into normal space. Let '0+A+B+C...' will be '+A+B+C... How about further separators?
I know: ^(0+_(2)1) works like ^++ but on +_1^(_), ^(0+_(2)2) works like ^++ but on ^(0+_1^(_)1+_(2)1), ^(0+_(N)1) works like ^++ but on +_(N-1)^(_), and ^(0++1) works like ^++ but on +^(_).
Limit of this part is ^(0+++...1)
Then, ^{1,+} works like ^+ but with +s in the separator, ^(0{1,+}N) works like ^+ but with +s in ^(_{1,+}N-1), and ^{N,+} works like ^+ but with {N-1,+}s in the separator.
ORIGINAL VERSION:
Here is the definition of <N>.
So how we get (1,+<\>2)? Well it is easy: {A^(1,+<\>2)B} = {A+B}. + but with (1,+<\>2)s = ^(+,(1,+<\>2)), not (2,+<\>2), then we can put A instead of +.
Then we have to define this: (0^((#)<\>N+1)(1)1<\>N) = ((#),(#),(#),...<\>N), then (N,#<\>M) works like {N,#}, but it drops down into separators of (N-1,#<\>M) and {N,#} works like {1,+}, but it drops down into separators of (N-1,#).
Then we have ^(+,<\>), and ^(<\>,2) works like <\> but on ^(_,<\>) then ^{<\>,2} works like <\> but on ^{_,<\>}.
Define <\> as the separators of +-space and further types, then <#\> as the separators of <#>-space and further types.
I recently found the stronger definition of <#\>, so...
Note: If <\> corresponds into ^+, then (0<\>0,1) corresponds into (0^+0,1).
I just found the forgetting definition of Mapping Function part.
Now we can define further <#> separators:
The limit is <\<\<\<...>1>1>1>.
REVAMPED VERSION:
The limit is <0<0<0<...>1>1>1>.
ORIGINAL VERSION:
Well then:
The limit of this part is M(M(M(...)1)1)1- I just found the new subextension:
REVAMPED VERSION:
I will redefine this: M[1]A works like M1 but on <M_1\<_>1[1]A-1>.
[2] can be defined as works like [1] but [2] uses [1] arrays instead of M arrays.
Then [N] works like [1] but with [N-1] arrays instead of M, that less than of the rank [N]. But I will define rank: Rank can be a expandal separator, describing with [A] (where A can be anything), but with M in the rank set.
It is time.... M[0,1]1 works like M1 but on M[(<_>)]1! Then M[# 0,A]1 works like M1 but on M[# (<_>,A-1)]1.
Note: [# 0,A] is the rank above the limits of [# (n),A-1] and [0(1)1] is the limit of linear arrays of the ranks.
Finally, M[M1]1 works like M1 but on M[<_>]1, M[MA]1 works like M1 but on M[<_>,MA-1]1, M[M[1]1]1 works like M1 but on M[<M_1\<_>1>]1, M[M[1]A]1 works like M1 but on M[<M_1\<_>1[1]A-1>]1, and M[M[N]1]1 works like M1 but on M[M<[N-1]_1\<_>1>1]1.
The limit of this part is M[M[M[...]1]1]1, therefore Expandal Array Definition is stronger than Alemagno's. I will double check if he defined that.
But M[0[1]1]1 works like M[1]1 but on M[_]1 and Alemagno thinks I am correct. Then: M[0[1]A #1]B #2 works like M[1]1 but on M[_[1]A-1 #1]1[0[1]A #1]B-1 #2.
And [N] in [0_1] works the same as M[N]1.
NOTE: [] don't appear on Nested Expandal, so my version will be defined on Hypernested Expandal. So...
[\] works like [1] but on [_] and [#\] works like [1] but on [#(_)]. Then [\_2], [\^(0,0,1)], [\\], [^+], [<1>], [M1], but wait what, [M1] already defined so we need to define a new layer THAT A is stronger than A without that layer. Let call that as (_^S).
[(A^S)] works like A but with [] arrays instead of () arrays and [(<A>^S)] is same as [<A>]. Finally, we can get [[1]], the starting expandal separator of Nested Expandal BHAN.
[[1]] works like [1] but on M[(_^S)]1, but [[1],2] works like [1] but on M[(_^S),[1]]1! And [N] in [_] works the same as M[N]1.
The limit of this part is A<n,n(0(0^(0<M[[[...[1]...]]]1>1)1)1)1>, in full expression.
Coming soon.
Coming soon.
Coming soon.
Coming soon.