User blog:GamesFan2000/Cascade Notation, Pt. 1

'''Addition is the weakest of the hyper-operators. In the FGH, it compares to f1(n). It’s a weak notation, but it’s a great starting point for googological functions. So, let’s take 3+3+3. We have three-plus-three-plus-three. An average person can easily tell you that this is equal to nine. But, what happens when I do this: 3++3++3? Well, I’ll show you how I’d solve this:'''

3++3++3=3+3+3++2++3=9++2++3=9+9+9+9+9+9+9+9+9++1++3=81++1++3=81+81...81 81’s…+81++3=6561++3=43046721++2~1.853*10^15++1~3.433*10^30.

'''Yeah, that actually defeats 3^^3, amazingly enough. But it’s nothing compared to 3+++3:'''

'''3+++3=3++3++3+++2~3.433*10^30+++2. That’s big. So, what’s the point of this? Well, these expressions are part of my new notation, Cascade Notation. This notation has operators that, for a lack of better wording, creates cascades of terms. The rules of recursion for this notation are simple:'''


 * 1) n+m...=(n[1]m)... in hyper-operator notation
 * 2) n++...++(m+1)...=n++...+n++...+...n n’s...n++...+n++...++m...
 * 3) n++...++0++...++m...=n++...++m...

'''Here’s a very simple correlation: n++(m+1)=(n^2)++m. Each cascade of the level-two operator basically squares the first term. So, let’s analyze:'''

n+n=f1(n)

n++1=n^2>f2(n)

n++2=n^4

n++m=n^(m*2)

n+++1=n++n++...n n’s...n++n

n++...++n~fw(n)

'''It’s not too difficult to find that the basic part of the notation is limited by w on the FGH. Now, let’s expand on the operators. I’ll introduce the brackets: (+)'''

n(+)1=n++...n +’s…++n...n n’s…++...n+’s…++n.

n+(+)1=n(+)n(+)...n n’s...n(+)n

n++(+)1=n+(+)n+(+)...n n’s...n+(+)n

n(+)+1=n++...n +’s…++(+)n...n’s…++...n +’s…++(+)n

n+(+)+1=n(+)+n…(+)+n

n(+)++1=n++...n +’s…++(+)+n…++...n +’s…++(+)+n

n(+)(+)1=n(+)++...n +’s…++n…(+)++...n +’s…++n

n+(+)(+)1=n(+)(+)n…(+)(+)n

n{(+)+}(+)1=n++...n +’s…++(+)(+)n…++...n +’s…++(+)(+)n

n(+){+(+)}1=n{(+)++...n +’s…++}(+)n…{(+)++...n +’s…++}(+)n

n(+)(+)+1=n(+){++...n +’s…++(+)n…(+){++...n +’s…++(+)}n

n(+)(+)(+)1=n(+)(+)++...n +’s…++n…(+)(+)++...n +’s…++n

n(++)1=n(+)(+)...n (+)’s…(+)(+)n…(+)(+)...n (+)’s…(+)(+)n

'''Basically, a higher-level symbol will decompose into n of the next-highest-level of symbol. You decompose the left side of the left-most highest-level operator first, then you crop a regular plus sign from the other side of said operator to repeat the process. Once that’s exhausted, crop a regular plus sign that connected to the left side of the highest-level operator that comes immediately after the left-most one. And so on and so forth. I don’t really know how to define a ruleset for this, so if anyone can, please do so. As such, the limit so far is n(+++...+++)n.'''