Zenith Notation

Zenith Notation is a notation designed to be the cutting edge of array notations, pushing the limits of the concept of separators and diagonalizers, and being balanced around simplicity, strength, and efficiency. It is a collaborative notation made together by a group of amateur googologists, lead mainly by VaryanaYT and DTL, with many other googologists (most notably Aarex Tiaokhiao and Planetn9ne). This notation is based off of R function and Strong Array Notation.

Current Developers and Contributors:

* VaryanaYT (aka Avatar of Wrath/Captain Churchill) is the main creator and the prime contributor.
* DTL (aka Eliza/DudeThat'sWholesome/Veblen Waifu) was also a great contributor who contributed quite a bit to the development.
* TehAarex (aka Aarex Tiaokhiao/Lightning Aarex) greatly helped Varyana and DTL formalize/advance the notation, as well as come up with theoretical extensions that are innovative and exceptionally powerful.
* Jayde (aka Binary198/Pet Logician) also helped with theoretical variants and extensions.
* PlanetNine helped come up with the idea of transfinite droppers that could allow Zenith to go past Strong Array Notation by fixing a problem that resulted in SAN variants stronger than DAN infinite looping. However, Zenith hasn't been formalized at theat level yet.

It went under dozens of revisions, some being complete overhauls, and is still being developed to this day. However development is slow for various personal reasons of the devs.

Like many other high-powered array notations, Zenith employs the concept of searching/level comparison for its above-average strength. It uses a base (LVn) in which base-successor terms ({0}s) are deleted and added into the base, simulating the Hardy Hierarchy. Then larger terms break down into smaller terms, with a successor term breaking off into a number of smaller terms based on the base. Zenith extends this level comparison to n-dropping, similar to what SAN and R function do. Zenith is currently separated into multiple parts, with Linear, Dimensional, and Ascending Zenith being formalized by the means of pseudocode.

## Linear Zenith

Linear Zenith is the start of Zenith Notation. It employs basic searching and level comparison, and is relatively simple, yet incredibly strong. The level comparison allow the notation to mimic cofinality functions of uncountables and inaccessibles in OCFs, giving it similar power. To simulate the structure of Cantor Normal Form in ordinals, successor terms split into copies of smaller terms based on the base. Its limit growth rate is
fψΩ(ψI(ω,0)(0))(n) (using hyp cos's inaccessible OCF) or (0)(1,1,1)(2,1,1)(3,1,1)(3)[n] in BM4, far past older and more well known array notations such as BAN, and on par with many more advanced linear array notations such as Linear pDAN (limit is {1{1{2,,}2}2} in SAN) and Linear R function.

### Definition

**Basic Notation:**

LV[base] [insert terms here]

Ex. LV69 {{0,0,1}}

**Terminology:**

**Base:** LVn is the base of this notation. A lot of rules copy and expand a certain amount of times based on n.

**Term:** A pair of curly braces surrounding another expression {##}

**Base Successor term:** A term that is {0}. The basic term that increases the base. It is also equivalent to 1. n copies of {0} = n. Empty term {} is interchangeable with 0

**Successor term:** A term that is {n} where n is a positive integer, or {{0}#}. Basically it is a successor, an ordinal that you can subtract one from to get a smaller ordinal, to a smaller term and you can subtract one from a successor term.

**Non-Successor term:** A term that is {0#} r, or {{m}#} where m is not 0. Basically it is not a successor to a smaller term; you can't subtract one from a non-successor term.

**Entry:** An expression surrounded by the left and right with a comma/curly brace [,/{]entry[,/}]. An entry is empty if it's 0. A term without commas has 1 entry.

**Separator/Comma:** A comma ‘,’.Separates entries, and induces searching when after an empty entry

**Ascending Layer/Descending Layer:** A layer that we are currently conducting searching on is an ascending layer {##0,a+1#}. Its searches for a descending layer {##\_\_,a#}, then copies everything inside the descending layer when expanding. An ascending layer {##0,a+1#} is a diagonalizer for its descending layer {##\_\_,a#}.

**Automatic Subrules (Always apply these rules):**

* Scan from left to right searching for the first non-zero entry/expandable term.
* Remove all trailing 0s for commas: {##,0,0} = {##}
* If LVn has no terms attached to it, return n

**Rules:**

* Base Successor Rule: Case LVn {0}# (where we encounter the leftmost term to be a {0} base successor term):
	+ Delete {0} leaving LVn #
	+ Increase n by 1

* Non-Successor Rule: Case LVn ##{m#}# (where we counter a non-successor term):
	+ Scan inside the nonsuccessor term {m#}

* Successor Expanding Rule: Case LVn ##{m#}# where {m} is a successor term:
	+ ##{m}# = ##|n copies of {m-1#}|#
* Layer Search and Expand Rule: Case LVn {##0,a#} where a is a successor:
	+ Search for {##\_\_,b#} < {##0,a#}
	+ If you can't find a descending layer or smaller, just copy the whole thing and expand it
	+ {##{...{##0,a#}...},b#} = {##{...{##{...{##{...{##0,a-1#}...},a-1#}...},a-1#}...},b#} with n nestings of {...{##0,a-1#}...}

**Level Comparison:**

When comparing two arrays array A = {a1,a2,a3,...an} B = {b1,b2,b3,...bn}. Thank god Pbot isn't here to throw corner cases and stupid questions at us or say 69 chromosomed stuff like that this notation has no strength. Also I assume you know to always apply the remove trailing zeroes rule before comparing A and B.

* \_\_ is the entry of a term that contains our **ascending layer**. \_\_ has the **highest** level in an entry
* Level of {term1}{term2} is the **sum** of level of {term1} and {term2}

Comparing Entries/Single Entry Terms

* Let there be no-comma term A {{a1}{a2}{a3}...{an}} and B {{b1}{b2}{b3}...{bn}}.
	+ Convert integer a into string of a {0}s
	+ If A and B have a **different** amount of terms, then add {}s or empty braces that represent 0 to the **smaller** array until both A and B have the **same** amount of terms.
	+ Let the largest term in A and B be {am} and {bm}, let the 2nd largest term in A and B be {am2} and {bm2} and so on, compare every {amn} and {bmn} in increasing order n starting from {am1} and {bm1}.
	+ If {amn} > {bmn}, then A > B. If {amn} < {bmn}, then A < B. If {amn} = {bmn}, then compare the next pair of terms {amn+1} and {bmn+1}. If you are done comparing all terms in both A and B then:
	+ If all {an} and all {bn} are the same, A = B.

* Comparing terms with multiple entries:
	+ Let there be term A {a1,a2,a3,a4,...an} and term B {b1,b2,b3,b4,...bn}.
	+ If A has more entries than B, A > B. If B has more entries than A, B > A. If A and B have the same amount of entries then:
	+ Start from the rightmost comma for both of arrays, compare **everything** (not just entry to the left or right) left and right of the commas. A = {a\_left, a\_right} and B = {b\_left, b\_right}. If {a\_right} > {b\_right}, A > B. If {a\_right} < {b\_right}, A < B. If {a\_right} = {b\_right}, then:
	+ If {a\_left} > {b\_left}, A > B. If {a\_left} < {b\_left}, A < B. If {a\_left} = {b\_left}, then:
	+ If all entries are equal, A = B.

### Guide

Feel free to refer to the definition above as needed. Starting with the basics, LVn returns n and adding {0}s increases n by 1 each. m {0}s is practically the same as m, so LVn |m copies of {0}| is LVn+m = n+m. A{1} split into n {0}s, A {2}s split into n {1}s, {m+1}s split into n {m}s. The terms exactly correspond to their ordinals in the HH, and in the FGH, LVn a is precisely Ha(n). Terms can be nested in other terms in layers, forming the structure of CNF. If a nonsuccessor term is hit, scan inside the term and reduce what is inside it until you get a string of {0}s. Then the base term is a successor term you can expand the base term normally like a successor, like how you need to diagonalize ω2 into ωn and ω2 into ω+n before further reducing it. Note that n can be replaced with n copies of {0}.

For example: LV3 {{{3}}} = LV3 {{{3}}} Scan inside the outermost {} as it is a nonsuccessor = LV3 {{{3}}} Scan inside the middle layer {} as it is also nonsuccessor = LV3 {{{3}}} Successor found = LV3 {{{2}{2}{2}}} expand the successor {3} into base (here it's 3) copies of {2} = LV3 {{{1}{1}{1}{2}{2}}} Do the same for the leftmost {1} as we scan from left to right = LV3 {{{0}{0}{0}{1}{1}{2}{2}}} which is the same thing as {{**3**{1}{1}{2}{2}}}, we can now expand the middle layer {} as it is a successor ({0} is identical to 1) = LV3{{{0}{0}{0}{1}{1}{2}{2}}} = LV3 {**{**{0}{0}{1}{1}{2}{2}**}{**{0}{0}{1}{1}{2}{2}**}{**{0}{0}{1}{1}{2}{2}**}**} which is the same thing as {**{2**{1}{1}{2}{2}**}{2**{1}{1}{2}{2}**}{2**{1}{1}{2}{2}**}**}

We can nest these basic terms as much as we want, {1}, {{1}}, {{{1}}}, {{{{1}}}}, {{{{{...}}}}}, and then we reach {{0,1}} which is ε0

The time we hit commas is when Zenith starts showing its true power. {{0,1}} functions exactly like a Ω Things are pretty normal, {0}{{0,1}}, {1}{{0,1}}, {{0}}{{0,1}}, {{{0}}}{{0,1}}, {{...}}{0,1}, and the limit of this is ε02 = {{0,1}}{{0,1}}. Then we have {{0,1}}{{0,1}}{{0,1}}, and then we hit {{0}{0,1}}, {{0}{0,1}}{{0}{0,1}}, {{0}{0}{0,1}}, {{1}{0,1}}, {{1}{1}{0,1}}, {{2}{0,1}}, {{{1}}{0,1}}, {{{...}}{0,1}}, then {{{0,1}}{0,1}}, {{{{0,1}}{0,1}}{0,1}}, then we finally reach {{0,1}{0,1}} = ϵ1. But what kind of magic did we pull here?

Behold, Zenith's true strategy for untold power, searching and level comparison! This is how it works, when you see a term with a comma, {0,n}, that will be your ascending layer. A comma is a separator, a term that can diagonalize over/separate entries and induce searching. We search **outwards** to find a descending layer which is exactly {\_\_,n-1}. However, a term such as {\_\_,n-2}, or anything smaller would ALSO work very well. Let that smaller layer be {0,m} where m < n. Then you copy EVERYTHING enclosed inside the smaller layer {\_\_,m}, subtract 1 from n in the ascending layer {0,n} (set {0,n} to {0,n-1}), and then expand it, remember. So ...{\_{{0,n},k}\_,m}... = ...{\_{{\_{{\_{{\_{{...,n-1},k}\_,n-1},k}\_,n-1},k}\_,n-1},k}\_,m}... (here k > n and m < n). If you CAN'T find a layer that is smaller when searching outwards, copy the WHOLE THING. A brace with no commas {\_} is the same as {\_,0}, {\_.0,0,0}, and so on, as they are identical due to the subrule that removes trailing zeroes. An ascending layer diagonalizes over a descending layer, {0,n} diagonalizes over {\_\_,n-1}.

Here is one example {{{{{0,3}{0,3},4}{0,4},0,1},2},3} (this salad term is nonstandard ROFL). Our active term or ascending layer is {0,3} {{{{**{0,3}**{0,3},4}{0,4},0,1},2},3} as it is the first term from left to right we can expand. We search for the next layer outwards which is {{{**{**{0,3}{0,3}**,4}**{0,4},0,1},2},3} (NOT {{{{{0,3}**{0,3}**,4}{0,4},0,1},2},3} or the {0,3} right to the right of our ascending layer you simpleton! The {\_\_,4} layer that encloses our ascending layer {0,3}). {\_\_,4} > {\_\_,3} so we copy the {\_\_,4} and continue searching outward. Our next layer is {{**{**{{0,3}{0,3},4}{0,4}**,0,1}**,2},3} so {\_\_,0,1} (NOT {{{{{0,3}{0,3},4}**{0,4}**,0,1},2},3} or the {0,4} right to the right of {\_\_,4} you /b/tard!). Here, {\_\_0,1} is a 3 entried term, a huge term, larger than {0,69}, {0,{420}}, {0,{0,{1337}}}, or any {\_\_,a} or binary term (where a is a binary term or smaller). So we obviously copy it. Then we hit {**{**{{{0,3}{0,3},4}{0,4},0,1}**,2}**,3} which is a {\_\_,2}, smaller than {\_\_,3}. STOP. We found a smaller layer, or in this case, the exact descending layer of {\_\_,3} which is {\_\_,2}, so we copy everything inside {**\_\_**,2} and halt searching (DO NOT INCLUDE **{**\_\_**,2}** or the descending/smaller layer itself unless you want an infinite loop!) (Also if we hit a **{\_\_,1}** or anything smaller we would have done the exact same thing). So we currently copy everything inside {\_\_,2} which is {{{0,3}{0,3},4}{0,4},0,1}. Now our original ascending layer is {0,3} in {**{**{{**{0,3}**{0,3},4}{0,4},0,1}**,2}**,3}. We copy everything inside the ascending layer {\_\_,3} which we then set to {\_\_,2}. Expanding time! {***{***{{**{0,3}**{0,3},4}{0,4},0,1}***,2}***,3} = {***{***{{**{**{{**{**{{**{0,2}**{0,3},4}{0,4},0,1}**,2}**{0,3},4}{0,4},0,1}**,2}**{0,3},4}{0,4},0,1},***2}***,3}. And ladies and gentlemen, that is searching!

When we expand {{0**,1**}} by itself, it finds the descending layer **{**{0,1}**}**, then expand it = **{{{**...**,0},0},0}**, the descending layer bolded. But when we have {{0**,1**}{0,1}}, it finds the descending layer **{**{0,1}{0,1}**}**, so it becomes **{{{** ... {0,1}**,0}**{0,1}**,0}**{0,1}**}**

We can continue building larger and larger terms. {0,2} searches for and diagonalizes over {\_\_,1}. {0,3} searches for and diagonalizes over {\_\_,2}, {0,n} searches for and diagonalizes over {\_\_,n-1}. We can have terms for our second entry such as {0,{0}{1}{2}}, which searches for {\_\_,{1}{2}} and diagonalizes over it. We can even have stuff like {0,{0,n}} which searches and diagonalizes over {0,{\_\_,n-1}}. The next step is more entries, {0,0,1} a triple entry term diagonalizes over {0,\_\_} for all two entry terms. {0,0,2} searches for {0,\_\_,1} and diagonalizes over it. We can get bigger with {0,0,3}, {0,0,{1}}, {0,0,{0,1}}, {0,0,{0,0,1}}. Then we hit 4 entries {0,0,0,1}, {0,0,0,{1}}, then we can have 5 entries {0,0,0,0,1}, 10 entries, 100 entries... and BOOM! That is the limit of Linear Zenith. But this is only the beginning of our powertrip of madness, {0[1]1} diagonalizing over the number of entries.

## Dimensional Zenith

When building array notations, after linear arrays, the next step is obviously dimensions. However, to truly make the notation powerful, we will have to pull some goofy searching witchcraft.

This is the part where Zenith explodes in power, allowing it to bulldoze a majority of googological notations. We now allow bare commas within dimensions, and even arrays and dimensions within dimensions. The last part is what gives this notation its unstoppable strength. This mimics reflecting structure, DOR, DTL, and BMS very well up to the limit of pi-n reflection.

### Definition

**Basic Notation:**

LV[base] [insert terms here]

Ex. LV69 {{0,0,1}}

**Terminology:**

**Base:** LVn is the base of this notation. A lot of rules copy and expand a certain amount of times based on n.

**Term:** A pair of curly braces surrounding another expression {##}

**Base Successor term:** A term that is {0}. The basic term that increases the base. It is also equivalent to 1. n copies of {0} = n

**Successor term:** A term that is {n} where n is a positive integer, or {{0}#}. Basically it is a successor, an ordinal that you can subtract one from to get a smaller ordinal, to a smaller term and you can subtract one from a successor term.

**Non-Successor term:** A term that is {0#} r, or {{m}#} where m is not 0. Basically it is not a successor to a smaller term; you can't subtract one from a non-successor term.

**Separator term:** Can just be a ',' aka a comma, or can be a more advanced term like [] a dimensional separator. {##[@]1#} where {separator} can be used to act as a separator of {##[@]1#} like 0{separator}n (ex. {##0[@]n#}). Nested separators are separators nested inside separators uninterrupted by layers (no {}s inbetween) {##0[...[...[]...]...]n#}. All separators are apart of the same term they are contained in, so for example {0[...**[#0,b#]**...]1} is apart of the same term as **{0**[...[#0,b#]...]**1}**.

**Entry:** An expression surrounded by the left and right with a separator/curly brace [separator/’{‘]entry[separator/’}’]

**Ascending Layer/Descending Layer:** A layer that we are currently conducting searching on is an ascending layer {##0,a+1#}. Its searches for a descending layer {##\_\_,a#}, then copies everything inside the descending layer when expanding. An ascending layer {##0,a+1#} is a diagonalizer for its descending layer {##\_\_,a#}.

* Scan from left to right searching for the first non-zero entry/expandable term
* Remove all trailing 0s: {##[separator1]0[separator2]#} = {##[separator2]#} if [separator1] < [separator2]
* Enclosing separators: If a term is the separator of a layer and isn’t surrounded by 2 layer terms ex. , convert it by 0[separator]1

**Rules:**

* Base Successor Rule: Case LVn {0}# (where we encounter the leftmost term to be a {0} base successor term):
	+ Delete {0} leaving LVn #
	+ Increase n by 1

* Non-Successor Rule: Case LVn ##{m#}# (where we counter a non-successor term):
	+ Scan inside the nonsuccessor term {m#}

* Successor Expanding Rule: Case LVn ##{m#}# where {m} is a successor term:
	+ ##{m}# = ##|n copies of {m-1#}|#
* Layer Search and Expand Rule: Case LVn {##0,a#} where a is a successor:
	+ Search for {##\_\_,b#} < {##0,a#}
	+ If you can't find a descending layer or smaller, just copy the whole thing and expand it
	+ {##{...{##0,a#}...},b#} = {##{...{##{...{##{...{##0,a-1#}...},a-1#}...},a-1#}...},b#} with n nestings of {...{##0,a-1#}...}
* Splitting Rule: Case LVn {##0[#]m#} where m > 1 and m is a successor:
	+ {##0[#]m#} = {##0[#]1[#]m-1#}
	+ Evaluate {##0[#]1#} ASAP with one of the rules below

* Non Successor Separator Rule: Case LVn {##0[m#]1#} (where we counter a nonsuccessor separator):
	+ Scan inside the nonsuccessor separator [m#]
* Successor Separator Rule: Case LVn {##0[m#]1#} (where we counter a successor separator):
	+ {##0[m#]1#} = {##|n copies of 0[m-1#]|1#}
* Separator Search and Expand Rule: Case LVn {##0[...[#0,a#]...]1#} (where we counter a successor separator and … … is only nested separators [] with no {}s):
	+ Search for a layer with a separator {##0[...[#\_\_,b#]...]1#} < {##0[...[#0,a-1#]...]1#}
	+ {##0[...[#...{##0[...[#0,a#]...]1#}...,b#]...]1#} = {##0[...[#{...{##0[...[#{...{##0[...[#{...{##0[...[#0,a-1#]...]1#}...},a-1#]...]1#}...},a-1#]...]1#}...},b#]...]1#} with n nestings of {...{##0[...[#0,a-1#]...]1#}...}\
	+ NOTE: This rule is actually equivalent to the Layer Search and Expand rule, as the brackets of {...[...[]...]...} are on the **same layer** of the **{**...[...[]...]...**}** term they are contained with

**Level Comparison:**

When comparing two arrays array A = {a1,a2,a3,...an} B = {b1,b2,b3,...bn}. Thank god Pbot isn't here to throw corner cases and stupid questions at us or say 69 chromosomed stuff like that this notation has no strength. Also I assume you know to always apply the remove trailing zeroes rule before comparing A and B.

* \_\_ is the entry of a term that contains our **ascending layer**. \_\_ has the **highest** level in an entry
* Level of {term1}{term2} is the **sum** of level of {term1} and {term2}

Comparing Entries/Single Entry Terms

* Let there be no-comma term A {{a1}{a2}{a3}...{an}} and B {{b1}{b2}{b3}...{bn}}.
* Convert integer a into string of a {0}s
* If A and B have a **different** amount of terms, then add {}s or empty braces that represent 0 to the **smaller** array until both A and B have the **same** amount of terms.
* Let the largest term in A and B be {am} and {bm}, let the 2nd largest term in A and B be {am2} and {bm2} and so on, compare every {amn} and {bmn} in increasing order n starting from {am1} and {bm1}.
* If {amn} > {bmn}, then A > B. If {amn} < {bmn}, then A < B. If {amn} = {bmn}, then compare the next pair of terms {amn+1} and {bmn+1}. If you are done comparing all terms in both A and B then:
* If all {an} and all {bn} are the same, A = B.Comparing terms with multiple entries:
* Let there be term A {a1[A1]a2[A2]a3[A3]a4[A4]...[An-1]an} and term B {b1[B1]b2[B2]b3[B3]b4[B4]...[Bn-1]bn}.
* Convert commas into [0]
* Let the largest separators in A and B be [am] and [bm], let the 2nd largest separators in A and B be [am2] and [bm2] and so on, compare every [amn] and {bmn} in increasing order n starting from [am1] and [bm1].
* If [amn] > [bmn], A > B. If [amn] < [bmn], A < B. If [amn] = [bmn] then:
* For every [amn] compare **everything** (not just entry to the left or right) left and right of the commas. A = {a\_left[amn]a\_right} and B = {b\_left[bmn]b\_right}. If {a\_right} > {b\_right}, A > B. If {a\_right} < {b\_right}, A < B. If {a\_right} = {b\_right}, then:
* If {a\_left} > {b\_left}, A > B. If {a\_left} < {b\_left}, A < B. If {a\_left} = {b\_left}, then:
* If entries are equal, A = B.

### Analysis and Guide

OK starting off, if you know googology decently well, you should know how dimensions in BEAF and BAN and other classical array notations work. A larger dimension (A successor dimension) splits into multiple copies of smaller dimensions. Starting with [1], {0[1]1} diagonalizes over the basic comma. You convert LV5 {0[1]1} = LV5 {0,0,0,0,0,1}. There are exactly n 0,s or zeroes separated from commas here, from LVn. If you see something a larger term like {0[1]4}, perform the splitting rule. Subtract 1 from 4, split a 0[1]1 from it, then IMMEDIATELY EVALUATE THE 0[1]1 ASAP. like LV5 {0[1]4} = LV5 {0[1]**4**} = LV5 {0[1]**1**[1]3} = LV5 {0,0,0,0,0,1[1]3}. Now time for larger dimensions. For example, 0[3]1 splits into n copies of 0[2]s which then splits into n copies of 0[1]s which then splits into n copies of 0,s. LV5 {0[3]4} = LV5 {0[3]**4**} = LV5 {0[3]**1**[3]3} = LV5 {0[2]0[2]0[2]0[2]0[2]**1**[3]3} = LV5 {0[2]0[2]0[2]0[2]0[1]0[1]0[1]0[1]0[1]**1**[3]3} = LV5 {0[2]0[2]0[2]0[2]0[1]0[1]0[1]0[1]0,0,0,0,0,**1**[3]3} = Do your searching cause comma alert! (Wait why the hell am I explaining this... shouldn't you intuitively know this from BEAF or BAN or something?)

Now we can go up. [4], [69]... Then we hit [{1}] or our first nonsuccessor dimensional separator. Simple, when we hit [@] where you can't subtract 1 from @, then just evaluate @. But if you hit {0[@]n} with n > 1, then **apply the splitting rule before evaluating [@].** In fact, **always** apply the splitting rule when you encounter {##0[@]n>1#} **no matter** what [@] is! LV5 {0[{{1}}]**4**} = APPLY SPLITTING RULE LV5 {0[{{1}}]**1**[{{1}}]**3**} = now you can evaluate [{{1}}] LV5 {0[{5}]**1**[{{1}}]**3**} = The [{5}] is not a successor dimensional separator yet so continue evaluating it LV5 {0[{4}{4}{4}{4}{4}]**1**[{{1}}]**3**} = LV5 {0[{3}{3}{3}{3}{3}{4}{4}{4}{4}]**1**[{{1}}]**3**} You get it. (I hope you are still with me or else no headpats for you).

If we hit [{0,1}], then we just do standard comma searching. Note that [] has a higher level than any {}, so you copy whatever [] layers or nested dimensional separators you find with standard {##0,n#} searching. Here is a more complex example for you to understand. LV3 {0[{{0[{{0,**4**},5}]1},3}]1} = Encounter {\_\_,5} continue searching LV3 {0[{{0[**{**{0,**4**}**,5}**]1},3}]1} = Encounter [] continue searching LV3 {0[{{0**[**{{0,4},5}**]**1},3}]1} = Encounter {0[\_\_]1} continue searching LV3 {0[{**{0[**{{0,**4**},5}**]1}**,3}]1} = Encounter {\_\_,3} which is smaller than {0,4} STOP SEARCHING! LV3 {0[**{**{0[{{0,**4**},5}]1}**,3}**]1}. We copy everything inside {**\_\_**,3} which is {0[{{0,**4**},5}]1} which we decrement to become {0[{{0,**3**},5}]1}. LV3 {0[{{0[{**{0,4}**,5}]1},3}]1} = LV3 {0[{{0[{**{**{0[{**{**{0[{**{0,3}**,5}]1}**,3},**5}]1}**,3}**,5}]1},3}]1}. We copy and nest it inside until we have **3** (from LV**3**) nestings of {0[{{\_\_,3},5}]1}.

Now comes the most important and complicated part: **Nested Dimensions**. Stuff like [0,1]. Do not confuse this with [{0,1}]. LV3 {0[**0,1**]1} = LV3 **{0[0,1]1}** = LV3 **{0[0,0]1}** We copy the whole layer into {0[\_\_,0]1}. This is because dimensions/separators are apart = LV3 {0[{0[{0[0,0]1},0]1},0]1} = LV3 {0[{0[{0,1}]1}]1} remove trailing zeroes. Also when we do level comparison we compare the entire term with all of its separators and dimensions. LV3 {0[**0,2**]1} = LV3 **{0[0,2]1}** = LV3 {0[{0[{0[**0,1**]1},**1**]1},**1**]1} = LV3 {0[{0[{0[**0,1**]1},1]1},1]1} = LV3 {0[{0[{0[0[{0[{0[0[{0[{0[**0,0**]1},1]1},1]1}**,0**]1},1]1},1]1}**,0**]1},1]1},1]1} = LV3 {0[{0[{0[0[{0[{0[0[{0[{0,1},1]1},1]1}]1},1]1},1]1}]1},1]1},1]1}. Nested dimensions are what really give Dimensional Zenith its distinguished strength, rocketing the notation from inaccessible level all the way to

Π
n

−

{\displaystyle \Pi\_n-}

reflection, obliterating PDAN and DOR with CNF, as well as an entire flock of post-OFP notations that reach Mahlo or Weakly Compact level but fail to reach

Π
n

−

{\displaystyle \Pi\_n-}

reflection. Yet this is only a fraction of this notation's true power and potential, as the possibility of dimensions can easily be extended even further.

## Super-Dimensional Zenith

Now we are taking power even further beyond! Like other array notations, the next step is to build stronger separators. However, the idea I have for my notation is extremely ingenious. Remember the braces {}, comma , , and brackets []? , and [] act like separators for the {} layer. This took us up to

Π
n

−

{\displaystyle \Pi\_n-}

reflection. But how do we go further? Well, how about we make a new type of separator for [] layers, a separator of separators. We can use new kinds brackets like <>, but I got a more efficient way. Behold, the double comma ,, . If you study SAN/R function you likely would know how the double comma work. {##0,,n#} is the comma for a {##X,,n-1#} layer. {##X,,n#} can act as a separator for {##X,,n-1#} like how previously [] is a separator of {}. By using the double comma, we can construct an infinitely long hierarchy of separators of separators. {##} is {##,,0} or just {##} (remove trailing 0s), [##] is a separator for {##} layers {##,,1} or can be as [##] for better readability, and {##,,2} is a separator for [##]/{##,,1}. {##,,n} may be written as [##,,n] for better readability.

This part of Zenith is where I start to have trouble figuring out how to search and expand. This is also the part of Zenith where the expansion rules. This is also where the concept of ascending and descending layers becomes important. Searching starts when we encounter a 0 followed by a double comma ,, such as in {##0,,n#} (because we search for the first non-zero entry to perform expansion on, ## is a chain of 0s and double commas). {##0,,n#} acts as a separator for a {##\_\_,,n-1#} layer. Therefore, before we commence standard comma searching, we must search outwards for a {##\_\_,,n-1#} layer {} (we search twice). If we cannot find a {##\_\_,,n-1#}, the notation falls apart so we MUST manually enclose it in {##\_\_,,n-1#}. Then we get our {##...0{##0,,n#}m...,,n-1#} and now we can do standard searching. But what do we search for? To keep things simple, {##...0{##0,,n#}m...,,n-1#} must search for {##...0{##0,,n#}m-1...,,n-1#}. But this time if we find something smaller than {##...0{##0,,n#}m-1...,,n-1#} , we automatically enclose a {##...0{##0,,n#}m-1...,,n-1#}. This step might sound unnecessary and unproductive, but the problem is that there might be multiple types of {0,,n} on the layer and choosing what to copy on the layer would be tiresome and even more unnecessary. This step also helps standardize nonstandard expressions, and it acts as a simple and potent safety net for goofy expressions.

### Definition

**Basic Notation:**

LV[base] [insert terms here]

Ex. LV69 {{0,0,1}}

**Terminology:**

**Base:** LVn is the base of this notation. A lot of rules copy and expand a certain amount of times based on n.

**Term:** A pair of curly braces surrounding another expression {##}

**Base Successor term:** A term that is {0}. The basic term that increases the base. It is also equivalent to 1. n copies of {0} = n

**Successor term:** A term that is {n} where n is a positive integer, or {{0}#}. Basically it is a successor, an ordinal that you can subtract one from to get a smaller ordinal, to a smaller term and you can subtract one from a successor term.

**Non-Successor term:** A term that is {0#} r, or {{m}#} where m is not 0. Basically it is not a successor to a smaller term; you can't subtract one from a non-successor term.

**Separator term:** Separator term: {layer0{separator}1##} where {separator} can be used to act as a separator of {layer\_\_##} like 0{separator}n (ex. {##0{0,,n},,n-1#}). Separators induce searching.

**Entry:** An expression surrounded by the left and right with a separator/curly brace [separator/’{‘]entry[separator/’}’]

**Ascending Layer/Descending Layer:** A layer that we are currently conducting searching on is an ascending layer {##...0{##0,,n+1#}a+1...,,n#}, with ## being chains of 0,,sd and {##0,,n+1#} being a comma/separator of {##\_\_,,n#} layer. Its searches for a descending layer {##...0{##0,,n+1#}a+1...,,n#}, then copies everything inside the descending layer when expanding. An ascending layer {##0,a+1#} is a diagonalizer for its descending layer {##\_\_,a#}.

**Alternative Notation:**

[term] = {term,,1}, [##term,,n#] = {##term,,n#} (brackets can be used for separators instead of braces for better readability)

* Scan from left to right searching for the first non-zero entry/expandable term
* Remove all trailing 0s: {##[separator1]0[separator2]#} = {##[separator2]#} if [separator1] < [separator2]
* Enclosing separators: If a term is the separator of a layer and isn’t surrounded by 2 layer terms ex. , convert it by 0[separator]1

**Rules:**

* Base Successor Rule: Case LVn {0}# (where we encounter the leftmost term to be a {0} base successor term):
	+ Delete {0} leaving LVn #
	+ Increase n by 1
* Splitting Rule: Case LVn {##{#}m#} where {#} is a separator of {##\_\_m#} layer and m > 1 and m is a successor:
	+ {##{#}m#} = {##{#}1{#}m-1#}
	+ Evaluate {##{#}1#} ASAP with one of the rules below

* Nonsuccessor Rule: Case LVn ##{m#}# (where we counter a non-successor term):
	+ Scan inside the nonsuccessor term {m#}

* Successor Expanding Rule: Case LVn ##{m#}# where {m} is a successor term:
	+ ##{m}# = ##|n copies of {m-1#}|#

* Successor Separator Expanding Rule: Case LVn ##0{m#}1# or ##{m#}# (where {m#} is a separator for the ##\_\_# layer and m is {0} or a successor):
	+ If the separator is not enclosed, enclose it ##{m#}# = ##0{m#}1#
	+ ##0{m#}1# = ##|n copies of 0{m-1#}|1#

* Non Successor Separator Rule: Case LVn ##0{m#}1# or ##{m#}# (where {m#} is a separator for the ##\_\_# layer and m is not a successor):
	+ If the separator is not enclosed, enclose it ##{m#}# = ##0{m#}1#
	+ Scan inside {m#}

* Separator Search and Expand Rule: Case LVn @@{##0,,a#}m@:
	+ If a is not a successor, evaluate a, otherwise
	+ If m is not a successor, evaluate m, otherwise continue
	+ Step 1: Search for a layer {XX\_\_,,bX} such that {XX\_\_,,bX} <= {##0,,a-1#} , with \_\_ being the separator/term that contains {##0,,a#}
		- If {XX\_\_,,bX} < {##0,,a-1#}
			* Enclose {XX\_\_,,bX} with 0{##\_\_,,a-1#}1 to form {XX{##@@0{##0,,a#}m@,,a-1#},,bX}
	+ Step 2: Search for layer {XX\*\*X} such that {XX\*\*X} < {##@@0{##0,,a#}m@,,a-1#} , with \*\* being the separator that contains {##@@0{##0,,a#}m@,,a-1#}
		- If {XX\*\*X} is not a {##@@0{##0,,a#}m-1@,,a-1#}
			* Enclose it in a {##@@0{##0,,a#}m-1@,,a-1#} to make {##@@...{##@@0{##0,,a#}m@,,a-1#}...{##0,,a#}m-1@,,a-1#}
	+ Step 3: Expand
		- {##@@...{##@@0{##0,,a#}m@,,a-1#}...{##0,,a#}m-1@,,a-1#} = {##@@...{##@@...{##@@...{##@@0{##0,,a#}m-1@,,a-1#}...{##0,,a#}m-1@,,a-1#}...{##0,,a#}m-1@,,a-1#}...{##0,,a#}m-1@,,a-1#} with n nestings of ...{##@@0{##0,,a#}m-1@,,a-1#}...

## Hyper-Dimensional Zenith

Definition

**Basic Notation:**

LV[base] [insert terms here]

Ex. LV69 {{0,0,1}}

**Terminology:**

**Base:** LVn is the base of this notation. A lot of rules copy and expand a certain amount of times based on n.

**Term:** A pair of curly braces surrounding another expression {##}

**Base Successor term:** A term that is {0}. The basic term that increases the base. It is also equivalent to 1. n copies of {0} = n

**Successor term:** A term that is {n} where n is a positive integer, or {{0}#}. Basically it is a successor, an ordinal that you can subtract one from to get a smaller ordinal, to a smaller term and you can subtract one from a successor term.

**Non-Successor term:** A term that is {0#} r, or {{m}#} where m is not 0. Basically it is not a successor to a smaller term; you can't subtract one from a non-successor term.

**Separator term:** Separator term: {layer0{separator}1##} where {separator} can be used to act as a separator of {layer\_\_##} like 0{separator}n (ex. {##0{0,,n},,n-1#}). Separators induce searching.

**Entry:** An expression surrounded by the left and right with a separator/curly brace [separator/’{‘]entry[separator/’}’]

**Ascending Layer/Descending Layer:** A layer that we are currently conducting searching on is an ascending layer {##...0{##0,,n+1#}a+1...,,n#}, with ## being chains of 0,,sd and {##0,,n+1#} being a comma/separator of {##\_\_,,n#} layer. Its searches for a descending layer {##...0{##0,,n+1#}a+1...,,n#}, then copies everything inside the descending layer when expanding. An ascending layer {##0,a+1#} is a diagonalizer for its descending layer {##\_\_,a#}.

**Alternative Notation:**

[term] = {term,,1}, [##term,,n#] = {##term,,n#} (brackets can be used for separators instead of braces for better readability)

* Scan from left to right searching for the first non-zero entry/expandable term
* Remove all trailing 0s: {##[separator1]0[separator2]#} = {##[separator2]#} if [separator1] < [separator2]
* Enclosing separators: If a term is the separator of a layer and isn’t surrounded by 2 layer terms ex. , convert it by 0[separator]1

**Rules:**

* Base Successor Rule: Case LVn {0}# (where we encounter the leftmost term to be a {0} base successor term):
	+ Delete {0} leaving LVn #
	+ Increase n by 1

* Nonsuccessor Rule: Case LVn ##{m#}# (where we counter a non-successor term):
	+ Scan inside the nonsuccessor term {m#}

* Successor Expanding Rule: Case LVn ##{m#}# where {m} is a successor term:
	+ ##{m}# = ##|n copies of {m-1#}|#

* Splitting Rule: Case LVn ##0{m#}a+1# or ##{m#}# (where {m#} is a separator for the ##\_\_# layer and m is {0} or a successor):
	+ If the separator is not enclosed, enclose it ##{m#}# = ##0{m#}1#
	+ ##0{m#}1# = ##|n copies of 0{m-1#}|1#

* Separator Search and Expand Rule: Case LVn @@{##0(n)a#}m@:
	+ If a is not a successor, evaluate a, otherwise
	+ If m is not a successor, evaluate m, otherwise continue
	+ Step 1: Search for a layer {XX\_\_,,bX} such that {XX\_\_,,bX} <= {##0,,a-1#} , with \_\_ being the separator/term that contains {##0,,a#}
		- If {XX\_\_,,bX} < {##0,,a-1#}
			* Enclose {XX\_\_,,bX} with 0{##\_\_,,a-1#}1 to form {XX{##@@0{##0,,a#}m@,,a-1#},,bX}
	+ Step 2: Search for layer {XX\*\*X} such that {XX\*\*X} < {##@@0{##0,,a#}m@,,a-1#} , with \*\* being the separator that contains {##@@0{##0,,a#}m@,,a-1#}
		- If {XX\*\*X} is not a {##@@0{##0,,a#}m-1@,,a-1#}
			* Enclose it in a {##@@0{##0,,a#}m-1@,,a-1#} to make {##@@...{##@@0{##0,,a#}m@,,a-1#}...{##0,,a#}m-1@,,a-1#}
	+ Step 3: Expand
		- {##@@...{##@@0{##0,,a#}m@,,a-1#}...{##0,,a#}m-1@,,a-1#} = {##@@...{##@@...{##@@...{##@@0{##0,,a#}m-1@,,a-1#}...{##0,,a#}m-1@,,a-1#}...{##0,,a#}m-1@,,a-1#}...{##0,,a#}m-1@,,a-1#} with n nestings of ...{##@@0{##0,,a#}m-1@,,a-1#}...

## Analysis

Zenith Analysis Sheet:

https://docs.google.com/spreadsheets/d/1fN6hFcOil-AqM2ZMeekawa0dvGh-XX\_zpPEwMv3HPoY/edit#gid=264712281

1. ↑ Rathjen's ψ, but without the Φ function in thrvdfbnhgfds closure.
2. ↑ The OCF is Extended Buchholz.