Calculating the nth super-root when n is greater than 2? Tetration (literally "4th operator iteration") is iterated exponentiation, much like how exponents are iterated multiplying. For example, $2$^^$3$ is the same as $2^{2^2}$, which is $2^4$ or 16. This applies to any two  positive real numbers, and possibly even all real numbers.
There are two inverses of tetration, iterated logarithms "super-logarithms" or "tetralogarithms" and iterated roots "super-roots". For instance, the value of  $\sqrt{256}_s$ is $4$ because $4$^^$2 = 4^4 =  256$.
It is very difficult to calculate with or approximate either of these inverse operations to tetration. Super-logarithms use some complicated recursive algorithms (see this wiki article), but super-roots are even harder; the example I showed just turned out to be easy-to-find because $256$ is a perfect super-square (that is, $4^4$). I could only manage to find a formula for super square roots on Wikipedia using the Lambert W function. I originally did not know what this Lambert W function was, but soon after I found out it's just the inverse function of $xe^x$. This expression stated that $ssrt(x) = ln(x)/W(ln(x))$.
However, I cannot find a formula or even approximation for higher super-roots at all. I tried using linear approximation along with a Euclidean distance version of linear approximation on $^3\sqrt{2}_s$  and both were very innacurate. I could eventually calculate $^3\sqrt{2}_s$ to 42 digits as $1.4766843373578699470892355853738898365517$ using this high-precision calculator and binary guess-and-check methods, but I still can't seem to find a generic formula or approximation for these super-roots which have orders higher than $2$, so I would like to know if anyone knows of one.
 A: One thing we can do is render the third superroot as an iteration of second superroots.
Let $x^{x^x}=a$.  Then
$(x^x)^{(x^x)}=a^x$
and we take two square superroots to get a fixed point iteration:
$\color{blue}{x=\sqrt{\sqrt{a^x}_s}_s}$
If we put $a>1$ and $x=1$ on the right side, we get
$x=\sqrt{\sqrt{a}_s}_s$
as our next iteration, and this will lie between $1$ and the true third superroot.  This suggests that the scheme will be convergent.
Let's try this on the third superroot of $16$.  Put $x=1$ on the right side of the fixed point relation above.  Then we get 
$x=\sqrt{\sqrt{16}_s}_s=1.769\text{ (4 digits)}$
Next time around we get to the same accuracy
$x=\sqrt{\sqrt{134.9}_s}_s=1.958\text{ (4 digits)}$
We seem to be converging to $2$ fairly rapidly.
For the third superroot of 2 the corresponding iterations are $1.000, 1.380, 1.459, 1.473, 1.476, \color{blue}{1.477},...$.
For smaller $a$ values the performance deteriorates, an outcome connected with square superroots being no longer single valued when the argument drops below 1.  If $a=0.9$ and an initial value $x=1$ is tried, the iteration converges to about $0.890$ if we take square superroots $\ge 1/e$; but this does not work for $a=0.8$ due to one of the square superroots being undefined over the reals.
A: Just for sake of simplicity, it is possible to compute $\sqrt[n]a_s$ very easily when $a>1$ or $n$ is odd and $a>0$ using bisection, which doesn't involve any hard calculations (so this is something doable with a calculator that only has exponentiation, and perhaps some paper).
As long as you have $x\le\sqrt[n]a_s\le y$, we can iteratively consider $[(x+y)/2]\widehat~\widehat~n$, and replace either $x$ or $y$ with $(x+y)/2$.
To find initial values to work with, note that $a\ge\sqrt[n]a_s$. From there, repeatedly divide by 2 until you find a value where $x\le\sqrt[n]a_s$, and set $y$ to be $2x$. Then apply the above.
Here is a simple program that implements this. It takes 53 steps to compute the result
$$\sqrt[3]2_s\approx1.4766843373578697$$
It is also notable that the above program may fail on larger inputs, since computing things like 256^^3 may not be reasonably doable. For a human, however, if the radicand is small enough, it is easy to find initial values manually.
Since some programming languages give $a^b=\infty$ if $a$ and $b$ are too large, and $\infty$ is considered greater than anything, there is no need to worry about larger inputs. This allows for the computation of things such as $\sqrt[7]{256}_s$ in only 60 steps. See here.

Improvement:
One can employ a faster root-finding algorithm that works well against functions with large second derivatives to get faster practical use. The idea is similar to the above, where we define a new function
$$f(x)=x\widehat~\widehat~n-a$$
which we want to find the root of. We use the initial boundaries
$$(x_l,x_u)=(\min(1,a),\max(1,a))$$
or $x_u=2$ if $f(2)>0$, and then iteratively define the bisection and regula falsi midpoints:
$$x_\mathrm B:=\frac{x_u+x_l}2$$
$$x_\mathrm{RF}:=\frac{x_uf(x_l)-x_lf(x_u)}{f(x_l)-f(x_u)}=\frac{\frac{x_u}{f(x_u)}-\frac{x_l}{f(x_l)}}{\frac1{f(x_u)}-\frac1{f(x_l)}}\stackrel{f(x_u)\to\infty}\longrightarrow x_l$$
where $x_\mathrm{RF}:=x_l$ is used if $f(x_u)$ is infinite in double precision. We then define our new endpoint as
$$x_r:=\begin{cases}\frac12(x_\mathrm B+x_\mathrm{RF}),&\text{steps}\bmod3\ne0\text{ or }x_u-x_l>0.5\text{ or }|f(x_\mathrm{RF})|>0.5\\x_\mathrm{RF},&\text{else}\end{cases}$$
$$x_l:=x_r\text{ if }f(x_r)<0$$
$$x_u:=x_r\text{ if }f(x_r)>0$$
which converges roughly twice as fast as bisection at worst and slightly faster than linear convergence asymptotically. See here for an implementation of the above, which computes $\sqrt[3]2_s$ and $\sqrt[7]{256}_s$ in 9 and 21 iterations respectively.
