Friday, 12 June 2015

Deep Numbers

Nudea with Egyptian headdress against wall with masks

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 ,[T1][T2][T3].. 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 to 1 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
  • => b……,[Big7][c]d reduced up to the left parent array

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] ([Ti]){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 ~~

I want all the world to see  To see you're laughing  And you're laughing at me  I can take it all from you  Again again again again again again again  Deeper and down  Down down deeper and down  Down down deeper and down  Down down deeper and down  Get down deeper and down
I have all the ways you see  To keep you guessing  Stop your messing with me  You'll be back to find your way  Again again again again again again again  Deeper and down  Down down deeper and down  Down down deeper and down  Down down deeper and down  Get down
I have found out you see  I know what you're doing  What you're doing to me  I'll keep on and say to you  Again again again again again again again  Deeper and down  Down down deeper and down  Down down deeper and down  Down down deeper and down  Get down

No comments:

Post a Comment