Disclaimer: All of this is pure speculation, and should not be take seriously. Inspiration taken from the Wikipedia articles on the

Ackermann function and

Hyperoperations.

It's interesting to note how the common operations in mathematics are easy to define from one another, on the set of positive natural numbers. The only thing we need for addition, multiplication and exponentiation is simply a function which gives us the next member of the natural number set, e.g. the next integer. We'll call this function S(x) (S for successor).

Now, onto the definitions:

S(x) is the function which maps x, a member of a set, to the next member of that set.

We can define Add(a,b)* as S(S(S(...S(a)...), where the S function is applied b times.

Then Mul(a,b) ** is Add(a,Add(a,...Add(a,a)..) where Add is applied b times,

And Exp(a,b)*** is Mul(a,Mul(a,...Mul(a,a)..) where Mul is applied b times.

Simple as that!****

From this we can see, that if you want a machine that's able to preform addition, multiplication and exponentiation on the positive natural numbers, it is sufficient that it can apply the successor function to the members, and that it can call functions recursively.

If we'd want to define subtraction, we'd simply swap the successor function for the predecessor function P. The multiplication function would then become a multiplication of a negative and a positive number, and the exponentiation function would be an exponentiation of a negative number. If we define the (-) sign, when joined with a as this operation (the swapping of S for P), we now have negative numbers (note however that b must remain a positive natural number, but a can be any integer).

It would be interesting to see what happens if we use this definition on other sets, and might be a cause for inquiry later.

Notes:

* Usually written as a+b

** Usually written as a*b

*** Usually written as a^b (not to be confused with the natural exponent)

**** We could of course logically continue this process, and get operations where OP_n(a,b) is OP_(n-1) (a,OP_(n-1)(a,...OP_(n-1)(a,a)..) where OP_(n-1) is applied b times.

p.s. If you spot an error, point it out!