Q & BigQ IndeX

# History of Big numbers X

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

# Counting X

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.

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.

# Notation conventions X

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!].

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)

# Autoreduction X

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.

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.

# Basic tuples X

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 units 1 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 X

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

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.

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.

# First rows X

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(r₁,..,r_n,z1) = Q(v,...,z) [v#n]  where v = Q(r₁,..,r_n,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 vana v

Q(a1,b,1) = Q(Q(a,b,1)*a1, Q(a,b,1)*b) := (3×4!^!!!)!^... [!#2×4!^!!!]
Q(1,...,b1,r_c,..,r_n,z1) [1#k1] = Q(v,...,v*b1,v*r_c,..,v*r_n,z) [v#k1]
                        where v = Q(1,...,b1,b,r_c,..,r_n,z1) [1#k]
Q(a1,r₂,..,r_m1,z1) = Q(v*a1,v*r₂,...,v*r_m1,z) [v*r_i#m]
           where v = Q(a,r₂,..,r_m1,z1)

You can check that the above algorithms cover all their single separator expressions, which are all (in theory) reducible to natural number.

# Ackermann recursion X

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.

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…

# Operation Babelfish X

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

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.

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.

Formula Pé is the general form of Péter's algorithm. Now it's time to listen to the fish…

Translating formula Pé

?

# Precedence rules X

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

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:

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.

# Array dimensions X

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 –

?

# Binary extras X

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:

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

# Single types X

Qa – it appears that Qa's countable separators were effectively hosted in Qe(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.

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.

# Multiple types X

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

We now come to the general definition of Q with a nested list of multiple types.

# Redefinition X

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.

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.

# Copy dimensions X

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.

Define the new dimensions of bigQ in the sober style of Q.

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.

# Copy types X

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.

We've reached the next point of redefinition within the gigantic framework of BigQ. A second cycle is about to copy the first…

# Second cycle X

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!

Copy the transfer of types from the former cycle to the new row.

Greedy precedence rules won't have to be altered. Copy dimensions.

# Universal computer X

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.