Revised Pehan Notation

Revised Pehan Notation is a notation created by Googology Wiki user Licorneuhh.
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 23:00 11/12/2020)
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 11:25 12/12/2020) 
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 12:52 12/12/2020) 
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 13:50 12/12/2020) 
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 23:39 12/12/2020) 
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 00:24 13/12/2020)
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 02:10 13/12/2020)
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 12:44 13/12/2020)
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 17:17 13/12/2020)
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 17:02 14/12/2020)
Revised Pehan Notation | Licorneuhh's Number Site (retrieved at UTC 22:46 08/01/2021)
Unfortunately, the original version and some parts of the current version are ill-defined, as we will explain later. As the source is just a personal website which is not peer-reviewed, some errors in the definition of the notation have been pointed out, and the definition has changed so many times. Therefore readers should be careful not to be confound the current definition with previous definitions.
In "Current definition" section, we will explain the summary of the whole system with repect to the current version. In latter sections, we will explain the original definition and the updating history of each level.
==Current definition==
The creator has added an abstract of the notation in an update :
"Abstract :
Each term of the following functions has its rules that will be describe. To avoid confusion, they will be the same formula-to-formula.
Each function in Revised Pehan Notation (RPN) is an application from N (or N*) to N, and all terms or arguments that can appear are part of natural numbers (precised when 0 excluded).
* ab(n) functions are defined for all a > 0 and all b natural number
* ab(n) = ab-1n(n) for all b > 0, where the superscript means the iteration of the function
* a0(n) = a-1n(n) for all a > 1
* 10(m) = um , where u0 = 1 and un+1 = m↑unm , using the Knuth up-arrow notation
* gab(n) functions are defined for g > 0
* 1ab(n) = ab(n)
* 2ab(n) = |a|b(n)
* a(in a g-gon)b(n) = gab(n)
* g10(n) = g-1nn(n), for g > 1 and not defined for n=0
* 1[1]0(n) = nnn(n), not defined for n=0
* 1[c]0(n) = nn[c-1]n(n), with c > 1 and not defined for n=0
All functions with an array (or more) are not defined for n = 0
Multi-entry rules have to be followed in the described order :
When you have an array with 1 or more zeroes at its rightmost entries before the computing process, they're removed. If all the array contains just zero(es) then it is removed.
At each changement (so when you reach 1[l]0(n) point, where l is a list of entries) :
1. All non-array arguments are replaced by n (including the g term, also when g = 1 and is not writted following the rule that 1ab(n) = ab(n))
2. In the array, the leftest non-0 entry decrease by 1
3. In the array, if there is one or more 0s chain at the left of the term that has been changed, they're all replaced by the n argument of the function
4. In the array, if the rightest entry decrease to 0, then the entry is removed.
* ga[ [[[[[...k...[l]...]]]]]]b(n) = ga[(k)[l]]b(n)
* ga[(1)[l]]b(n) = ga[l]b(n)
* 1[(k)[1]]0(n) = nn[(k-1)[n,n,n,...n,n]]n(n) with n n's in the array, for k > 1 and n > 0
* If there is more than one array, when one array disappear, the array at its left take over, and has n terms of n value with n square brackets. The fact that there is one ore more array is denoted with empty arrays "[ ]" (different from array that have the value of 0 in it !) in the left of non-empty arrays. The priority goes to the rightest array. The numbers of empty array can be descibed by a number in supersupscript s after one empty array.
* ga[ ]1[1]b(n) = ga[ ] [1]b(n)
* 1[ ] [1]0(n) = nn[(n)[n,n,n,...n,n]]n(n) with n n's in the array for n > 0
* 1[ ]s [1]0(n) = nn[ ]s-1[(n)[n,n,n,...n,n]]n(n) with n n's in the array for n > 0
No function with more than one non-empty array is defined.
The basic relation between level of arrays is the following : 
* 1[{L}1]0(n) = nn[{L-1} ]n [(n)[{L-1}n,n,n...,n]]n(n) with n n's in the array for n > 1 and for L > 1
The level don't need to be showed when equal to 1 :
* ga[{1}l]b(n) = ga[l]b(n)
No function is defined for any L = 0
* 1*0(n) = nn[{n} ]n-1 [(n)[{n}n,n,...,n]]n(n) with n n's in the array
* 1*k 0(n) = nn*k-1[{n} ]n-1 [(n)[{n}n,n,...,n]] n(n) with n n's in the array and with k the number of stars after the "a" term.
* No function of the type ga*k[{L1} ] [[L2}l] b(0) is defined.
Ȝ(n) = 1*n 0(n)for all n natural number "
Also, the rules for multiples arrays have been updated : 
"
* If there is more than one array, the priority goes to the leftest non-empty array. 
* When one array disappear (value decreasing to 0), if it has a non-empty array at its right (direct or not) the array changes to an empty array instead of disappearing and the non-empty array at its right decreases. 
* If an array decrease and has an empty array at its left, then the empty array is filled with n terms of n value with n square brackets. 
* The fact that there is one ore more array is denoted with empty arrays "[ ]" (different from array that have the value of 0 in it !) in the left of non-empty arrays. 
* If there is a chain of 1 or more empty arrays with no non-empty arrays at the right of that chain, then they got removed "
It is to notice that the update also nerfed the "No function with more than one non-empty array is defined." rule 
Also, another major update, who just made the creator's site to keep the abstract, definitely banned n=0 :
"Each function in Revised Pehan Notation (RPN) is an application from N* to N", removing so the precisions for the case of n=0, now useless.
The last update (January 2021) introduces "star arrays" and reforms the yogh funtcion :
" ga*oAb(n) = ga[o]Ab(n), with A being array(s) (or no array).
All preceding array rules work for the "star array"
To differenciate te type of arrays, we can use a subscript d after the array (d=1 for normal arrays, d=2 for star arrays) The priorities go to the arrays with the smallest d-value, with the following relation :
1[H]d0(n) = nn[{n} ]d-1n-1 [(n)[{n}n,n,...,n]]d-1[H-1]d n(n), where [H-1] denotes one decrease of the array [H], for all d > 1
Ȝ(n) = nn[(n)[{n}n,n,...,n]]nn(n)".
==Basic Level==
The rules for basic level are as follows:
*10(m) = um , where u0 = 1 and un+1 = m↑unm , using the Knuth up-arrow notation
*ak(n) = ak-1n(n) for all a, k > 0
*a0(n) = a-1n(n) for all a > 1
Although it is not clarified, it is reasonable to guess that the domain of the function ak is the set of non-negative integers rather than the set of positive integers for any positive integer a and any non-negative integer k, as the source includes an evaluation for the case n=0.
==Geometric level==
The original rules for geometric level are as follows:
*ab(n) = 1ab(n)
*|a|b(n) = 2ab(n)
*gab(n) = a(in a g-gon)b(n)
*g10(n) = gnn(n)
Although it is not precisely defined, the creator perhaps intends the following two additional rules according to the original description in the source:
: "you can apply the same logic that before but with |a|b(n) ( |a| is just the notation, it doesn't mean the absolute value of a ) !"
: "The same logic is applied but when you get to |1|0(n), it is equal to nn(n)"
* ga0(n) = ga-1nn(n) for any positive integers g and a > 1.
* gab(n) = gab-1n(n) for any positive integers g, a, and b.
Unfortunately, this level was ill-defined by the following reasons:
# There are two distinct rules applicable to 110(0).
## If we apply rule 1, then the resulting value is 10(0) = 1.
## If we apply rule 4, then the resulting value is 100(0) = 00(0), which is ill-defined.
# There are two distinct rules applicable to 110(1).
## If we apply rule 1, then the resulting value is 10(1) = 1.
## If we apply rule 4, then the resulting value is 111(1).
# There is no rule applicable to 210(1).
# It has an infinite loop: g10(1) calls g11(1), which calls g10(1).
It is notable that the creator wrote a different rule when he or she created this article by himself or herself.The first version of this article. In the first edition, rule 4 was replaced by the following rule:
* g10(n) = g-110(n) for all g>1
Then gab(n) does not depend on g, and hence the description is perhaps a typo. At least, it is completely different from the original rule in the source.
Later, the creator replaced rule 4 by the following rule:
* g10(n) = g-1nn(n).
Although it is not clarified in the source, g in the updated rule is perhaps inteded to be greater than or equal to 2, because of the following reasons:
# If we allow g in rule 4 to be 1, then the issue of the overlapping of the case classification for rule 1 and rule 4 pointed out above has not been solved.
# If we apply rule 4 to the case of g = 1, then the right hand is 0nn(n), which is ill-defined.
However, it still had an issue: 210(0) is ill-defined, as its resulting value is 100(0) = 00(0), which is ill-defined.
The issue has been solved in another update of the definition "With that rule, the functions of the type g10(0) are not defined for g > 1 because functions of the type g0b(n) are not defined."
The overlapping has also been solved in another update ""The "gone-changing rule" is that : g10(n) = g-1nn(n) for all g > 1""
==Simple array level==
The original rules for simple array level are as follows:
*1[1]0(n) = nnn(n)
*1[b]0(n) = nn[b-1]n(n) for all b > 1
Although it is not precisely defined, the creator perhaps intends the following six additional rules according to the original description in the source:
: "The preceding logics with subscript, geometrics always apply."
*a[b]k(n) = a[b]k-1n(n) for any positive integers a, b, and k.
*a[b]0(n) = a-1[b]n(n) for any positive integers a > 1 and b.
*1a[b]c(n) = a[b]c(n) for any positive integers a and b and non-any negative integer c.
*g1[b]0(n) = g-1n[b]n(n) for any positive integers g > 1 and b.
*ga[b]0(n) = ga-1[b]nn(n) for any positive integers g, a > 1, and b.
*ga[b]c(n) = ga[b]c-1n(n) for any positive integers g, a, b, and c.
Later, the creator added a new description "As 1[b]0(n) = nn[b-1]n(n), any function of this type is not defined for n=0".
==Multi-entries array level==
Multi-entry rules have to be followed in the described order :
At each changement (so when you reach 1[l]0(n) point) :
# All non-array arguments are replaced by n
# In the array, the leftest non-0 entry decrease by 1
# In the array, if there is one or more 0s chain at the left, they're all replaced by the n argument of the function
# In the array, if the rightest entry decrease to 0, then the entry is removed.
Although it is not clarified in the source, l perhaps denotes an array of length greater than or equal to 2 according to the examples in the source, and "the array" in the rules above refers to l. The precise domain, i.e. the range of entries of l is unclear. As the examples show, an entry of l can be 0. However, the expression 1[0,0]0(n) is ill-defined, as its resulting value is n[n,-1]n(n), which is ill-defined. Therefore l is perhaps intended to be an array of non-negative integers of length greater than or equal to 2, whose last entry is not 0.
Also, althought it is not clarified in the source, there are perhaps additional eight rules to compute other sorts of expressions of the form a[b]c(n) and ga[b]c(n) for suitable g, a, b, and c.
Literally, the value of 1[0,1]0(2) should be computed by the following term rewriting steps:
# 1[0,1]0(2)
# 2[0,1]2(2)
# 2[0,0]2(2)
# 2[2,0]2(2)
# 2[2]2(2)
However, the example in the source states that it should be computed by the following term rewriting process:
# 1[0,1]0(2)
# 22[0,1]2(2)
# 22[0,0]2(2)
# 22[2,0]2(2)
# 22[2]2(2)
Therefore the creator perhaps omitted an additional rule to add the superscript g = 1 before applying the process.
It has been clarified by an update of the rule 1 "1. All non-array arguments are replaced by n (including the g term, also when g = 1 and is not writted following the rule that 1ab(n) = ab(n))".
Unfortunately, even if we ingore the ill-definedness of the domain, i.e. the ambiguity of the range of l, it is still ill-defined becase the computation of 1[1,1]0(n) for n > 0 includes an infinite loop, as long as the ambiguous word "at the left" in rule 3 means "in the segment of l given by removing the rightmost entry". Indeed, it should be computed by the following term rewriting process:
# 1[1,1]0(n)
# nn[1,1]n(n)
# nn[0,1]n(n)
# nn[n,1]n(n)
The evaluation of the last expression calls the evaluation of 1[1,1]0(n') for an n' larger than or equal to n, and hence it is non-terminating. Especially, the evaluation in the case n = 1 simply causes circular logic.
Although the issue on the ambiguity of the domain is not solved, the issue of an infinite loop has been solved in an update of the rule 3 "3. In the array, if there is one or more 0s chain at the left of the term that has been changed, they're all replaced by the n argument of the function ". Namely, the problem was the ambiguity of the term "at the left". In the updated definition, 1[1,1]0(n) is computed in the following term rewriting process:
# 1[1,1]0(n)
# nn[1,1]n(n)
# nn[0,1]n(n)
Rule 4 does nothing, because it refers to the non-empty array. Therefore the problem does not occur.
The case were a chain of zeroes are put in the rightests entries of the array is intended to be solved by an update "It is to notice that when you have an array with 1 or more zeroes at its left before the computing process, they're removed.", but the meaning of "at its left" is quite ambiguous again. According to the creator, the problem of the ill-definedness of 48[42,8,0,8,7,0,0,0,0]9(6) can be solved, as it is intended to be expanded as 48[42,8,0,8,7]9(6). Therefore the ambiguous word "at its left" perhaps means "at the left of the right bracket ]", i.e. "at the rightmost entries of l".
The new example 48[42,8,0,8,7,0,0,0,0]9(6) shows that l can be an array whose rightmost entry is 0. Therefore if this interpretation of the ambiguous word "at its left" is correct, then the expression 1[0,0]0(n) is still ill-defined, as its resulting expression is 1[]0(n), which is ill-defined.
It has been corrected in another update "It is to notice that when you have an array with 1 or more zeroes at its rightmost entries before the computing process, they're removed. If all the array contains just zero(es) then it is removed." This solves the ambiguity of the phrase "at its left" in the previous versoion and the issue of the ill-definedness of 1[0,0]0(n), as it will be expanded as 10(n).
==Multi-square-brackets array level==
The rules for multi-square-brackets array level are as follows:
*ga[ [[[[[...k...[l]...]]]]]]b(n) = ga[(k)[l]]b(n)
*1[(k)[l]]0(n) = nn[(k-1)[n,n,n...n]]n(n) with n n's in the array
The rule 1 has been updated "You can describe the number k of square brackets (so natural positive) by this k in parentheses between double brackets : 
ga[ [[[[[...k...[l]...]]]]]]b(n) = ga[(k)[l]]b(n), with l a list of one or more entries".
The rule 2 has been updated too "1[(k)[1]]0(n) = nn[(k-1)[n,n,n,...n]]n(n) with n n's in the array, for k > 1".
Another rule has been precised :
"ga[(1)[l]]b(n) = ga[l]b(n)" .
==Multi-arrays level==
When one array disappear, the array at its left take over, and has n terms of n value with n square brackets. The fact that there is one or more array is denoted as empty arrays "[ ]" (different from array that have 0 !). The priority goes to the rightest array. The numbers of empty array can be descibed by a number in supersupscript after one empty array.
The rule for multi-arrays level is as follows:
*1[ ] [1]0(n) = nn[(n)[n,n,n,n,n,...n,n,n]]n(n), with n terms in the bracket.
Two rules have been added in an update :
*"No function is defined for two non-empty arrays at the same time"
*"As there's no arrays with no square brackets, no ga[ ]s [l]b(0) function type is defined."
==Superior array levels level==
The L level of array is put in the supersupscript at the left of the array, noted as {L}, with the level 1 as basic level :
ga[{1}l]b(n) = ga[l]b(n)
Later, the creator added a description "No function is defined for any L = 0".<ref name="second">
The basic relation between level of arrays is as follows :
*1[{L}1]0(n) = nn[{L-1} ]n [(n)[{L-1}n,n,n...,n]]n(n)
A rule have been added in an update :
*"As there's no arrays with no square brackets, no function with arrays of a level L > 1 is defined for n=0."
==Stars level==
The original rules for stars level are as follows:
*1*0(n) = nn[{n} ]n-1 [(n)[{n}n,n,...,n]]n(n) (with n n's in the array)
*1*k 0(n) = nn*k-1[{n} ]n-1 [(n)[{n}n,n,...,n]] n(n) (with n n's in the array, and with k = number of stars)
Later, the creator added a description "As there is no level L that can be equal to 0, 1*k 0(0) is not defined, you can apply star functions to natural positive numbers only."
==Yogh function==
The original definition of Yogh function is as follows:
Ȝ(n) = 1*n 0(n)
Later, the creator added a description "It is defined for n=0, because it gives a function with no star, so with no level of arrays equal to 0 and so computable."
==Examples==
As the notation is ill-defined, the following computation does not mean the actual termination by a decisive process, but just means an intended behaviour.
*10(1) = 1↑1 = 1
*10(2) = 2↑2↑22 = 2↑42 = 2↑↑↑↑2 = 4
*10(3) = 3↑3↑3↑333 = 3↑3↑2733
*11(4) = 10(10(10(10(4)))) = 10(10(10(4↑4↑4↑256444)))
*21(3) = 202(122(112(102(3↑3↑2733))))
*|1|2(2) = |1|1(|1|1(2)) = |1|1(|1|0(22(2))) = |1|1(|1|0(21(20(11(10(10(2))))))) = |1|1(|1|0(21(20(11(4↑4↑4↑256444)))))
*510(4) =444(4) = 4434(4) = 443(443(443(443(4))))
*1[1]0(5) = 555(5)
*1[6]0(3) = 33[5]3(3)
*1[0,1]0(2) = 22[2,0]2(2) = 22[2]2(2) = |2[2]|1(|2[2]|0(|1[2]|1(|1[2]|0(22[1]2(2)))))
*1[0,43,0,145,1]0(2) = 1[2,42,0,145,1]0(2)
*1[0,0,0,145,1]0(10100) = 1[10100,10100,10100,144,1]0(2)
*1[0,0,0,0,0,1]0(150) = 1[150,150,150,150,150]0(150)
*1[ [1] ]0(4) = 44[4,4,4,4]4(4)
*1[(3)[1]]0(4) = 44[ [4,4,4,4]]4(4)
*1[(6)[1]]0(8) = 88[(5)[8,8,8,8,8,8,8,8]]8(8)
*1[ ] [1]0(6) = 66[(6)[6,6,6,6,6,6]]6(6)
*1[ ] [ ] [1]0(5) = 55[ ] [(5)[5,5,5,5,5]]5(5)
*1[ ]87 [1]0(5) = 55[ ]86 [(5)[5,5,5,5,5]]5(5)
*1[{2}1]0(6) = 66[{1} ]6 [(6)[{1}6,6,6,6,6,6]]6(6) = 66[ ]6 [(6)[6,6,6,6,6,6]]6(6)
== See also ==
* Revised Pehan Notation numbers
==References==
Category:Functions
Category:Incomplete
Category:Numbers by Licorneuhh
Category:Notations