How to solve non-linear sets of equations

Learn how to solve non-linear sets of equations with practical examples, diagrams, and best practices. Covers python, math, numpy development techniques with visual explanations.

Solving Non-Linear Systems of Equations in Python

Hero image for How to solve non-linear sets of equations

Explore powerful Python libraries like SciPy, NumPy, and SymPy to effectively solve complex non-linear systems of equations, from numerical approximations to symbolic solutions.

Solving non-linear systems of equations is a common task in various scientific and engineering disciplines. Unlike linear systems, non-linear systems often lack analytical solutions and require numerical methods or symbolic manipulation. Python, with its rich ecosystem of mathematical libraries, provides robust tools to tackle these challenges. This article will guide you through different approaches using SciPy for numerical solutions, NumPy for foundational array operations, and SymPy for symbolic computations.

Understanding Non-Linear Systems

A system of non-linear equations consists of two or more equations where at least one equation is not linear. This means variables might be raised to powers other than one, multiplied together, or appear inside non-linear functions like sin(), cos(), exp(), or log(). Finding the solutions (roots) to such systems involves identifying the points where all equations are simultaneously satisfied. Due to their complexity, these systems can have multiple solutions, no solutions, or even an infinite number of solutions, depending on the specific functions involved.

flowchart TD
    A[Start] --> B{Define Non-Linear System}
    B --> C{Choose Solution Method}
    C -->|Numerical (SciPy)| D[Provide Initial Guess]
    C -->|Symbolic (SymPy)| E[Define Variables & Equations]
    D --> F[Iterative Solver (e.g., `fsolve`)]
    E --> G[Symbolic Solver (e.g., `solve`)]
    F --> H{Check Convergence & Accuracy}
    G --> I{Evaluate Solutions}
    H --> J[Numerical Solutions]
    I --> K[Symbolic Solutions]
    J --> L[End]
    K --> L[End]

Workflow for solving non-linear systems of equations

Numerical Solutions with SciPy

SciPy is Python's scientific computing library, and its optimize module provides several functions for finding the roots of non-linear equations. The most commonly used function for systems of equations is scipy.optimize.fsolve. This function requires you to define your system of equations as a Python function that returns an array of the residuals (the difference between the left and right sides of the equations when set to zero). It also requires an initial guess for the solution, which is crucial for convergence, especially in non-linear problems.

import numpy as np
from scipy.optimize import fsolve

# Define the system of non-linear equations
# f1(x, y) = x^2 + y^2 - 4 = 0
# f2(x, y) = y - x^2 + 1 = 0
def equations(p):
    x, y = p
    return (
        x**2 + y**2 - 4,
        y - x**2 + 1
    )

# Initial guess for the solution
initial_guess = [1, 1]

# Solve the system
solution = fsolve(equations, initial_guess)

print(f"Numerical solution: x={solution[0]:.4f}, y={solution[1]:.4f}")

# Verify the solution
print(f"Verification: {equations(solution)}")

Solving a non-linear system numerically using scipy.optimize.fsolve

💡

The choice of initial guess is critical for fsolve. A poor initial guess might lead to convergence to a local minimum, a different root than expected, or even failure to converge. Visualizing the functions or using domain knowledge can help in providing a good initial guess.

Symbolic Solutions with SymPy

For systems where an exact, analytical solution is desired, SymPy comes into play. SymPy is a Python library for symbolic mathematics. It can define symbolic variables, construct equations, and then solve them symbolically. This approach is powerful when you need to understand the structure of the solutions or when numerical precision is not sufficient. SymPy's solve function is versatile and can handle various types of equations, including non-linear systems.

from sympy import symbols, solve

# Define symbolic variables
x, y = symbols('x y')

# Define the system of non-linear equations
# x^2 + y^2 - 4 = 0
# y - x^2 + 1 = 0
equation1 = x**2 + y**2 - 4
equation2 = y - x**2 + 1

# Solve the system symbolically
solutions = solve((equation1, equation2), (x, y))

print("Symbolic solutions:")
for sol in solutions:
    print(f"  x={sol[x]}, y={sol[y]}")

Solving a non-linear system symbolically using SymPy

⚠️

SymPy's solve function can be computationally intensive for very complex or large systems of non-linear equations. It might also return solutions that involve complex numbers, even if only real solutions are physically meaningful in your context. Always check the nature of the solutions returned.

Practical Considerations and Advanced Techniques

When dealing with non-linear systems, several practical aspects can influence your approach:

Multiple Solutions: Non-linear systems can have multiple solutions. Numerical solvers like fsolve will typically find one solution based on the initial guess. To find other solutions, you might need to try different initial guesses or use global optimization techniques.
No Solution: Some non-linear systems might not have any real solutions. Numerical solvers might converge to a non-real solution or fail to converge.
Convergence Issues: Numerical methods are iterative. They might fail to converge if the initial guess is too far from a root, or if the system is ill-conditioned. Techniques like trust-region methods (scipy.optimize.root with method='lm' or 'hybr') can sometimes offer more robustness.
System Size: For very large systems, specialized algorithms and parallel computing might be necessary. Libraries like JAX or TensorFlow can be used for automatic differentiation, which is beneficial for gradient-based optimization methods.

Choosing between numerical and symbolic methods depends on your specific needs: numerical for approximations and efficiency, symbolic for exact solutions and analytical insights.