Intro: Why I am trying to beat SAN[]
So a lot of people here know that SAN is the strongest array notation that is widely known. A few people from googology discord may also know that me, System Shark, and a few other "trolls" from the server are total nuisances and dumbasses. Well, I want to change these 2 statements. Me, System Shark, Binary198, Veblen Waifu, Aarex Tiaokhiao, and a few other googologists are now developing super OVERPOWERED, COMPACT, AND COMPLEX array notations which are gonna reach at least (0,0,0)(1,1,1)(2,2,0) in BM4. Currently, Aarex Tiaokhiao has been extraordinarily successful, with his notation ASAN obliterating SAN, and even reaching past TRIO SEQUENCING SYSTEM. AAREX, YOU ARE NOW A GOOGOLOGY GOD. And I look up to you and I will follow your footsteps to apotheosis.
Well I am here to come up with a notation idea that could DESTROY SAN. To not only give SAN the middle finger, but to secure my place in this community as a expert googologist. I will be known as the creator of one of the strongest array notations ever.
I have been mildly successful, I have almost fully formalized the first stage of Zenith Notation. It's currently very OP, a lot of my fellow googologists told me that it reaches at least OFP, if not MUCH MUCH FURTHER. My formalization might be very messy and ill-defined, so if any googologists want to help me analyze it, improve my formalizations or overall notation behavior further, do not hesitate to give suggestions and tips or even directly contribute to this document. https://docs.google.com/document/d/14yiYkLBjVXnjQUx3RJFVE7dX3JzoT6f2r2XmqRGFwW8/edit#
I would love it the most if people could determine the strength of Zenith Notation.
I welcome:
- More collaborators
- Tips on how to make my notation more OP
- People spinning off my notations
- Formalization tips
- People coding my ideas
- People analyzing my notation and it's strength
Note to PBOT: Thanks for giving me tips on how to formalize notations. I do not know how to formalize my notation in the exact concise manner that you expect people to. The best I could do is to get me and some other co-creators to code it using python or C++ or some language, then spoonfeed the code to those who want the super-exact ultraformalized definition. If you want to give feedback, I welcome it. I also welcome you to help code it if you are willing to help :)
Big shoutout to Binary198, Katakana, Veblen Waifu, Alegmano and Aarex Tiaokhiao for helping me make this notation. I look forward to working with you again.
BINARY ZENITH NOTATION[]
Warning, this notation may be poorly formalized.
For an equation {@(#x##)@@}
# and ## or * and ** =Left and right inside of the innermost parentheses respectively
@ and @@ = Left and right outside of the innermost parentheses respectively
An array looks like LVn {a[1]b}, where n is a variable.
a and b are either numbers or expressions
TERMS ARE SHOWN IN THE IMAGE NEXT TO THIS TEXT. THE IMAGE IS FROM THE DOCUMENT I MENTIONED ABOVE!
TERMS FOR THE NOTATION
Do the following until you get 1 big number:
main(LVn {a[1]b} where):
Look from left to right, search for the leftmost non-zero separator:
Always start at the left most entry.
Cases are in order of greatest importance to least
Base array case:
LVn {0[1]1} = n
{n} = n if n is a number
Remove all zeroes:
LVn {b[1]0} = LVn {b}
Base number addition rule:
Lvn {m} = n+m
LVn {b[1]##} = LV(n+b) {0[1]##}
Expansion rule:
Starting with {a[1]b} as the current array:
If {a[1]b} = {0[1]1}:
Return LVn+n
If a is a number or {0[1]1}:
GO TO Base number addition rule
If a is an expression:
Search in main(a), current array is now a
If b > 1:
Let {e[1]f} be {a[1]b} aka the original array
Find Structure rule:
Let {x[1]y} = {a[1]b}
If ({a[1]b} is the lowest layer in the array):
Halt and return {x[1]y}
Else:
Let {c[1]d} be the innermost parent that is a level of {x[1]y} ({c[1]d} = y)
If ({c[1]d} doesn’t exist):
Halt and return {x[1]y}
Else if ({x[1]y} is the child of {c[1]d} aka c = {x[1]y}):
Halt and return {x[1]y}
Else:
Set {x[1]y} to {c[1]d}
Continue searching outwards with find Structure rule
Structure search:
Let {a[1]b} now be set to the structure we found by using structure rule on {a[1]b} aka it’s returned {x[1]y}
{a[1]b} = starting array/original array
{c[1]d} = lower array/parent array
(initially set up as the next-lowest layer relative after performing the Find structure rule on it)
{a[1]b} must be the child of {c[1]d} to search properly
Note that {a[1]b} isn’t equal to {c[1]d}.
If ({a[1]b} is the lowest layer of the array aka if {c[1]d} doesn’t exist): Skip to Final copy/paste stage
Starting from the current array {a[1]b}, search outwards.
(EX in {{0[1]2}[1]3} if {0[1]2} is {a[1]b}, then {_[1]3} is {c[1]d})
Tip: WE CAN TELL IF d > = < b if we EVALUATE Lv10 {d} and Lv10 {b} and then compare the results we get from evaluating both arrays. For example, if Lv10 {d} > Lv10 {b}, then d > b.
If ({a[1]b} = d (aka {a[1]b} is level) or d >= b):
Continue searching outwards as if you started from {c[1]d}, set {a[1]b} to {c[1]d}
Else if (d < b):
Final copy/paste stage:
Stop searching
Everything in {a[1]b} gets copied into a massive array
Repeat n times:
Ascend inwards back into {e[1]f}
Subtract 1 from f so we now have {e[1]f-1}
Replace e with the copied massive array
When you are done with everything, increase Lvn by n so Lvn + n