## Ψ.1.Natural repetition

### # 1.2.Meta-notation

The ravens sit on Óðins shoulders and say into his ear all the tidings which they see or hear. They are called thus: "Huginn" (Thought) and "Muninn" (Memory).
He sends them at day-break to fly about all the world, and they come back before the noon meal, so he is acquainted with many tidings. Therefore men call him "Hrafnaguð" (Raven God), as is said:

Hugin and Munin hover each day the wide earth over.
I fear for Hugin lest he fare not back, --
yet watch I more for Munin.

Gylfaginning 38.

#### §1.2.1.Selection

We use meta-expressions to write rules for the evaluation of mathematical expressions. This helps us tame longer sequences of characters (called words) that have the capacity for Bigger numbers.
We apply a series of meta-statements from left to right to the corresponding marks in the source expression. By default we select subexpressions left associatively, but the order in the source can sometimes be overruled.

A few selected example cases will make this click!
Because a single meta-statement can serve multiple associated marks in the source, our method is to keep replacing these marks for as long as every meta-statement can be applied at least once (1st case).
That word selection is left meta-associative means that all preliminary correspondences are resolved moving through the meta-expression from left to right, even if the arithmetical evaluation is right associative (2nd case).

aabaa {a:p a:q} = ppbpa {a:q} = ppbpq

