The next class of big numbers comes from the deep.
To increase the depth of
nested arrays
directly, we define a system of deep arrays, or deeps.
Deeps ,[U]
are series
,[T_{1}][T_{2}][T_{3}]..
of nested arrays of arbitrary depth and length.
Note: on words, variables, entries, brackets and rules.
Words X,Y,Z
can contain all allowed characters or none.
Inside subarrays R,S,T
all brackets are paired []
together,
but inside deeps U,V,W
an unpaired closing
][
opens a next deep.
Variables are greedy for number units,
so if a rule matches some n or n1
in an expression,
we'll never miss a 1
or 
that is unaccounted for on either side of the var.
An entry has on its left a sep array closing ]
or an opening bracket [
if it's the first entry (0th index).
On the right it has the next sep comma ,
or an array end ]
if it's the last entry.
Same for an empty entry, signified by º
or zero 0
.
So there is no number 0
in between ][
deep arrays.
In our systems an array is always attached to some sign
*
,
]
etc.
An array attached with its opening bracket to a left sign,
creates a type array for that sign.
A sentry is a triple of a comma ,
sep followed by a type array and a number entry or value.
The function of a sentry value,
is determined by the rule we apply,
which depends on its place in the array.
Our systems reduce short but complex input,
to long but simple output 1..
(of maximum entropy).
An algorithm is reducible and sound,
if evaluation of finite expressions always halts,
so vicious cycles never happen.
Also our rules must be crafted
to avoid the collapse of valuable structures to zero.
We take comfort from the reductions below:
the rule system for deeps looks maximal and sound.
It passes the test, but proof becomes difficult.
When an array has been depleted or is empty to start with,
we can supply it with new depth.
In the example below, the next deep index c1 only
confirms
the nesting. Entry d1,
right on the parent array, is the actual depth counter
.
The array level from the initial nesting is further increased
by reload of b down in the 3d line.
A series of c different nestings follows,
each adding b next levels.
Only then we get to see a normal nested array:
at the extreme depth d+b*c
.
And near it many other deeps,
all set for a big increase of future depths,
spread out along the original array.
#

( ,[][c1]d1
.b)
=
,[,[][c1]d][c]d1 nesting step,
==
,[..,[][c1]..][c]í :d1: the entryí
decreases..
=
,[..][c]í :d1: ..right from d1 to1
in the middle. 
,[0][c]1
=
,[,[][c]0][c]1=
,[0][c]1==
,[][]1=
1 
,[,[][c]1][c]2
=
( ,[1][c]2 .b)=>
,[][c]b,[1][c]1 
,[][c]b
=
,[..][c]í :b:
⋮
⋮
⋮
,[][1]b=
,[..][]í :b:=
,[..]í :b: 
( ,[,[]1]2
.b)
=
,[1]2=>
,[]b,[1]1
=
b,[1]1≡
b,1 first comma, ≡ ,[1]

( ,[b,1]3
.b)
=>
,[b,1]b,[b,1]2
==>
,[,1]b.,[í,1]b..,[b,1]2 :b
=>
,[b]b.,[í,1]b..,[b,1]2 :b 
( ,[b]b
.b)
=>
,[b]b,[b]b
==>
,[]b.,[í]b.. :b
=
b.,[í]b.. :b 
,[b……,[b,1]2]4
=>
b……,[b……,[b,1]2]3 
,[b……,[Nest1]5
=>
b……,[Nest2]4 
,[b……,[Nest3]b,[1][1]1
≈>
b……,[1][1]1 
,[b……,[1][1]1][1]3
=>
b……,[Big1][1]2 small deep is big 
,[b……,[Big1][1]2][1]4
=>
b……,[Big2][1]3 
b……,[Big3][1]b,[1][2]1
≈
b……,[1][2]1 
⋮
⋮
⋮
,[b……,[1][c]1][c]3=>
b……,[Big4][c]2 
,[b……,[Big4][c]2][c]4
=>
b……,[Big5][c]3 
,[b……,[Big6][c]d][c]d1
=>
,[1+Big7][c]b,[Big7][c]d
Click the board, to reduce the example above,
until the parent array is filled to the left rim.
All structures created here by deep nesting
wouldn't even fit on a webpage the size of the universe,
so we only show subexpressions
at crucial moments during evaluation.
We adapt the rules for superstars and nested arrays
to the new deeps U
,
and define a general system for recursive nesting of arrays.
#
 a*{}b = ab (add)
 a*{V}1 = a (unity)
 a*{1V}b1 = a*{V}(a*{1V}b) (powers)

[U]
≡
([T_{i}]){m1} (deep arrays) 
,?[]1
=
1 (off side) 
,[U]0
=
0 (sep elim) 
( ,[1U]1 .b)
=>
,[U]b,[1U] (reload) 
`
≡
,([]){n} (macro) 
`[][1U]1d
=
`[`[][1U]d][U]1d (nesting)
The magenta
code are Regular Expressions.
Words are grouped by round brackets,
and counted within curly brackets.
A question mark ,?
means we have one or none of the preceding group or character,
here a separator sign.
An opening bracket [
with its deep array U]
can be attached to any construct,
be it ,
or ,[][][]
or some future array operator sign.
Deep nesting of arrays will work in any context,
and refill the preceding empty arrays.
To always use entry d
of the parent array as a depth counter will be problematic.
Instead, we can reserve the first two entries of a deep
to nest the left empty array, with minor loss.
The deep array inside
2*{4,.[6]..5}3 :7
appears innocent, like digits 6666666
that add up to 42
in base ten,
but it helps produce unimaginably long
1..
output.
Deeps are analogous to natural numbers,
when we count one array as the unit 1
.
Next blog
will perform elementary operations over deeps,
much like we add, multiply and raise powers with numbers.
And if we allow for superdeep star operations over arrays,
this has the potential to change the status quo in big number land.
~~ Deeper and Down ~~
No comments:
Post a Comment