How to Get Readable Exact Roots of a Parameterized Cubic in SymPy: Use S(8)/3 Rationals and CSE

Learn why solveset returns huge cubic roots in SymPy and how to keep exact, readable forms using S(8)/3 rationals and CSE for compact, clean symbolic results.

SymPy returns an exact but sprawling expression when you solve a parameterized cubic. The bulk comes from repeated fractional parts and the structure of the cubic formula itself. If you try to coerce that output with a single Rational(...) call, you’ll hit a type error rather than a cleaner form. Below is a compact walkthrough of why this happens and how to get a more readable symbolic result without changing the math.

Problem setup

We want the roots of a cubic in the unknown x with a parameter a. The expression can be written using an auxiliary b = sqrt((8/3)*(1 - a)) and expands to a monic cubic x^3 + (41/3)x^2 + (8/3)(a + 10)x + (160/3)(a - 1). A straightforward solveset(...) call returns an exact set of solutions, but the printed form is huge; attempting Rational(...) on that set throws an error.

Code that reproduces the issue

The following snippet mirrors the setup and shows why a naive Rational(...) call does not help:

import sympy as sy
from sympy import Eq as Equal, solveset as solve_set, Rational as Rat

u_sym, param_sym, beta_sym = sy.symbols('u_sym param_sym beta_sym')

expr_raw = beta_sym*(-(10 + u_sym)*beta_sym - 10*beta_sym) - ((8/3) + u_sym)*((10 + u_sym)*(1 + u_sym) - 10)
expr_sub = expr_raw.subs(beta_sym, sy.sqrt((8/3)*(1 - param_sym)))
rel = Equal(expr_sub, 0)
roots_set = solve_set(rel, u_sym)

# This raises TypeError: invalid input: <set of solutions>
Rat(roots_set)

Two things are at play. First, using plain 8/3 introduces non-rational numbers early, leading to messier output. Second, solve_set(...) returns a set; Rational(...) expects a number or an expression, not a container, so it fails.

What’s actually going on

The cubic formula is inherently verbose, and SymPy faithfully constructs an exact expression for the roots. Repeated fractional values and radicals are expected, and printing them in full expands the output significantly. You can confirm the underlying polynomial is clean by expanding the left-hand side into a polynomial in x and a with only rational coefficients; the expansion matches the stated x^3 + (41/3)x^2 + (8/3)(a + 10)x + (160/3)(a - 1).

There are two practical levers you can pull without changing the math: force rational literals at construction time and factor out common subexpressions to shorten what you see. SymPy provides both via S(...) for exact rationals and cse(...) for common subexpression elimination.

Solution: keep rationals, then compress structure

Switch numeric literals like 8/3 to S(8)/3 so they are inserted as exact rationals. Then ask SymPy to perform common subexpression elimination on the solved result to present a more compact, symbolically equivalent form.

import sympy as sy
from sympy import Eq as Equal, S as Sym, cse as cse_func, solve as solve_func

u_var, par_var, b_var = sy.symbols('u_var par_var b_var')

poly_expr = b_var*(-(10 + u_var)*b_var - 10*b_var) - (Sym(8)/3 + u_var)*((10 + u_var)*(1 + u_var) - 10)
poly_sub = poly_expr.subs(b_var, sy.sqrt(Sym(8)/3 * (1 - par_var)))
poly_eq = Equal(poly_sub, 0)

# Expand to see a polynomial in u_var and par_var with rational coefficients
poly_clean = poly_eq.lhs.expand()

# Get explicit roots and compress their printed form with CSE
repls, compact_roots = cse_func(solve_func(poly_eq, u_var))

# compact_roots now holds a shorter, structurally factored representation of the roots
compact_roots

Using S(8)/3 guarantees all coefficients stay rational rather than floating, which removes one source of noise. Running cse(...) on the explicit roots produces a pair: a list of temporary definitions and a list of root expressions written in terms of those temporaries. This doesn’t change the solutions; it only shortens the way they are written.

Why this matters

Exact arithmetic versus floating approximations impacts both readability and downstream transformations. Keeping everything rational avoids unnecessary float artifacts in the final expressions. At the same time, the cubic formula will remain large no matter what, so structural compaction with cse(...) can make the expressions practical to inspect, log, or substitute further.

Takeaways

If you need explicit roots, expect the cubic formula to be verbose. Preserve exactness by writing rationals as S(8)/3 rather than 8/3. When the expressions get unwieldy, run cse(...) on the solved result to factor out repeated parts without changing semantics. If your goal is to analyze or manipulate the polynomial itself, expanding the left-hand side with .lhs.expand() yields a clean polynomial in the unknown and the parameter with rational coefficients, which is often the most convenient starting point.