Chitan notation

Chitan notation is an in-progress notation created by Googology Wiki user Licorneuhh .

This notation uses arrays, their decreasing making another value grow until the end of the process.

In "Current definition" section, we will explain the summary of the whole system, dividing it by what the author calls "levels".

Current definition

The creator has added an abstract of the notation, divided by "levels". Here is the abstract :

First arrays level

Expressions of this level are of the type :

[A] |f

• [A] is the content of at least one array.
• The f (or follower) number is the principal term of the expression : it will be the final output after the computing process.

Computing process

Array decreasing system

The arrays are the central element in an expression : the computing process is based on their decreasing. They start with an "<" and end with a ">". They can contain natural numbers, separated with a ",".

Rules :

1. An array, to exist in the expression, must have at least one non-zero value in it and can only contain natural numbers as values.

1a. If an array ceases to exist it disappears from the expression.

2. If there is a continue chain of zeroes at the rightmost entries of the array, they are removed and the array now ends at the last non-0 value.

3. The decreasing of an array is concretized by the decreasing of 1 on the leftmost non-0 entry

3a. In addition, if that value has a chain of zeroes at its left, all zeroes that are part of it are replaced by the f number (defined above).

4. At each decreasing, the original array expands to f copies of that array decreased once (if there is a chain of same arrays, you can put an exponent after one to indicate the stacking of that array).

5. The priority goes to the leftmost array.

f value computing process

If there is no (more) array, there is no problem, the result of the expression is just f itself! This is what to do when there is at least one array...

6. When an array decreases, look at the place p (from left to right, p starting at value 1) of the value in the array that decreased by 1: if it was in the first place, f is replaced by f*f (or f²). If it was in second place, f is replaced by f↑f = f^f, in the third place f↑↑f etc...

In general, if a value decreases at the p-place in an array, f is replaced by f↑^p2, using Knuth's arrow notation with the exponent after the arrow being the number of arrows.

Examples:

<2>|2 = <1><1>|4 = <1>|16 = 256
<2><1>|2 = <1>³|4 = <1>|256 = 65 536
<1><2>|2 = <2>|4 = <1>⁴|16 = <1>²|65 536 = <1>|4 294 967 296 = 18 446 744 073 709 551 616
<0,1>|2 = <2><2>|2↑↑2 = <2><2>|4 = <2>|18 446 744 073 709 551 616 = 18 446 744 073 709 551 616^{218 446 744 073 709 551 617} ~ 10^101018.74

Subarrays level

Expressions of this level are the same type as before, except an array can have a "subarray" (or "2-array") in it, as the following :

< A₁ {A₂} > |f

Where A₁ is the content of the simple array and A₂ the content of the subarray. The special brackets "{}" represents the subarray of the principal array.

Array decreasing system

Rules :

7. Subarrays are arrays composed of arrays. To exist, there must be at least one entry (so one array) in it.

7a. Empty entries in subarrays are represented with the symbol "∅".

7b. If there is at least one empty entry at the rightmost entries of the subarray, this entry is removed

7c. Arrays in subarrays are submitted to the same laws as the main arrays and can have subarrays themselves.

7d. If an array in a subarray would normally decrease to <0> and disappear, if there is at least one non-empty entry at the right of it, it decreases to an empty entry instead

7d1. If that entry was the rightmost non-empty entry, that entry is just removed after its decreasing.

7e. The decreasing of subarrays works as followed :

7e1. A subarray decreases only in the case when its main array would decrease to <0> and so disappear

7e2. A subarray's decreasing as the following consequences on the main array :

• The main array fills out with f entries "f".

7e3. A subarray's decreasing as the following consequences on itself :

• The decreasing of a subarray implies the decreasing of the leftmost non-empty entry (being the decreasing of an array in the subarray).
• If the leftmost non-empty entry is the leftmost entry :
  • That entry decreases normally, following all the simple arrays' rules.

• If the leftmost non-empty entry has empties entries at its left :
  • Let's denote p the place of the decreasing entry (place 1 being the leftmost entry of the subarray)
  • All the entries at the left of the decreasing entry (so entry 1 to entry p-1) expand out to, each one :
    • f principal arrays with f entries f, with each one a subarray S.

(Repeat the following process f times) [ This subarray S is the decreased once subarray up to that part of the process.]

• • This subarray S is the original subarray with the leftmost non-empty entry decreased once, entries 1 to p-1 being replaced by f arrays with each one f entries "f".

Here are more formal definitions :

Simplified (case the decreasing entry is the leftmost one in the subarray) : <1 {< A>, R} > |f = < F {< A-1>^f, R} >^f |D(f²)

Where :

• A is the content of the 2-array
• A-1 is the content of the 2-array decreased once
• F is f entries "f" in the array
• D(n) is the effect of the decreasing of the 2-array applied to n.
• R being the other entries in the subarray (if existing).

Expanded (case the decreasing entry in the subarray isn't the leftmost entry) :

<1 {∅,∅,..., < A>, R}> |f = < F {[< F {...(f+2 nestings)...{[< F {[< F>^f]^p-1, < A-1>^f, R} >^f]^p-1, < A-1>^f, R}...} >^f]^p-1, < A-1>^f, R} >^f |D(f²)

Where : * A is the content of the decreasing entry in the subarray

• A-1 is the content of the decreased entry in the subarray
• F represents f entries "f" in the array which it is placed
• D(n) is the effect of the decreasing of the entry in the subarray to n
• [ ]^m represents an entry content being in all places from place 1 to place m
• R being the other entries in the subarray (if existing).

f value computing process

Same rules as the first level, just be careful to the fact that the decreasing of the principal part prioritizes on the decreasing of the 2-array for the applications to f.

Examples :

<1 {<1>} > |3 = <3,3,3>³|(3²)² = <3,3,3>³|81

<1 {<0,1>} > |3 = <3,3,3 {<3>³} >³ |(3²)↑↑2 = <3,3,3 {<3>³} >³ |387 420 489

<1 {∅,<1>} > |2 = <2,2 {<2,2 {<2,2 {<2,2 {<2,2>²} >²} >²} >²} >² |16

<1 {∅,<1>²} > |2 = <2,2 {<2,2 {<2,2 {<2,2 {<2,2>²,<1>} >²,<1>} >²,<1>} >²,<1>} >² |16

<1 {∅,<2>} > |2 = <2,2 {<2,2 {<2,2 {<2,2 {<2,2>²,<1>²} >²,<1>²} >²,<1>²} >²,<1>²} >² |16

<1 {∅,∅,<1>} > |2 = <2,2 _{{<2,2 {<2,2 {<2,2 {<2,2>²,<2,2>²} >²,<2,2 {<2,2>²,<2,2>²} >²} >²,<2,2 {<2,2 {<2,2>²,<2,2>²} >²,<2,2 {<2,2>²,<2,2>²} >²} >²} >²,<2,2 {<2,2 {<2,2 {<2,2>²,<2,2>²} >²,<2,2 {<2,2>²,<2,2>²} >²} >²,<2,2 {<2,2 {<2,2>²,<2,2>²} >²,<2,2 {<2,2>²,<2,2>²} >²} >²} >²}} >² |16

(subscript notation used here, intending to make it more readable)