[THOUGHT] We need maximize a concave quadratic over a convex polytope. I will use KKT conditions: for each possible active set of the 7 linear inequalities, solve the resulting linear KKT system (stationarity + active constraints as equalities), filter feasible points with nonnegative multipliers, then evaluate F exactly (rationals) and take the maximum. Finally convert M to lowest terms and compute p^2 q. [/THOUGHT] [PYTHON] import itertools import sympy as sp

Variables

x, y, z = sp.symbols('x y z', real=True)

Objective

F = -5x**2 - 4y2 - 6*z2 + 4xy - 2xz + 3yz + 20x + 14y + 15*z + 1

Inequalities g_i <= 0

g = [ -x, # x >= 0 -y, # y >= 0 -z, # z >= 0 x + y - 2, # x+y <= 2 x + 2*y - 3, # x+2y <= 3 x + z - 3, # x+z <= 3 y + z - 3 # y+z <= 3 ]

Gradients of constraints

grad_g = [sp.Matrix([sp.diff(gi, v) for v in (x,y,z)]) for gi in g] grad_F = sp.Matrix([sp.diff(F, v) for v in (x,y,z)])

best = None best_point = None best_active = None

Enumerate all active sets

for r in range(0, len(g)+1): for A in itertools.combinations(range(len(g)), r): # multipliers for active constraints lam = sp.symbols('lam0:'+str(r), real=True) # stationarity: gradF = sum lam_i * grad g_i sum_grad = sp.Matrix([0,0,0]) for idx, li in zip(A, lam): sum_grad += li * grad_g[idx] eqs = list(grad_F - sum_grad) # 3 equations # active constraints equalities eqs += [g[idx] for idx in A] vars_ = (x,y,z) + lam

    # Solve linear system
    sol_set = sp.linsolve(eqs, vars_)
    if not sol_set:
        continue
    for sol in sol_set:
        # If any parameters, skip (shouldn't matter; maxima handled by larger active sets)
        if any(s.free_symbols - set(vars_) for s in sol):
            continue
        xv,yv,zv = sol[0], sol[1], sol[2]
        # Check feasibility of all inequalities
        feasible = True
        for gi in g:
            val = sp.simplify(gi.subs({x:xv,y:yv,z:zv}))
            # require val <= 0
            if sp.nsimplify(val) > 0:
                feasible = False
                break
        if not feasible:
            continue
        # Check multipliers nonnegative
        ok_lam = True
        for li in sol[3:]:
            if sp.nsimplify(li) < 0:
                ok_lam = False
                break
        if not ok_lam:
            continue
        valF = sp.simplify(F.subs({x:xv,y:yv,z:zv}))
        if best is None or sp.nsimplify(valF - best) > 0:
            best = sp.nsimplify(valF)
            best_point = (sp.nsimplify(xv), sp.nsimplify(yv), sp.nsimplify(zv))
            best_active = A

best, best_point, best_active print("best =", best) print("point =", best_point) print("active set =", best_active)

Convert to p/q and compute p^2 q

M = sp.Rational(best) p,q = M.p, M.q print("p,q =", p,q) print("p^2 q =", ppq) [/PYTHON]

[THOUGHT] The prior run errored because some KKT solutions left multipliers symbolic (free), making comparisons like <0 invalid. I’ll rerun while discarding any solution containing free symbols (ensuring all variables/multipliers are numeric), then compute the maximum value exactly as a rational and output p^2 q. [/THOUGHT] [PYTHON] import itertools import sympy as sp

x, y, z = sp.symbols('x y z', real=True)

F = -5x**2 - 4y2 - 6*z2 + 4xy - 2xz + 3yz + 20x + 14y + 15*z + 1

g = [ -x, # x >= 0 -y, # y >= 0 -z, # z >= 0 x + y - 2, # x+y <= 2 x + 2*y - 3, # x+2y <= 3 x + z - 3, # x+z <= 3 y + z - 3 # y+z <= 3 ]

grad_g = [sp.Matrix([sp.diff(gi, v) for v in (x,y,z)]) for gi in g] grad_F = sp.Matrix([sp.diff(F, v) for v in (x,y,z)])

best = None best_point = None best_active = None

for r in range(0, len(g)+1): for A in itertools.combinations(range(len(g)), r): lam = sp.symbols('lam0:'+str(r), real=True) sum_grad = sp.Matrix([0,0,0]) for idx, li in zip(A, lam): sum_grad += li * grad_g[idx] eqs = list(grad_F - sum_grad) eqs += [g[idx] for idx in A] vars_ = (x,y,z) + lam

    sol_set = sp.linsolve(eqs, vars_)
    if not sol_set:
        continue
    for sol in sol_set:
        # require fully numeric solution: no free symbols anywhere
        if any(expr.free_symbols for expr in sol):
            continue
        xv, yv, zv = map(sp.simplify, sol[:3])
        lams = list(map(sp.simplify, sol[3:]))

        # feasibility check
        feasible = True
        for gi in g:
            val = sp.simplify(gi.subs({x:xv,y:yv,z:zv}))
            if val > 0:
                feasible = False
                break
        if not feasible:
            continue

        # multipliers nonnegative
        if any(li < 0 for li in lams):
            continue

        valF = sp.simplify(F.subs({x:xv,y:yv,z:zv}))
        if best is None or valF > best:
            best = valF
            best_point = (xv,yv,zv)
            best_active = A

print("best =", best) print("point =", best_point) print("active =", best_active)

M = sp.Rational(best) p,q = M.p, M.q print("p,q =", p,q) print("p^2 q =", ppq) [/PYTHON][THOUGHT] The maximum value is (M=\frac{641}{4}), so (p=641), (q=4), and (p^2q=1643524). [ \boxed{1643524} ]

[THOUGHT] From the Python output, (M=\frac{122}{3}) in lowest terms, so (p=122), (q=3), and (p^2q=44652). Therefore the requested value is \boxed{44652}.