How to Get Unconditional SymPy Solutions: Verify Candidates That Work for All Remaining Symbols

Enforce universal solutions in SymPy: filter solver results, substitute back, use equals(0) to keep only assignments that always hold for all free symbols.

Universal solutions in symbolic systems look deceptively simple: “solve for a subset of variables and keep only what works for every value of the rest.” In practice, a straightforward call to a computer algebra solver can return candidates that are correct only under hidden constraints on the remaining symbols. If your pipeline needs solutions that hold unconditionally with respect to the other free symbols, you must separate those from the conditional ones.

Problem setup

Suppose you want solutions for a chosen subset of variables that satisfy an entire equation system regardless of the values of the other free symbols. A direct call like solve(system, subset) does not guarantee this. Two minimal examples show the mismatch between what’s returned and what counts as a solution that is valid for all values of the remaining symbols.

from sympy import solve, symbols

a, b = symbols('a b')
system_eqs = [a, b]
targets = [a]
solve(system_eqs, targets)

This yields {a: 0}. However, {a: 0} only satisfies the system when b is also 0. There is no solution in a that satisfies both equations for every possible b, so the desired outcome is effectively “no solution.”

from sympy import solve, symbols

a, b = symbols('a b')
system_eqs = [a, a + b]
targets = [a]
solve(system_eqs, targets)

This returns [], which in this case does align with the intended semantics: there is no value of a that solves the entire system for all b.

Why the mismatch happens

Symbolic solvers routinely return candidate assignments for the target variables that make the system satisfiable, sometimes implicitly relying on relationships between the remaining symbols. That is perfectly reasonable for many algebraic workflows, but it diverges from a stronger requirement: a solution must zero out every equation for any admissible value of the other free symbols. Under that requirement, a candidate is acceptable only if, after substitution, every equation is identically 0 without needing additional constraints.

A pragmatic way to enforce “valid for all remaining symbols”

You can enforce the stronger requirement by post-filtering the results of solve. Ask for solutions as dictionaries, substitute each candidate back into every equation, and keep only those that are identically zero. The check below follows that pattern.

from sympy import solve, symbols

# System: a == 0 and b == 0
# We want solutions for a that are valid regardless of b
p, q = symbols('p q')
exprs = [p, q]
unknowns = [p]

# Get candidate assignments for p
candidates = solve(exprs, unknowns, dict=True)

# Keep only the candidates that annihilate all equations without extra constraints
universal = []
for cand in candidates:
    if all(term.xreplace(cand).equals(0) for term in exprs):
        universal.append(cand)

print(universal)  # []

For this system the filtered result is empty, which matches the intended interpretation. If you modify the second equation to p*q, the filter will accept [{p: 0}] as a universal solution because substituting p = 0 makes both p and p*q equal to 0 for any q.

Notes on tractability and correctness

The identity check equals(0) can be expensive on some expressions. There is no single method that works well for all systems, and there is no guarantee that every case can be efficiently decided. A faster, “probably correct” strategy mirrors the internal behavior used during solving: keep candidates unless a consistency check is definitively False. In that paradigm, solutions for which the check is inconclusive are retained. This trades strictness for speed and scales better when you must sift through many candidates, but it may accept solutions that rely on latent constraints.

Why this matters

Downstream code often depends on clear semantics: either a solution unconditionally satisfies every equation with respect to the remaining symbols, or it does not. Mixing unconditional solutions with conditional ones complicates programmatic workflows and can lead to subtle bugs, especially when a later stage assumes that no hidden constraints are present. Making the distinction explicit at the solver boundary simplifies the logic elsewhere.

Takeaways

If you need solutions that hold for all values of the remaining free symbols, do not rely on the raw output of a generic solver call. Post-process candidate assignments by substituting them back and verifying that every equation becomes identically zero. Expect equals(0) to be more expensive but stricter; if performance is paramount and occasional indeterminacy is acceptable, prefer a faster consistency check that only rejects solutions when it can prove them invalid. When additional structural assumptions about the system are available, they can change what is optimal, but absent those, filtering after solve is a robust general tactic. All examples above were evaluated with SymPy 1.13.3.