#
*“On the shoulders of giant numbers”*

http://www.iteror.org/big/book/ch1/ch1_2.html
big**Ψ**

http://www.iteror.org/big/book/ch1/ch1_2.html

## Ψ.1. Natural repetition

#####
chapter 1.2, *edit 0.2.9*

published: *2010-11-05*

updated: *2011-12-30*

### # 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.... `

as above (4th case with `{B..#n #m}``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
`Q`uote 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).

`{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 `

and `{A:B}` = XBZ`TPY `

, where all
`{A:B in P:XAZ}` = TXBZY`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 `

removes site `{A:}` = X`A`

recursively from each `X'`

word.^{..}A

The case of `X `

on its own does nothing,
because an empty site is normally not eligible for substitution.
Any substitution rule `{:B}``n `

of `{:1}` = n1*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.. `

is not composed of (evidently) commutative factors,
such as `{#A}`*omegas* and *zeros*.

`{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 `

as repetition, by `{A:B}``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

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 `:`

of a cascade of
_{y;}n*hyperarithmetical* jumps or code translations.

The purpose of *hyperarithmetic* for Big number lovers is obvious.
If you have a lot of different `:`

(ground level) signs,
enumerate them as _{0}`:`

numbers and use these instead.
When you know how to streamline your axioms (the rules to evaluate expressions),
_{1;}1..*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 `:`

sign, that would allow you in _{1}n`:`

to create even Bigger numbers _{0}`n'`

with, round and round we go…

The recursion that arranges this would necessarily be written in the language
`:`

of a higher hyperarithmetical level,
with an alphabet encoded _{1}`:`

and
_{2;}1 = 1`:`

to start with.
Then a higher loop can jump in to exploit the full power of
recursion over characters and levels in a _{2;}2 = :`:`

_{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.`{:}`= .

*0*.1

`{`=

*0*:*0*}*0*1 = 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 Moreremember?

#### §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 `

an equal number of`{A#n D#n}`

`n`

repetitions on both sides of the ellipsis is written
`AB..C.D `

`{A#n#D}`

or alternatively as `A.CDE.. `

so if `{A#n#D}``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.... `

with two 2-dot ellipsis `{B..#m #n}``..`

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.nB♣Z
(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
`XA`

_{i}B...Z `{A _{i}#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 `..#n _{i}` 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 `i`

to get the next._{n}

Also a substitution series can replace all word variables `v`

with a unique value

or word `X`

for example
_{i}`O(`

**v,..**) `{v#n v:X _{i}}`

`= O(`**X**_{i},...) `{X`_{i}#n}

#### §1.2.5. Advanced selection

Given a rule or a general expression `X `

the meta-statements in `{M}``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`

.

`{M`= Y

_{i}...`{#m}`}`{N`

_{i}...`{#n}`}
The correspondences between the marks in the source and the
meta-statements `M _{i}` 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.

Compare the cases below, and more if you
click here!

_{i}....

`{c`= c

_{i}#j #2}_{i}..c

_{i}..

`{c`= c

_{i}#1 c_{i}#2}_{1}c

_{1}c

_{2}

c

_{i}..:.

`{c`= c

_{i}#i #2}_{1}..c

_{2}..

`{c`= c

_{1}#1 c_{2}#2}_{1}c

_{2}c

_{2}

c

_{i}....

`{#j #2}`= c

_{i}..c

_{i}..

`{#1 #2}`= c

_{1}c

_{1}c

_{1}c

_{2}

c

_{i}..:.

`{#i #2}`= c

_{1}..c

_{2}..

`{#1 #2}`= c

_{1}c

_{2}c

_{1}c

_{2}

c

_{i}....

`{c`= c

_{i}#3 #2}_{1}c

_{2}c

_{3}..

`{#2}`= c

_{1}c

_{2}c

_{3}c

_{1}c

_{2}c

_{3}

c

_{i}..:.

`{c`= c

_{i}#3 #2}_{1}..c

_{2}..

`{c`= c

_{1}#3 c_{2}#3}_{1}c

_{1}c

_{1}c

_{2}c

_{2}c

_{2}

c

_{i}....

`{c`= c

_{i}..#2 #3}_{i}..c

_{i}..

`{#3}`= c

_{1}c

_{2}c

_{3}c

_{1}c

_{1}c

_{2}c

_{3}c

_{2}c

_{1}c

_{2}c

_{3}c

_{3}

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
wildcard.

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.