Turing-complete recursive function using only $a^b$ and $\log_b a$

Question

Edit: Below, I establish this for $\{\log x,x^y,-1\}$. It occurs to me that you can trade the requirement of including $-1$ for the ability to use a log with any base. This follows because given an integer $n>1$, you have

$$\log_n { \log_{(n^n)}{n}}=-1.$$

Since any state $s_i$ in the domain is such an integer, we can use that as our $n$, allowing us to replace any instance of $-1$ with this expression.

---

I think I've got a constructive proof that a certain class of recursive function can be Turing-complete, and I am curious whether I am retreading old ground.

Using only the operations $\ln(x)$ and $x^y$ along with the constant $-1$, you can build up an expression in terms of a state input $s_i$ (also built from those three atoms) that will compute the state $s_{i+1}$, such that repeated application of that expression will be Turing-complete. In particular, it simulates one step in a 2-tag system, where the production rules are embedded as constants within the function, and the input string is $s_0$. A non-integer value indicates a halt.

This has the implications you'd expect. For example, if you let $f(s)$ be some suitable function using only those atoms, it's undecidable in general whether $f^{n}(s)$ is integer-valued for all $n$, since it's equivalent to the halting problem. More broadly, this result shows that any finite computation can be performed using only an expression built using logs, powers, and -1.

Allowing unbounded iterative application of such expressions grants Turing completeness. There exists some $f$ which would work as a Universal Turing Machine in that sense. Actually building that function using this approach would be tedious, and the result would very likely be unusably inefficient, but it would otherwise be a straightforward extrapolation.

As a proof of concept, I tried it with the 2-tag 2-symbol system $\{0 \to 001, 1\to 0\}$, and it indeed works. 2-tag 2-symbol systems are always decidable, and the current smallest tag system proven universal is 576-tag 2-symbol, but my approach should be able to scale up arbitrarily, and it is almost certain a far smaller universal machine exists.

However, I never claimed it's pretty—even the expression for this small machine is too unwieldy to show in standard form. Here's a flat representation of it instead, where log is the natural log, pow is exponentiation, and s is the previous state:

nextState[s] := log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],log[log[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[pow[-1,pow[log[-1],-1]],-1],pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]]],log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]]],-1]],log[s]]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]],log[pow[pow[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]],log[pow[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[pow[-1,pow[log[-1],-1]],-1],pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]]],-1]],log[s]]]],log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]]],pow[pow[log[-1],log[log[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]]],pow[log[log[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]]]]]]],log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]]],pow[pow[pow[log[-1],log[log[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]]],pow[log[log[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]],-1]]]]]]]]]]]]]]],log[log[pow[pow[pow[pow[pow[pow[pow[pow[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[log[pow[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],-1]]],log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[pow[pow[-1,pow[log[-1],-1]],-1],pow[-1,s]]]]]]]]]]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[pow[pow[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]],log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[-1],-1]],s]],log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]],log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],pow[-1,s]]]]]]],pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]],log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[pow[-1,pow[log[-1],-1]],pow[log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[-1,pow[log[-1],-1]]],pow[-1,pow[log[-1],-1]]]]],-1]],log[log[pow[pow[pow[-1,pow[log[-1],-1]],pow[pow[-1,pow[log[-1],-1]],-1]],pow[pow[-1,pow[log[-1],-1]],pow[-1,s]]]]]]],pow[pow[-1,pow[log[-1],-1]],s]]]]]]]]]]]]]]]]]

...or, slightly more compactly, in a prefix-ordered shorthand, ^_- being pow, log, -1 respectively:

__^^^-^_--^^^-^_--^__^^^-^_--^-^_--^-^_--__^^^^-^_--^^-^_---^^-^_---_^^^-^_--^^^-^_---^__^^^-^_--^-^_--^-^_---_^^^-^_--^^^-^_--^___^^^-^_--^-^_--^-^_---_s^^^-^_--^__^^^-^_--^-^_--^-^_---_^^_^^^-^_--^-^_--^-^_--_^_^^^-^_--^^^-^_---^__^^^-^_--^-^_--^-^_---^^^-^_--^___^^^-^_--^-^_--^-^_---_s_^^^-^_--^-^__^^^-^_--^-^_--^-^_---^^_-__^^^^^-^_--^-^_--^-^_--^-^_--^-^_--^__^^^^^-^_--^-^_--^-^_--^-^_--^-^_---_^^^-^_--^-^__^^^-^_--^-^_--^-^_---^^^_-__^^^^^-^_--^-^_--^-^_--^-^_--^-^_--^__^^^^^-^_--^-^_--^-^_--^-^_--^-^_----__^^^^^^^^^^^^^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^-^_--^_^^^^^^-^_--^^-^_---^^-^_---^^-^_---^^-^_---^^-^_---__^^^-^_--^-^_--^^^-

...or, slightly more coherently, as a tree:

---

The state string is represented as $1b_nb_{n-1}\dots b_1b_0$, that is, with a leading $1$ and with the least significant bit being the front of the string. E.g., $s=110100_2=52$ corresponds to a string of $00101$ as they are more usually represented.

My question is whether or not this is a known result, or if anyone knows of research along similar lines. I'll also accept an answer pointing out a flaw in my approach. The closest related thing I could find was Richardson's Theorem, but that seems to require the sine function.