5*..5*..... {*#2 *#1 5#5} = 5**5*... {5#5}
= 5**(5*5*5*5*5) = 5^3125 =

19110125979454775203564045597039645991980810489900943371395127892465205302426158
03012059386519739850265586440155794462235359212788673806972288410146915986602087
96189675719570183928166033804761122597553362610100148265112341314776825241149309
44471769652827562851967375143953575424790932192066418830117871691225524210700507
09064674382870851449950256586194461543183511379849133691779928127433840431549236
85552678359637410210533154603135372532574863690915977869032826645918298381523028
69365728736914226481312917437621363257303216452829794868625762453622180176732249
40567642819360078720713837072355305446356153946401185348493792719514594505508232
74922160584891291094518995994868619954314766693801303717616359259447974616422005
08850794698044871332051331607391342305401988725700383298012460501970134673971759
09027389493923817315786996845899794781068042822436093783946335265422815704302832
44238551508231649096728571217170812323279048181726832751011274678231741098588868
37085220007117334922539133223007561471804290075276777933523062006182860124552542
43061006894805446584704820650982664319360960388736258510747074340636286976576702
69925864995355797631817390255089133122329474393034395616132833407283166349825814
52268620043077990846881038041873683248009038735962129196336025831207816736737425
33322879296907205490595621406888825991244581842379597863476484315673760923625090
37151179894142426227022006628648686786871018298087280256069310194928083082504419
84247967920589088171123271923014555829167467951974305480264046468540027339938607
98594465961501752586965811447568510041568687730903712482535343839285397598749458
49705003822501248928400182659005625128618762993804440734014234706205578530532503
49181895897071993056621885129631875017435359602822010382116160485451210393133122
56332260766436236688296850208839496142830484739113991669622649948563685234712873
29479668088450940589395110465094413790950227654565313301867063352132302846051943
43813998105614006525953007317907727110657834941746426847209561346473277485842382
74899668755052504394218232191357223054066715373374248543645663782045701654593218
15405354839361425066449858540330746646854189014813434771465031503795417577862281
1776585876941680908203125. = 5^^3

a,..,.. {#2} ≠ a,..,a,.., {#2} ≠ a,..,a,a,..,a,, etc.
= a,a,,.. {#2} = a,a,,a,a,,

1.... {..#3 #2} = 1...... {#2} = 1...... {#2 #2 #2}
= 11.... {#2 #2} = 1111.. {#2}
= 11111111 = 8

The false red inequalities show (in the 3d case) that we must avoid meta-evaluating from the right in the source, if this allows an endless repetition of repetition marks, leading to an infinite expression. A series of meta-statements and their targets (characters or marks) in the source are preferably kept in the same left to right order.
When we overrule the default direction in the source this must be done intelligently and explicitely. For example when a right mark reflects on a subordinate left mark – notably when a power repetition n first repeats the dot marks for a repetition m targetted left AB.... {B..#n #m} as above (4th case with B void).

Apart from the curly violet braces {} of meta-expressions for substitution and repetition, collections in golden curly braces {} for set and class will be used to order mathematical construction methods according to their speed. We can give a rough estimate of the size of numbers, if we know which class the number generating function belongs to.
For rewrite or waitor brackets [] on the level of the source expression, refer to chapter 2.5.3.

To show which part of the source expression a meta-statement applies to, we either Quote the intended character(s) in the meta-statement, or point to their . beginning and (optionally) end . with dots inserted in the source. As subsequences get longer, dot selection saves on paper and ink. (o: the legendary pink dots :o).

A.Q {Q:S} = A.Q {:S} = AS
A.Q.Z {Q:S} = A.Q.Z {:S} = ASZ
AQ...Z {Q#n} = A.Q..Z {#n} (left quote and right dot selection)

Meta-notation can get quite involved when we work out reduction cascades of operatorial Big number functions which would otherwise be inaccessible. But often we use it to state simple arithmetical facts about the expression and its context. For starters we'd use a meta-statement to mark the empty space betwixt numbers, in case of ab {0*} to add (our default) and in case of ab {0^} to multiply neighbouring variables.

#### §1.2.2.Substitution

A philosopher of language would consider all notation as substitution – a word to be a placeholder for the real thing, even if the thing our words point at is a platonic ideal. Human speech produces vectors that direct our body and mind to intervene in the course of reality and fight entropy. But when those vectors start to point back...

For a computer substitution begins with selection, the read – which requires recognition and precise positioning – and then replacement, the write – which combines the acts of removal and insertion.
We use the sign : for substitution and let A.X.Z {X:S} = ASZ define a single substitution operation, removing the characters X positioned between the dots and inserting the substitute S in place.

In mathematics any number can be built from units and substitutions. Both substitution .1.1 {1:n} and repetition 1..1 {1#n} express the same successor n1 of number n. Constructing next numbers n1 by substitution it is obvious that n need not be a natural number.
Similarly we can define multiplication a*b as a series of substitutions 1.. {1#b 1:a} of all units 1 in natural number b for the number a. This repeated substitution works regardless whether a≠1 or a is natural or not.

A meta-statement of substitution is A:B or more precisely A:B in P where the substitute word B replaces A on the target sites A in the source expression or exclusively in part P of the expression.
The evaluation is given by XAZ {A:B} = XBZ and TPY {A:B in P:XAZ} = TXBZY, where all A in X and Z are included – recursively as X'AZ' etc. – but possible A in T and Y are excluded from the substitution.
If substitute B is empty, then XA {A:} = X removes site A recursively from each X'..A word.

The case of X {:B} on its own does nothing, because an empty site is normally not eligible for substitution. Any substitution rule n {:1} = n1 of zero, would lead to n1.. {1#ω} = ω a definition of infinity.
We'd rather use ω directly, and apply (:n) only to enumerate characters in hyperarithmetic.

Just like multiplication, repetition of a word A by a whole number n can be covered by two substitutions A:n 1:A. This works for all A (for XAZ subsequences dot selection or the in clause helps).
Repetition by substitution embodies a distributive law, it doesn't raise issues when A.. {#n} ≠ n.. {#A} is not composed of (evidently) commutative factors, such as omegas and zeros.

A {A:n 1:A} = n {1:A} = 1.. {1#n 1:A}
= .1n- {1:A} = A.n- {1:A} = AA.n-- {1:A}
== [A..].1 {A#n- 1:A} = [A..].0 {A#n 1:A}
= A... {A#n}

Vice versa you can notate substitution A {A:B} as repetition, by A...B {A#} which looks somewhat odd. The A left of the ellipsis will be selected for repetition by 0 and removed, so that the B the tooth fairy appended is left. Nothing is actually substituted – the illusory series A... was simply pulled out!

Kurt Gödel
Princeton 1956

#### #Hypercode

The text on your screen is stored as binary codes in your computer – Unicode boasts a fixed size of 16 bits and 65535 characters. Similarly the symbols of an ever expanding mathematical system can be translated to natural numbers :n to form series of 1.. delimited by : stops.
For example :0 =   should code for null and :1 = X {X:1} = 1 seems onely natural. Follows the separator :2 = , for expression input, plus a pair of brackets `at least` for machine evaluation.

Then the transposed sentences jump to the first hyperarithmetical level y=1, which is in essence a table that swaps characters for numbers, so the meta-sign of substitution : applies. What is called the hyperarithmetical hierarchy would be the enumeration :y;n of a cascade of hyperarithmetical jumps or code translations.

The purpose of hyperarithmetic for Big number lovers is obvious. If you have a lot of different :0 (ground level) signs, enumerate them as :1;1.. numbers and use these instead. When you know how to streamline your axioms (the rules to evaluate expressions), any size definition can be expressed in hyper-numbers.
If the coast looks clear and the weather is fine, a Big number n can call some far away code :1n sign, that would allow you in :0 to create even Bigger numbers n' with, round and round we go…
The recursion that arranges this would necessarily be written in the language :1 of a higher hyperarithmetical level, with an alphabet encoded :2;1 = 1 and :2;2 = : to start with. Then a higher loop can jump in to exploit the full power of recursion over characters and levels in a :y; hyperarithmetical hierarchy.

In the beginning Substitution, Repetition and Numbers were One. Only when fractions arose the three became separated from counting. Later logicians tried to reduce the original Trinity to functions, but presupposed the very concepts they were required to explain, and wicked teachers of maths still worship their contrived idols.

Likewise there is no way to construct 1 without mentioning it, either by repeated addition 0..1 {0#0} or by substitution with a void substitute in the successor function ..1 {:n} = n1.
And even if we allow an empty index 0 in our dictionary to code for 1 then apart from a dereference to 1 in the code list, there's also a reference to a hyper-level needed to find the dictionary, and that level can't be zero, it goes at least one : colon up.

..1 {:} = .0.1 {0:0} = 01 = 1
{1::0}= :0. = :.

Though we use meta-repetition statements profusely, in our view substitution is the True Way, if only because it expresses   {0:1} = 1... {1#ω} = ω infinity naturally, where the raven of repetition should fly off to a rapacious .. {#ψ} = 0... {0#ψ} = 1 end of the world, if ever, to meet the initial One, or else wait nine days for Him to fall  .. {# 0^} = 0^0 = 1 from the Tree of More remember?

#### §1.2.3.Repetition

We define a meta-notation for repetition, applied in mathematical and logical expressions.
By extending it with smart features this will be our main tool for constructing Big numbers.

Notate a repeated sequence A in an expression in the format XAB...Z {A#n}
where B is optional and A the first occurrence of the word A left of the ellipsis.

The meta-repetition A#n substitutes AB in the source n times for the word A
whilst inserting the word B in between, before every next A, overall n- times.

If all characters A directly left of the ellipsis are to be repeated, this allows us
to omit them with an open repetition A...Z {#n} or by dot X.A..Z {#n}

We abbreviate a 3-dot ellipsis ... to a 2-dot ellipsis .. whenever this is convenient.
Superscripted ellipsis ×... count operators, e.g. 2^..3 {^#n} = 2*..4 {*#n}

Extend the notation for meta-repetition to cover double-sided recursive constructions.

Instead of the formal XAB...CD...Z {A#n D#n} an equal number of
n repetitions on both sides of the ellipsis is written AB..C.D {A#n#D}
or alternatively as A.CDE.. {A#n#D} so if n=0 the term C remains.

If all characters to the left and/or right end of expression A..C.D are repeated,
we omit A or/and D from the meta-part with {A#n#} or {#n#D} and {#n#}
Likewise for A.C.D..Z where Z is optional, {#n#} repeats both A and D.

An expression AB.... {B..#m #n} with two 2-dot ellipsis .. is a dual repetition,
where the first hash #m repeats the ellipsis .. then linked to the second hash #n
while strict left associativity for meta-statements is used to work out all repetitions.
To illustrate the rule that meta-statements can have multiple associated marks,
the single #n repeats all three open repetitions A..Z starting from the left.

a,.... {,..#3 #n} = a,..,..,.. {#n} or {#n #n #n}
{n:3}= a,a,a,,a,a,a,,a,a,a,,,
a,a,a,,a,a,a,,a,a,a,,,
a,a,a,,a,a,a,,a,a,a,,, = a,:: {#3}
{a:3}= 3,

if  nB.... {B..#n #n} ~ nB.... {B..#n- #n}
=> A.nB::BZ {#n} = A.nBZ (dimension box clubs convention)

A full dimension box where dual repetition m=n is marked by a square ellipsis ,::
can be followed by a shorthand meta-statement {#n} instead of {,..#n #n}
and in case all specifications of such a dimension box are equal, we can write n,

#### §1.2.4.Incrementation

We reserve the special meta-variables i,j to allow repeated sequences to evolve.
These are always part of a meta-repetition statement, such as XAiB...Z {Ai#n}

Variables i and j signify incrementors, repeated inside A or (also in) B,
which start with 1 and at each iteration increment by 1 until n is reached.
The default starting value i:1 may be overruled, e.g. by specifying i≥0
but then, after n iterations, the value of the incrementor will stop at i:n-

Incrementors can be followed by an iterative ellipsis, named illipsis .:. or :.
:. Indicates the sequence in which the preceding meta-variable is dealt with
and overrules the ellipsis right after the incrementor, which owns i by default.
A typical example, and a hard one where a single illipsis increments both j.

The meta-statement that owns the ellipsis is resolved first – overruling left associativity.
On occassion (defining a structure) only the meta-statement contains an incrementor,
these ..#ni can repeat each of the corresponding .. marks with a different value.

In any enumeration the meta-variables i and j are applied purely as indexes
numbers as unique labels for variables – where the value itself isn't determined yet.
But when we use i in a calculation, the direction of incrementation can be specified,
so that í increments toward the right, and ì decrements (adds up from right to left).

í*... {í#n} = 1*2*..*n = n! (factorial)
ì*... {ì#n} = n*n-*..*1 = n! (same)

í^... {í#n- i≥2} = 2^3^..^n > ì1^... {ì1#n-} = n^n-^..^2

We won't run out of incrementors, they can be subscripted in to get the next.
Also a substitution series can replace all word variables v with a unique value
or word Xi for example O(v,..) {v#n v:Xi} = O(Xi,...) {Xi#n}

Given a rule or a general expression X {M} the meta-statements in M reflect on the source X to determine the properties of a variable (a subrange of 0<a<ω) or a series of replacements of a word (a meta-repetition A#k) before the expression can be properly evaluated to a new expression Y.

X {Mi ... {#m}} = Y {Ni ... {#n}}

The correspondences between the marks in the source and the meta-statements Mi are resolved by moving from left to right through the meta-expression. This we've called the left meta-associativity of selection.
As long as it's clear which source marks are selected by which meta-statements we tend to write them in the same default order. In practice this order doesn't matter much, because a single meta-statement can be thought to address all previously repeated marks associated with it.

An exception to the rule of left associative pre-evaluation occurs when a left meta-statement (with an incrementor i usually) is dependent upon a right correspondence. Examples in chapter 2.3. and 2.7. show how the right statement is resolved before the incrementation that it is said to own, and that is formally repeated both inside the source and the meta-expression.

ci.... {ci#j #2} = ci..ci.. {ci#1 ci#2} = c1c1c2
ci..:. {ci#i #2} = c1..c2.. {c1#1 c2#2} = c1c2c2
ci.... {#j #2} = ci..ci.. {#1 #2} = c1c1c1c2
ci..:. {#i #2} = c1..c2.. {#1 #2} = c1c2c1c2
ci.... {ci#3 #2} = c1c2c3.. {#2} = c1c2c3c1c2c3
ci..:. {ci#3 #2} = c1..c2.. {c1#3 c2#3} = c1c1c1c2c2c2

ci.... {ci..#2 #3} = ci..ci.. {#3} = c1c2c3c1c1c2c3c2c1c2c3c3

It is easy to forget that meta-notation with its various extensions and (not so well explained) exceptions isn't a goal in itself, but is primarily meant to help us write complicated expressions in a concise manner. Sometimes a formula can best be understood from its intended purpose or by looking at the available preliminary cases.

We use greedy + quantifiers for the reduction of term-rewrite expressions, similar to the way that text is matched by Regular Expressions in computer languages. Selection of a word (subsequence) by a meta-statement is greedy if it covers a maximum number of words in the source expression.
A rewrite rule that is marked greedy is not allowed to continue selecting the indicated word in an adjacent area of the source. So meta-repetition of parameters stops short at (or just before) a

The scope of a meta-sign is by default undetermined when it is in the company of a wildcard, but then lazy evaluation can be a risk. A quote that is strictly lazy selects only its indicated subsequence (marked S below) in the source, nothing more, so the length of the overall repetition is unknown. But a greedy quote would also target any possible adjacent S at the end of A and/or the start of Z.

ASSSZ = AS...Z {S#3} (undetermined)
= AS...Y {S#+k k≥3} (greedy) => Y:≠SY'
= BS...Y {S+#+k k≥3} (both greedy) => B:≠B'S & Y:≠SY'

ASS... {S-#n} = AS... {S#p≤n} (left lazy) => p≥1
== BS {B≠B'S}

To make sure the wildcards A or Z are not part of the indicated substitution or repetition, the meta-sign # is declared greedy by appending a plus + on either side. We can have +#+ on both sides, or greedy selection can be applied in one direction with +# for left and #+ for common right greedy meta-repetition.

Expressions with wildcards need careful definition. Substituting S:1 in the examples above, the subsequences A1 and 1Z become problematic when the greedy issue isn't properly resolved (hence the if clauses). But some variables lead ambiguous lives too, when at a certain value they become part of a designated series.
Note that the greedy + sign never returns in the preceding source, so in case an operator sign + should be repeated this clearly shows in the source expression.

#### #Greedy vs. lazy definition

When we define a greedy upload rule on a row R this will match three types of expressions in one go (we put k=2 in all cases below). The type of expression excluded by greedy selection #+ is highlighted (regardless if , is a bad way to start a row). As usual after evaluation any empty trailing characters ,0 are chopped off.

rule:  a,b,1,...,1R {1#+k} => R:≠,1R'
= a,b,...,R {b#k1}  where  a,b,1 ≠ a,b => k>0

cases: a,b,1,1,11,z = a,b,b,b,1,z  {R:1,z}
a,b,1,1,11 = a,b,b,b,1      {R:1}
a,b,1,1,1 = a,b,b,b,        {R:0}

Greedy selection is not a good choice when simply adding another axiom provides more clarity. To balance the definitional trade-offs of generalizing the above upload rule to any final Z seems daunting, when you consider the discrepancies such greedy forms show!

forms: a,b,1,...n1,Z {1,#+k} = a,b,...n,Z {b,#k1}
a,b,1,...,n1Z {1#+k} = a,b,...,nZ {b#k1}
and   A1,0,Z {n=0} = A1,Z
a,b,1,...,1Z {1#+k} = a,b,...[,]Z {b#k1}
if   Z:=1Z' => [,]1:,1   else  [,]:0

rules: a,b,1,...,11Z {1#k} = a,b,...,1Z {b#k1}
a,b,1,...,,Z {1#k} = a,b,...,,Z {b#k}
case:  a,b,1,... {1#k} ={Z:}= a,b,...,, {b#k1}

To treat meta-selection in different ways is not so rigorous, but until this matter of the definition of operatorials is properly standardized the greedy + sign can help to visually reduce the number of rules in an algorithm.

Anything which either is or is not can be counted. Every recursion starts with a single operation, defined with an initial case and a single step. With bird's-eye view we can reduce the number of steps to a single meta-repetition.
As the rules for the reduction of Big number constructions become ever more complex, the meta-operator # for repetition will come to lead a life of its own. We predict that, at an advanced stage, the whole hip hop movement between source and meta-expression bursts open for a higher #.. meta-quantification.