The goal is to eliminate ,  and  from . However, eliminate only outputs a null expression (I added a  to emphasize it): 

restart;
expr := 4*[y*z/((x + y)*(x + z)), z*x/((y + z)*(y + x)), x*y/((z + x)*(z + y))]:
{eliminate}([a, b, c]**~2 =~ expr, [x, y, z]);
 = 
                               {}

Why is the result empty? 
In my view, the result should be  (or its equivalent). One may verify this by: 

seq(seq(seq(
    is(eval((a^2 + b^2 + c^2 - 4)^2 = (a*b*c)^2, 
      elementwise([a, b, c] = [k1, k2, k3]*sqrt(expr)))), 
    `in`(k3, [-1, +1])), `in`(k2, [-1, +1])), `in`(k1, [-1, +1]));
 = 
         true, true, true, true, true, true, true, true

Recently, I read an old article about how to call external subroutines to speed up the evaluation tremendously. The core of that article is: 

Evidently, the is equivalent to  when b＞0, and the  is equivalent to . 
The 𝙲 code in that article was composed separately. However, now that it is possible to generate external functions, compile and access them using a single Compiler:-Compile command, it is better to complete the entire process on the fly (in order to reduce oversights and typographical errors while coding). (Besides, the original 𝙼𝚊𝚙𝚕𝚎 implementation appears verbose and less elegant.) So I write: 

But unfortunately, I then get: 

JonesM1(1);
                               2

JonesM1(2);
                               3

JonesM1(3);
                               5

JonesM1(4);
Error, (in JonesM1) integer overflow detected in compiled code

How do I get rid of this error message? 

Note. Of course there exist a ready-to-use built-in function , but the chief aim is not to find the n-th prime number as quickly as possible; I want to see if 𝙼𝚊𝚙𝚕𝚎 can directly create a compiled version of the one-liner that implements the so-called Jones' algorithm instead of writing separate 𝙲 code like that article. (Don't confound the means with the ends.) 

The output  means that there is no real solution, but clearly, both and  satisfy the original equation: 

So, why does `solve` lose the real solutions without any warning messages? 
Code: 

restart;
eq := 9*(x^2 + 2*cos(x)) = Pi^2 + 9;
RealDomain:-solve(eq, [x]);
                               []

:-solve({eq, x >= 0}, [x]); # as (lhs - rhs)(eq) is an even function 
                               []

Here are two systems over the reals:

The following results indicate that both and are satisfiable 

QuantifierElimination:-QuantifierEliminate(exists([s,q,r],sys__1));
                              true

QuantifierElimination:-QuantifierEliminate(exists([s,q,r],sys__1));
                              true

but RealDomain:-solve simply returns an empty list (that is, no solution exists) in both cases

RealDomain:-solve(sys__1,[q,s,r]); # ⟹ sys1 cannot be satisfied
                               []

RealDomain:-solve(sys__2,[q,s,r]); # ⟹ sys2 cannot be satisfied
                               []

As discussed in the previous problem, in contrast to using QuantifierElimination:-QuantifierEliminate, the use of RealDomain:-solve is unsafe. Nevertheless, the above output suggests that even the much-more-sophisticated QuantifierElimination:-QuantifierEliminate is still not always reliable (since the correct returnedvalue appears to be in lieu of ). So, what is the right command to handle polynomial systems over real domains in Maple? 

The first time they are evaluated, some aborts can occur; the second time they are evaluated, no exception is thrown: 
 

Download run__twice.mw

Why does (the outer) RootOf have to be evaluated twice? 
Note. There are other similar examples, but they are less concise (so they are omitted here).