I am also curious whether or not it would be fair to say this operates on the reals; there are intermediate complex values, but the input and output of the entire expression is always an integer, at least within its domain.

---

You can try it yourself, sort of, with Wolfram Alpha. It was tough getting it to fit in the character limit, but I assure you this is the same as the expression given above, simplified some and optimized for space:

s=52,c=-1,a=E^Ln[E^E^(c^s-1)]^(1/2),b=Ln[E^E^(1+s^Ln@2^c)],Ln@Ln[(E^(E^2^(Ln@Ln[b^((-Ln@b^(I2π))^(I/π))^(1/2)]-5/2))^Ln@Ln[E^(E^11*Ln[E^E^(1-c^s)]^-5)])^Ln[((E^E^s)^Ln[a^E^I^Ln@Ln[a^E^s]])^E^c]^(1/4)]

The $s$ parameter at the beginning is its current state. For tag machines, this means you also use that to give it initial input; the bitstring which $s$ encodes is roughly analogous to a Turing machine's current tape, state, and head position.

For example, for $s=52=110100_2$, we remove the leading $1$ and reverse the remaining $10100$ to map to an initial string of $00101$. Since the first bit is $0$, our rules table $\{0 \to 001, 1\to 0\}$ says to append $001$, yielding $00101\mathbf{001}$. After appending the appropriate string, the first two bits are always deleted, leaving $101001$ in this case.

We do the inverse transformation to convert back to our state form, meaning reverse it and prepend a $1$, giving $1100101_2=101=s'$. This means that if all is working as advertised, we should expect the function to spit out $101$ (in base-10).

Note that using Alpha, you may have to click 'Approximate form' and 'More digits' to see the "real" part. In Mathematica using exact values, any input value with $s \geq 4 : s\in\mathbb N$ gives an integer answer, at least within the limits of my testing.

$0 < s < 4$ corresponds to $<2$ symbols remaining in the string. This is the halting condition, and ideally should not return a valid state, although I've tested that part less since it's not technically in the domain. Any $s$ other than a positive integer is definitely outside of the domain, thus return value is undefined.

---

Derivation

Begin by representing a tag system with two symbols and deletion letter $v$ as

$$ x_{i+1} := \left\lfloor\frac{x_i}{2^v}\right\rfloor +(2^{\left\lfloor\log_2{x_i}\right\rfloor-v})\left[ (x_i \bmod 2)(\beta -\alpha) +\alpha-1\right], $$

where $x_i$ is the current state, and $\alpha$ and $\beta$ are the two production rules. All of these are given as integers in the form described earlier. For example, Post's still-unresolved tag system $\{0\to 00,1\to 1101\}$ can be described by plugging in $v=3, \alpha=100_2=4, \beta=11011_2=26.$

Broken down, these are the components:

• $\left\lfloor\frac{x_i}{2^v}\right\rfloor$ is effectively a right-shift by $v$, truncating the least significant $v$ bits off the right side of the string.
• $2^{\left\lfloor\log_2{x_i}\right\rfloor-v}$ provides the index of the most significant bit, yielding the factor we'll need to multiply by to prepend bits to the left side of the string.
• $\left[ (x_i \bmod 2)(\beta-\alpha)+\alpha-1\right]$ provides a parity conditional. If the LSB is $0$, we get $\alpha-1$; if it's $1$, we get $\beta-1$. The $-1$ clears the extra $1$ bit from $x_i$, which we use as an end-of-string marker so we don't discard trailing zeroes.
• $\alpha$ and $\beta$ are integers corresponding to the binary productions for $0$ and $1$. They are encoded such that if $w_0 \rightarrow b_0 b_1 \ldots b_i$, we have $\alpha = 1b_i b_{i-1} \ldots b_0$.

From that equation, it's a matter of abusing a few equalities. First, $n \bmod 2 = \frac{1-(-1)^n}{2}$, using mod as an operation, and assuming $n\in\mathbb Z$. You can extend the same principle to convert $\bmod 2^k$ for any $k$, although it gets uglier, e.g.:

$$n \bmod 4 = \frac{1-(-1)^n}{2}+1-(-1)^{\frac{n-\frac{1-(-1)^n}{2}}{2}}.$$

Second, that floors and mods are interchangeable with

$$a-b\left\lfloor\frac{a}{b}\right\rfloor=a\bmod b.$$

More problematic is the $\left\lfloor\log_2{x_i}\right\rfloor$ term. For this, as inspired by a related answer, I took advantage of the cyclic nature of $e^{2n\pi i}$ with

$$\left\lfloor\log{n}\right\rfloor=\log{(n)}- \frac{\log{\left(e^{\left(2\pi i (\log{(n)} -\frac{1}{2})\right)}\right)}}{2 \pi i} - \frac{1}{2},$$

which seems to work for all integers $n>1 : n\in\mathbb N$. I believe this works fine so long as $\log{n}$ is a positive non-integer real, which it always will be for our purposes, and is also why you need the $(-1)^n$ trick above.

Finally, you can put it all together by leveraging the fact that exponentiation subsumes the lower operations, as in

$$\large \log \log \left[\left(e^{\left(e^a\right)^{b}}\right)^{e^c}\right]=ab+c.$$

Helpful are the identities

• $i\pi=\log (-1)$
• $e=(-1)^{\log{(-1)}^{(-1)}}$

from which you can build up everything else you need.