Q & BigQ IndeX
Quintessential construction methods for Big numbers.
1st written in the Book of
Francesca, Gerardus, Asankyeya, Webmuis.
Midwoud, North-Holland, May 2009.
Tell the story
On the Origin of Numbers
by relating 0
and 1
to the chicken and the egg.
What came or comes first?
Then follow up on:
Archimedes' sand-reckoner...
the sands of the Ganges in the Diamond Sutra, etc...
Units one
After the recognition that something has order,
counting starts by representing a first case with the unit one 1
All numbers are composed of number units,
except zero 0
, which is essentially the number with no units
0 =
Every natural number
can be represented as a series of units 1..
(counting up to some total).
Ordering functions
Bigger natural numbers can be composed by arithmetical
operations on units
(multiplication, the factorial, powers, etc.)
and consequently by operator functions counting over basic operators.
This outlines how to “jump out of the box and into the ocean” –
the way we discover new construction methods for Big numbers.
As higher order functions count lower order functions, their function order
becomes countable by the first (extra) parameter of a super order function.
More extra parameters follow…
At last, when the super order is exhausted, it comes into perspective as the first case
of a higher order function positioned right above the initial value (or lowest order function).
Etcetera…
Inverse operations
By introducing the inverse unit - = -1
to our usual operations, we create new sets of countable numbers.
The mathematician who can make calculations on the last two in the list below
has ‘Napier's bones’.
-
0.
the negative numbers, by inverse addition or by multiplying the inverse unit -
1.
the rational numbers or fractions, by inverse multiplication or a negative power -
2.
the algebraic (complex:) numbers, by a rational power (:of a negative number) -
3.
logarithmic numbers, which are inverse powers -
c.
super-inverse numbers – super-roots, super-complex numbers and super-logarithms -
d.
continuous algorithmic numbers, where the number of operators is rational, etc.
Even though a real world calculation might well require an infinite series, these inverse numbers can be represented by countable units only, and in this (notational) sense they are all countable numbers.
Number and character variables
A number variable is a placeholder for a number.
Number variables are written in lower case a,b,c,..
In this article all variables stand in for natural numbers, 0
inclusive.
A wild card is a placeholder for any sequence of characters allowed on that position in the expression.
Wild cards are written in upper case A,B,C,..
Bear in mind that a wild card can often also stand in for an empty string.
A wild card R = r1,..,rk
designates (part of) a row
and therefore may contain only single separator characters of a type expected from the context in which the expression was made.
Other wild cards such as X
may contain any number of subsequent separators,
albeit of an expected type.
If a wild card X
should end with a natural number variable, write X1
Repetition of characters
Define a meta-notation for repetition [an important tool in this article!].
Write a repeated sequence as ABC...D [B#n]
where A
,C
and D
are optional and
B
is not in C
(B
must be the first B
left of the ellipsis).
The meta-operator #
for repetition in [B#n]
indicates a substitution in place of BC...
with a row of n
times the characters B
,
and characters C
inserted in between
(before every next B
).
Three examples of evaluations applying meta-repetition:
111**111 = 111*111*111 = 9×3 = 3... [3#9] = 27
111***111 = 111**111**111 = 3^27 = 3*... [3#27] = 7625597484987
Qo(111,,1) = Qo(111,...) [111#111] = Qo(111,111,111)
~ 4^^24
Other meta-information about expressions, such as the range of a variable, also belongs
in square brackets.
Substitution :
for example of the units 1
by v
in all parameters R
is written:
Q(R,z) [1:v in R]
Operators and separators
Stars *... [*#c c>1] = ^...[^#c c>0]
are countable operators (see Qa).
Commas ,... [,#n n>0]
are separators in the parameter array of operator functions.
Semi-colon ;... [;#n n>0]
superators
help count separators in an extradimensional function.
Various precedence rules apply to the operators and separators of functions Q.
‘Old style’ expressions in brown font
are
always evaluated by school precedence rules
– evaluating higher operators first.
In ascending order the signs for ‘old’ operators are +,×,^,^^,^^^..
This article presupposes some experience with countable operations.
Here's the general operator formula for super-exponentiation.
Let c=1
to get the power a^(b+1)
a*...b1 [*#c1] =
a*...(a*...b) [*#c *#c1] =
a*...... [*#c a#b1]
Addition
Represent natural numbers n
naturally
as a series of
units one
1... [1#n]
Add two numbers directly by adjoining their representation in units.
For example, if a=1
and b=1111
, then
ab = 1 1111 = 11111 = a+b = 5
Add a negative to a positive number to subtract ones,
for example 2-1 = 11- = 1
Because addition in its primitive form is inert (except when school precedence applies),
the plus sign +
is essentially
a repetition operator *..
of 0
length.
Capacity
The choice to “count fingers”
as the final representation of truly Big numbers is not so bad.
For practical purposes its capacity is comparable to decimal numbers,
even when exponential notation n.mE+p
hands some help.
A series of n
ones can be noted down in
log(n)
digits, concisely so it seems, but already when
n = 10^^10
no radix notation (plus exponent) offers a significant practical advantage:
log(10^^10) = log(10^(10^^(10-1))) = 10^^(10-1)
=> 10^^9 decimals, or 10^^8 in the exponent
Of course the resolution of “finger counting” numbers
is the same as that of any radix system – all natural numbers are covered.
Note that two natural numbers can represent a fraction n/m
or a decimal point n.m
Reducing Q
To evaluate an expression of an operator function completely, it must be reduced to the smallest possible number of operations on units. In this article all expressions Q will be (theoretically) reducible to a natural number.
Creating operator functions for Big numbers is more of an art than a science.
At level Q0
all functions Q
are characterized by the following automatic reduction rules.
-
Q(a) = a
so Q() = 0 -
Q(X,0) = Q(X,) = Q(X)
or Q(X,1) = Q(X) if specified otherwise
Zeros
Of the five vowels of Q that are to be presented below,
only Qa drops its final parameter when tuples reach
Qa(X,1)
format.
This requires us to specify the reduction of all Qa(X,0)
to make the number 0
work.
Note that a new ordering of zeros may be opportune:
0*... [0#m] > 0*... [0#n n>m]
The function family Q shuns the unit 0
from its definitions.
It is assumed that an expression with parameter value 0
can be reduced by inverse construction –
backward recursion from an initial value 1
–
as in Qa(a,0)
below.
Level Q1
operator functions
calculate Q(a,b)
for tuples (two operands).
Give 5 different definitions that introduce a secondary parameter in Q.
Qa
– start off naturally with multiplication of two (apparently commutative) operands-
Q(a,1) = Q(a) = a*1 = a
Q(a,11) = Q(a) [1:11] = Q(a Q(a,1)) = a*11 = aa = 2×a
Q(a,b1) = Q(a) [1:b1] = Q(a Q(a,b)) = a*b1 = a... [a#b1] = (b+1)×a
Q(a,0) = 0 because Q(a,1) = Q(a Q(a,0)) = a Q(a,0) = a Qe
– enable Q to host addition, simply by dropping the first and single separator-
Q(a,1) = Q(a1) = a1 = a+1
Q(a,b1) = Q(Q(a,1),b) = Q(a1...) [1#b1] = ab1 = a+b1 Qi
– initiate an iteration of doubles-
Q(a,1) = Q(a) [1:11] = Q(aa) = aa
Q(a,11) = Q(Q(a,1),1) = aaaa
Q(a,b1) = Q(Q(a,b),b) = a*(11**11**b) Qo
– originate an orgy of squares-
Q(a,1) = Q(a) [1:a] = Q(a...) [a#a] = a×a
Q(a,11) = Q(Q(a,1),1) = a^4
Q(a,b1) = Q(Q(a,b),b) = a^2^2^b Qu
– instead of substituting parameters, maximize Q by substituting the units1
that hide inside-
Q(a1,1) = Q(a1) [1:Q(a,1)] =
Q(Q(a,1)*a1) = (a+1)!
init: Q(1,b1) = Q(v,b) where v = Q(b1,b)
step: Q(a1,b1) = Q(a1,b) [1:v' in a1]
= Q(v'*a1, b) where v' = Q(a,b1)
You may wonder, why these five? Aren't there any alternative functions that create big numbers?
There are many, especially hybrid algorithms,
but in this article we like to compare those Q,
which are built up naturally (but rigorously) by pursuing a particular algorithm of choice,
in the hope this will illuminate the way…
For record breakers – the super-factorial operator function Qu
helps you reach number oblivion now!!!
Pi, i and e
Pi pops up in the analysis of circles and spheres –
geometrical figures with a fixed distance from a fixed point.
The number pi Π = 3.14..
is proven to be
non-algebraic (transcendental)
and possibly Π
is not a logarithm of an algebraic number either.
But many infinite series converge to Π
beautifully
(see: J. Arndt & C. Haenel "Pi-unleashed" 2001, ch.16),
and there's Euler's famous pi theorem (1743).
where i is the complex root i = -1^(1/2)
and e is the base number of natural logarithms
e = 2.718.. = lim (1+1/n)^n as n→∞
Real independence
Because the transcendence of the constants Π
and e
is so connected, the question arises if one of them
could operate as a transcendental or real unit –
in the sense that a single infinite series (such as e
)
put in an algebraic and/or logarithmic context
covers a class of transcendental reals (enumerable by e
).
An example to the contrary should express Π
as
the super-root or super-logarithm of some countable function
in the hierarchy of exponential operators ^..
But how do you prove that a real number is
independent of all
inversive
super-exponentials Qe(a,b,c)
?
Are there uncountably many independent real units,
as Cantor's conception of the continuum suggests?
Can you give a description of a number that's certainly an independent real constant?
Gamma hybrid
At least Π
is a hybrid
of the two countable algorithms
Qe & Qu.
When Qu's first parameter is a natural number we have a factorial, but
Euler's Gamma function makes the Qu algorithm continuous.
In tandem with the
inverse unit
and exponentiation, Euler's Gamma function
Γ(a+1) = a!
yields a discrete formula for pi.
with Γ(a) = (a-1)! = Qu(a-,1) = Qu(Qe(Qu(a--,1),a-,1))
and -½ = Qe(--,-,11)
so Γ(½) = Qu(Qe(--,-,11), 1)
= Qe(Π, Qe(11,-,11), 11) = Π^½
Now if you could
translate
the Qu part of the last formula into some finite Qe format,
you'd get the strange result that pi and e
are countable members of the super-exponential order.
LEMMA QQ?? However, Qu cannot be translated to a primitive recursive function like Qe, because it's a higher order function (from b=1
[the factorial is higher order QQ??] as we shall prove below),
and (according to Ackermann) these live on different planets.
At level Q2
the existing tuples are blended with the next parameters on the first row.
Present 5 models for Q and 2 hybrids,
illustrate them by evaluating Q(3,2,1)
Qa
– place brackets to sort a right associative row of multiplications-
Q(a,b,c) = Q(a,Q(b,c)) = a*(b*c) := 3*(2*1) = 6
Q(a,..,y,z) = Q(a,..,Q(y,z)) = a*..*(y*z) Qe
– define super-exponentiation in 3 parameters, then generalize over operator subscripts [link QQ??]-
Q(a,1,c1) = Q(a,1,c) [c>0] = Q(a,1,1) = a
Q(a,b1,c1) = Q(a,Q(a,b,c1),c) = a*...... [*#c a#b1] := 3*2 = 6 -
Q(a,b,1,1) = Q(a,b,b)
Q(a,b1,c1,1) = Q(a,Q(a,b,c1,1),c,1)
Q(a,b,1,d1) = Q(a,b,b,d)
Q(a,b1,c1,d) = Q(a,Q(a,b,c1,d),c,d) -
Q(a,1,..,n1,R) = Q(a,1,..,n,R) = Q(a,1,1) = a
Q(a,b,1,...,n1,R) [1#k] = Q(a,b,...,n,R) [b#k1]
so Q(a,b,1,...) [1#k k>1] = Q(a,b,...) [b#k] else if [k=1] do
Q(a,b1,c1,..,z) = Q(a,Q(a,b,c1,..,z),c,..,z) QeC
– represent John Conway's chained arrow function in Q-notation (a Qe2 hybrid)-
C(a,b,c) = Qe(a,b,c1) := 3^2 = 9
C(a,1,..,z) = a
C(a,..,y,1) = C(a,..,y)
C(a,..,x,1,z) = C(a,..,x)
C(a,..,y1,z1) = C(a,..,C(a,..,y,z1),z) Qi
– increase iteration speed on the double-
Q(a,b,c1) = Q(a,Q(a,b,c),c) := 3*2^281474976710656
Q(a,..,y,z1) = Q(a,..,Q(a,..,y,z),z) Qo
– overload all open (non-final) parameters from square one-
Q(a,b,c1) = Q(v,v,c) where v = Q(a,b,c)
:= 43046721^2^2^43046721
Q(r1,..,rn,z1) = Q(v,...,z) [v#n] where v = Q(r1,..,rn,z) QoC
– or carry on squaring in maximal Conway style (Qo1+QeC hybrid)-
C(a,b) = Qo(a,b)
C(1,..,z) = 1
C(a,..,1,z) = C(a,..,C(a,..,z)) [a>1]
C(a1,..,y,z1) = C(a1,..,C(a,..,y,z1),z) [a>0 y>1] := 3^65536 Qu
– generalize the super-factorial function by overloading with maximal vanav
-
Q(a1,b,1) = Q(Q(a,b,1)*a1, Q(a,b,1)*b)
:= (3×4!!!!)!...
[!#2×4!!!!]
Q(1,...,b1,rc,..,rn,z1) [1#k1] = Q(v,...,v*b1,v*rc,..,v*rn,z) [v#k1]
where v = Q(1,...,b1,b,rc,..,rn,z1) [1#k]
Q(a1,r2,..,rm1,z1) = Q(v*a1,v*r2,...,v*rm1,z) [v*ri#m]
where v = Q(a,r2,..,rm1,z1)
You can check that the above algorithms cover all their single separator expressions, which are all (in theory) reducible to natural number.
Definition
Define primitive recursion
[S. Kleene "Introduction to Meta-mathematics" 1952, p.220]
recursively as an iteration over primitive recursive functions,
where the initial case or cases involve a total reduction operation.
An example of such an initial case is Qe(a,1,1) = a
Ackermann functions are recursive functions,
such as Ac(a) = Qe(a,a,1,1)
,
which cannot be expressed by iterating over primitive recursive functions
of type Qe(a,b,c)
alone,
but must increase the number c
of primitive iterations directly.
Function history
In David Hilbert's 1925 article "On the infinite"
[J. Heijenoort "From Frege to Gödel" 1967, p. 388]
we meet the super-exponential again,
with c
as a counter of primitive recursive function levels,
starting with addition on level 1
.
John Conway uses the same third parameter c++
to shoot away his
chained arrow
function
[J. Conway & R. Guy "The Book of Numbers" 1996, p.61],
which we've rephrased as QeC.
In Wilhelm Ackermann's 1928 article "On Hilbert's construction of the real numbers"
[read Heijenoort's introduction, ibid., p.493]
he firmly establishes that
primitive recursive
functions and higher level recursions live in separate boxes.
(Hence the need for a separator!)
The formula he erects his proof on is identical to our Qe(a,b,c)
for natural numbers c
, with addition at c=0
.
The archetypical Ackermann function can be expressed in Qe as:
Ac(a) = Qe(a,a,a) = Qe(a,a,1,1) = Qe(a,,111)
This is the “recursion on one variable” that Ackermann worked out so painstakingly, to prove Hilbert's conjecture that higher level functions exist, independent of the primitive recursive function level.
Classification
The different Hilbert levels of recursion are defined
by (primitive) recursive substitution in a single variable parameter,
and only in this sense are they independent.
Ackermann's functions substitute higher parameters by lower,
which means he needs to count down an even higher parameter, in order not to run out of control.
So we define Ackermann levels of recursion in Qe
to require the introduction of an extra parameter.
Then parameter arrays of different length are independent, in the sense that
Ackermann substitution alone cannot increase row length.
This is trivial, as the final countdown z
safeguards the principle of reducibility.
Independent Hilbert levels are created by recursive substitution of
super-exponents in a function
Qe of 4 params.
Because Qe(a,b,1, d1) = Qe(a,b,b, d)
recurses an extra-exponential number of times
from 1
to 2
parameters,
there are zillions of Hilbert levels in an Ackermann level.
Inspired by the articles of Hilbert and Ackermann, Rózsa Péter continued work on classification schemes for recursive functions. Of her hand is a simple algorithm that can be used to build an Ackermann function on 2 parameters instead of 3 (it's sometimes presented as ‘the’ Ackermann recursion, but that's not historical).
In the next chapter we'll generalize Péter's formula
and express it in Qe.
It feels like Rózsa Péter may have derived this herself,
but I don't know her book…
“Inside the Holy Grail swims a Babelfish called Kun that translates every recursive function into another.”
The following theorem should serve as an example of a successful function translation,
crossing the borders of
primitive recursion, but staying firmly within the first
Hilbert level.
The ideal is to be able to classify all recursive functions by their corresponding parameters in the standard recursive function Qe.
One has to start somewhere…
THEOREM: Péter's formula is super-exponential
Follows Rózsa Péter's algorithm, with parameters mirrored.
Parameters to the right create bigger numbers, is our motto.
P(0,b1) = P(1,b)
P(a1,b1) = P(P(a,b1),b)
Extra parameter n
Péter's algorithm applies the same recursive substitution as the basic tuple of Qu
did with the
step vana
v' = Qu(a,b1)
.
But in Qu the parameter units 1
are substituted
(or the substituted parameter is multiplied),
and Péter substitutes the first parameter in one go.
Therefore Péter must at least add 1
to the single variable a
in P(a,0)
– while dropping the rest –
else if she'd add 0
every reduction would result
in the number m=1
(except for a=0 & b=0
).
Our operator functions Q
apply no operation to single variables at level
Q0
. A matter of style.
Now generalize Péter's formula so that
any value n
can be added in its initial recursion.
With this the function Pe becomes a member
of the operator function family Q.
Pe(n, 1,b1) = Pe(n, Pe(n, 0,b1),b) = Pe(n, Pe(n, 1,b),b)
Pe(n, a1,b1) = Pe(n, Pe(n, a,b1),b)
Intro parameter m
Péter's algorithm substitutes in the initial case
P(1,b1)
the value v = P(1,b)
, which is
wholy different from Qu where the
init vana
v = Qu(b1,b)
in Qu
is a variable tuple.
A more modest variation on the substituent in the initial case would be
v = P(m,b)
and the introduction
of a parameter m
,
which could either be independent or dependent on the parameter n
.
Because m
influences most end results less than n
we put it left in Pé's parameter list.
Pé(m,n, 1,b1) = Pé(m,n, Pé(m,n, m,b),b)
Pé(m,n, a1,b1) = Pé(m,n, Pé(m,n, a,b1),b)
Formula Pé is the general form of Péter's algorithm. Now it's time to listen to the fish…
Translating formula Pé
?
Next level in the algorithms for Q – separators become countable, so their rules of precedence must be fixed.
Right associativity
Reduce expressions of Q by associating all parameters and other signs from right to left.
R-evaluate expressions from right to left:
3**3**3 = 3**(3**3) = 3^27 = 7625597484987
L-evaluation mostly yields smaller numbers:
3**3**3 = (3**3)**3 = 27^3 = 3^9 = 19683
We saw this before, when Qa
was right-associatively reduced to tuples Q(y,z)
which caused
its first row to drop a parameter in every reduction step.
The other vowels of Q weren't so wasteful –
their first dimension couldn't be subdivided before recursion –
but that may change with separators of various lengths, which are better attacked by
a common rule of precedence
Let multiple separators create a multidimensional parameter array. Most algorithms for Q would cover all parameters in a dimension with equal separators at once, in a reduction step.
Greedy precedence bad formula!
Define three rules of precedence, tailor made for reducing expressions to tuples.
For fast scanning there's lazy precedence where the operands are simply the numbers on either side of the rightmost operator. Lazy precedence respects subdivision by brackets (as do all forms of precedence).
L(X,a,..b) = L(X,L(a,..b))
with LP 11**11*11**11 = 2^(2*(2^2)) = 2^8 = 256
Let greedy precedence be the principle of reduction
that evaluates lower operators first.
Then the operand left of operator
*...[*#m]
runs left till the sign says
*...[*#k k≥m]
or until it breaks.
In arrays the parameters bordering equal separators are often not reduced in tuples, hence the formula:
G(X,...a,...b) [,#k ,#m k>m] =
G(X,...G(a,...b)) [,#k ,#m]
G(a,...b,...Z) [,#m ,#n m<n] =
G(G(a,...b),...Z) [,#m ,#n]
G(X,...Y,...Z) [,#k ,#n] = G(X,...G(Y),...Z) [,#k ,#n]
where
Y := ti,...... [,#m ti#j j>1 k>m m<n]
so part Y owns equal ,...
with GP 11**11*11**11 = 2^((2*2)^2)) = 2^16 = 65536
The inverse rule is School precedence
which (unless bracketed) evaluates lower operations later.
So the number left of an operator
*...[*#m]
runs on until it meets the signs
*...[*#k k≤m]
or until it reaches brackets at/or the start of the expression.
with SP 11**11*11**11 = (2^2)*(2^2) = 4*4 = 16
Contrary to common usage self-repetitive operations *...[*#c]
should be greedy. Why?
Four reasons:
– Considering adding ones is automatically greedy,
it allows for addition as a zeroth operation where [*#0]
– Greedy separators keep the dimensions in an array automatically separate.
– Greedy precedence results in bigger numbers than school precedence does
(less resolution alas – but with real numbers around resolution is infinite).
– Powers can be evaluated with no extra brackets, as in:
3**3**3 = 3**3*3*3 = 3**3*3 3 3
The above formula for greedy precedence in parameter arrays is a bit difficult,
because it has to accomodate arrays with mixed dimensions,
where parameters bordering equal separators are not resolved from right to left,
but saved up to be evaluated as a series by the appropriate algorithm.
The forms of precedence below open a broader perspective on parameter arrays.
Alternative precedence
Try to discover other rules of precedence, to handle large multidimensional arrays and exploit their properties.
For instance, we can define a Reluctant operator that has a tendency to shy away from its characteristic operation and postpone this until certain conditions are met.
At construction level Q3
secondary rows begin to expand Q's parameters into the dimensional realm.
Seen from the perspective of the highest row all earlier parameters
do not necessarily have an individual role to play.
Illustrate this with an example from mathematical history.
When Wilhelm Ackermann in 1928 published his higher order functions,
the dimensional perspective on arrays wasn't yet applied on function parameters.
Though construction methods with countable separators didn't exist, still
the so called Ackermann function
ψ(a) = φ(a,a,a)
can be situated on Qe's second row now.
Qe(a,,b) = Qe(a,...) [a#b b=3]
Note that the value of parameter a
in this initial reduction step
(which drops a row and a dimension) does not matter.
But if it did, the number a
could be applied to create a faster algorithm.
See the examples below.
Square arrays soon turn cubic, but by then a general multidimensional definition can clearly be stated.
Qa
– depend on greedy precedence to subdivide more complex expressions Qa with brackets-
Q(a,,1) = Q(a) = a
Q(a,,b1) = Q(a,Q(a,,b)) = Q(a,...) [a#b1] = a*... [a#b1]
Q(a,...1) [,#c] = a
Q(a,...b1) [,#c1] = Q(a,......) [,#c a#b1] = a^...b1 [^#c] Qe
–-
Q(a,,1) = Q(a) = a
Q(a,b,,1) = Q(a,...) [a#b]
Q(a,b1,c1,,1) = Q(a,Q(a,b,c1,,1),c,,1) = Qi
–- ?
Qo
– use the same principles as apply to the basic tuple-
Q(a,,1) = Q(a,...) [a#a]
Q(a,,b1) = Q(Q(a,,b),,b)
Q(a,...1) [,#c1] = Q(a,......) [,#c a#a]
Q(a,...b1) [,#c] = Q(Q(a,...b),...b) [,#c ,#c] Qu
–- ?
Q(r1,..,rm,rn) = Q(r1,..,Q(rm,rn))
To make Q at this stage work like a binary expression for big numbers,
expand the number of dimensions of Q's parameter array directly
by prefixing extra superator commas at the left end.
Gently formulate the necessary superator evaluation rules.
For example:
Q(,...a) [,#p1 p>0] = Q(,...Q(,...a)) [,#p ,#p]
Or choose a flamboyant final formula that takes binary Q-construction to extremes.
Prefixed superator commas are considered higher than ordinary separator commas, which means (according to the dogma of greedy precedence) that the right parameter array must be reduced to a natural number first, before the superators can be counted off for evaluation.
The trick to extract a binary big number from within Q()
is to take its parametric expression, replace every ,
by 0
and put that binary sequence in reverse order (though arguably
the old radix order of digits should be reversed, because larger powers are typically calculated
by repeated multiplication of a base and we like to write from left to right).
Qa
– it appears that Qa's countable separators were effectively hosted inQe(a,b,c)
By extending Q with separator types we enter a new chapter in the creation of big numbers. The prefixed superators described above are superseded by this extension, which is achieved by introducing a third character.
Write a typed separator as a comma character ,
followed by a type counter,
which is (in single form) a natural number immediately terminated by a semicolon ;
to define and close the counter.
The type counter part will be subscripted in red for visual clarity.
Define the evaluation rules for single separator type counters within expressions of Q.
Q(X,0;Y) = Q(X,;Y) = Q(X,Y)
Q(a,1;1) =
Q(a,......) [,#a a#a] = Q(,a)
Q(a,1;b1) =
Q(Q(a,1;b),1;b) =
Q(,...a) [,#b1]
Q(a,1;...1) [,1;#c1] =
Q(a,1;......) [,1;#c a#a]
Q(a,1;...b1) [,1;#c] =
Q(Q(a,1;...b),1;...b)
[,1;#c ,1;#c]
Q(a,d1;1) =
Q(a,d;......) [,d;#a a#a]
Q(a,d;b1) =
Q(Q(a,d;b),d;b)
Q(a,d;...1) [,d;#c1] =
Q(a,d;......) [,d;#c a#a]
Q(a,d;...b1) [,d;#c] =
Q(Q(a,d;...b),d;...b)
[,d;#c ,d;#c]
Let it be said that greedy precedence applies in more complex expressions of Q
at every stage, here too… Moving from right to left,
lower type d
separators are evaluated before higher type,
and when adjacent types are equal, the evaluation of the smaller number c
of separators takes precedence above the larger number.
Create multiple separator types by alternating semicolons ;
with number variables.
Thus a new row of separator counter parameters is formed,
which perform operations specific for Q,
both on operand pair a
and b
and occassionally also on the separator number and type.
Every next separator type number relates to earlier types,
as type counter d
relates
to what we know as the number of separators c
(but what is essentially the primary separator counter).
Q(a,1;e1;1) = Q(a,a;e;......) [,a;e;#a a#a]
Q(a,d1;e;1) = Q(a,d;e;......) [,d;e;#a a#a]
Q(a,d;e;...1) [,d;e;#c1] = Q(a,d;e;......) [,d;e;#c a#a]
Q(a,d;e;...b1) [,d;e;#c] = Q(Q(a,d;e;...b),d;e;...b) [,d;e;#c ,d;e;#c]
We now come to the general definition of Q with a nested list of multiple types.
Q(a,1;...;1) [1#m1] = Q(a,a;...;......) [a#m ,a;...;#a a#a]
Q(a,1;...;n1;R;1) [1#m] = Q(a,a;...;n;R;......) [a#m ,a;...;n;R;#a a#a]
Q(a,R;...1) [,R;#c1] = Q(a,R;......) [,R;#c a#a]
Q(a,R;...b1) [,R;#c] = Q(Q(a,R;...b),R;...b) [,R;#c ,R;#c]
Along the lines of the previous chapters we could continue with multidimensional types
a,d;...p;b [;#q]
Instead its time to ‘jump from the box’ and merge the two current separator characters into one.
The new operator function is nicknamed bigQ,
and officially declared as Q1()
Consider Q to be the zeroth cycle of BigQ,
then bigQ will be the first (next) cycle of its kind.
Define the first row of bigQ,
with all separators written as semicolons ;
and a parameter array without Q1()
method declaration.
X;0 = X; = X
a;0;R = a
What is kept alive of the diversity of numbers and separators that was possible
in the previous function Q()
are the first two parameters a
and b
and the row of type counters for separators,
starting with ‘array dimension’ counter c
.
The new definition of bigQ captures the quintessence of Q.
a;1;1 = Q(a,1) = a... [a#a]
a;1;c1 = Q(a,...1) [,#c1] = Q(a,......) [,#c a#a] =
a;(...a...);c [a;(#a-#);c] =
a;1;1;1;... [1#k1] = a;... [a#k111]
a;1;1;...;n1;R [1#k1] = a;...;n;R [a#k11]
a;b1;1R = (a;b;1R);b;1R
Though the newly defined parameter rows cannot be subdivided by bracketing anymore, greedy precedence still helps to negotiate brackets between different dimensions, and between second dimensions and higher.
X1;...y;...z [;#m ;#n m<n] = (X1;...y);...z [;#m ;#n]
Define the new dimensions of bigQ in the sober style of Q.
a;;b1 = (a;;b);;b
a;...1 [;#c1] = a;...... [;#c a#a]
a;...b1 [;#c] = (a;...b);...b [;#c ;#c]
Another binary expression for big numbers knocks at the BigQ door… This time we won't be tempted to open it, like we did before with Binary extras. Prefixed superators are easily overtaken by single types; so separator types are the way to go.
Within subscripts for separators ;R,..
single commas ,
are nested as separators for type counter parameters.
The general definition of bigQ with multiple types
is again copied from Q.
a;1,...,1 [1#m1] = a;a,...,...... [a#m ;a,...,#a a#a]
a;1,...,n1,R,1 [1#m] = a;a,...,n,R,...... [a#m ;a,...,n,R,#a a#a]
a;R,...1 [;R,#c1] = a;R,...... [;R,#c a#a]
a;R,...b1 [;R,#c] = (a;R,...b);R,...b [;R,#c ;R,#c]
We've reached the next point of redefinition within the gigantic framework of BigQ. A second cycle is about to copy the first…
Single and multiple separator types are an excellent means
to explain the transition from one cycle to the next,
but ideally types (with their conspicuous ‘third character’)
should not be part of any ‘binary’ cycle at all.
If every cycle definition is self-contained – as happened to the first bigQ –
types can remain virtual
and covered in the definition of the first row of the next cycle.
This should mean the formula
Qn1(a;b;c;R) =
Qn(a;R,...b)
[;R,#c]
is always superfluous.
However, the second cycle needs a fresh initialization.
Reference is made to the first bigQ cycle as Q1()
??? but make sure the cycle definition is self-contained!
a;b = ab
a;b;1 = Q1(a;b) = ab
a;1;c1 = Q1(a;...1) [;#c1] = Q1(a;......) [;#c a#a] =
Copy the transfer of types from the former cycle to the new row.
a;1;1;1;... [1#k1] = a;... [a#k111]
a;1;...;n1;R [1#m] = a;...;n;R [a#m1]
Greedy precedence rules won't have to be altered. Copy dimensions.
a;...b1 [;#c] = (a;...b);...b [;#c ;#c]
Ever since Wolfram wrote his book on finite automatons (?), people wonder if somewhere far below the world of atoms and quarks the mathematical substrate might be discrete. The universe in which we live could have been built as a random quantum computer – or at least it can function as such – for some mathematical God far out in the guya (universe environment).
Suppose the internal bit is equal to the Planck impulse-momentum
I = 10^-33.178744048564 kg*m2*s-1
and all universal computer bits U
are evaluated
every Planck moment T = 10^-43.2683 s
.
Then the energy inside the universe is
constant at E = U/T = 10^71.1835 kg*m2*s-2
.
More details about such a Universal Computer can be found in our Physics Parlour.