Max gives us a shortcut allowing us to use brute force to check for (positive) roots of this system. But what is the solution ?

First, let's see how Max's shortcut can be derived in Sage :

```
sage: var("x, y, z, p")
(x, y, z, p)
```

Our initial equations are :

```
sage: E1=x+y+z==24*p+3
sage: E2=x*y*z==576*p^3+216*p^2+27*p-25
```

Let's solve E2, keeping only real roots, but with no consideration for their integrity

```
sage: E2.solve(p)
[p == -1/16*(8/9*x*y*z + 209/9)^(1/3)*(I*sqrt(3) + 1) - 1/8, p == -1/16*(8/9*x*y*z + 209/9)^(1/3)*(-I*sqrt(3) + 1) - 1/8, p == 1/24*(24*x*y*z + 627)^(1/3) - 1/8]
```

Substitute in E1 :

```
sage: E1.subs(E2.solve(p)[2])^3
(x + y + z)^3 == 24*x*y*z + 627
```

AM-GM inequality gives us :

```
sage: I1=(x+y+z)/3>=(x*y*z)^(1/3)
sage: ((I1*3)^3)
(x + y + z)^3 >= 27*x*y*z
```

Adding our constraints :

```
sage: (((I1*3)^3).subs(E1.subs(E2.solve(p)[2])^3))
24*x*y*z + 627 >= 27*x*y*z
```

which results in:

```
sage: I2=(((I1*3)^3).subs(E1.subs(E2.solve(p)[2])^3)).solve(x*y*z)
[[x*y*z - 209 == 0], [-x*y*z + 209 > 0]]
```

This upper limit allows us to program a "brute-force" search :

```
sage: %%time
....: L=[]
....: for a in (1..209):
....: for b in (1..209//a):
....: for c in (1..209//(a*b)):
....: D1={x:a, y:b, z:c}
....: S1=E1.subs(D1).solve_diophantine(solution_dict=True)
....: if len(S1)>0:
....: L2=[D1.update(s) for s in S1 if bool(E2.subs(D1).subs(S1))]
....: if len(L2)>0: L.append(L2)
....:
CPU times: user 34.3 s, sys: 16 ms, total: 34.4 s
Wall time: 34.4 s
```

But :

```
sage: L
[]
```

The original system doesn't seem to have solutions. A check seems in order...

Homework ?

No just trying to solve!