Add files using upload-large-folder tool

pllava/lib/python3.10/site-packages/sympy/solvers/benchmarks/bench_solvers.py

@@ -0,0 +1,12 @@
+from sympy.core.symbol import Symbol
+from sympy.matrices.dense import (eye, zeros)
+from sympy.solvers.solvers import solve_linear_system
+
+N = 8
+M = zeros(N, N + 1)
+M[:, :N] = eye(N)
+S = [Symbol('A%i' % i) for i in range(N)]
+
+
+def timeit_linsolve_trivial():
+    solve_linear_system(M, *S)

pllava/lib/python3.10/site-packages/sympy/solvers/decompogen.py

@@ -0,0 +1,126 @@
+from sympy.core import (Function, Pow, sympify, Expr)
+from sympy.core.relational import Relational
+from sympy.core.singleton import S
+from sympy.polys import Poly, decompose
+from sympy.utilities.misc import func_name
+from sympy.functions.elementary.miscellaneous import Min, Max
+
+
+def decompogen(f, symbol):
+    """
+    Computes General functional decomposition of ``f``.
+    Given an expression ``f``, returns a list ``[f_1, f_2, ..., f_n]``,
+    where::
+              f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))
+
+    Note: This is a General decomposition function. It also decomposes
+    Polynomials. For only Polynomial decomposition see ``decompose`` in polys.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy import decompogen, sqrt, sin, cos
+    >>> decompogen(sin(cos(x)), x)
+    [sin(x), cos(x)]
+    >>> decompogen(sin(x)**2 + sin(x) + 1, x)
+    [x**2 + x + 1, sin(x)]
+    >>> decompogen(sqrt(6*x**2 - 5), x)
+    [sqrt(x), 6*x**2 - 5]
+    >>> decompogen(sin(sqrt(cos(x**2 + 1))), x)
+    [sin(x), sqrt(x), cos(x), x**2 + 1]
+    >>> decompogen(x**4 + 2*x**3 - x - 1, x)
+    [x**2 - x - 1, x**2 + x]
+
+    """
+    f = sympify(f)
+    if not isinstance(f, Expr) or isinstance(f, Relational):
+        raise TypeError('expecting Expr but got: `%s`' % func_name(f))
+    if symbol not in f.free_symbols:
+        return [f]
+
+
+    # ===== Simple Functions ===== #
+    if isinstance(f, (Function, Pow)):
+        if f.is_Pow and f.base == S.Exp1:
+            arg = f.exp
+        else:
+            arg = f.args[0]
+        if arg == symbol:
+            return [f]
+        return [f.subs(arg, symbol)] + decompogen(arg, symbol)
+
+    # ===== Min/Max Functions ===== #
+    if isinstance(f, (Min, Max)):
+        args = list(f.args)
+        d0 = None
+        for i, a in enumerate(args):
+            if not a.has_free(symbol):
+                continue
+            d = decompogen(a, symbol)
+            if len(d) == 1:
+                d = [symbol] + d
+            if d0 is None:
+                d0 = d[1:]
+            elif d[1:] != d0:
+                # decomposition is not the same for each arg:
+                # mark as having no decomposition
+                d = [symbol]
+                break
+            args[i] = d[0]
+        if d[0] == symbol:
+            return [f]
+        return [f.func(*args)] + d0
+
+    # ===== Convert to Polynomial ===== #
+    fp = Poly(f)
+    gens = list(filter(lambda x: symbol in x.free_symbols, fp.gens))
+
+    if len(gens) == 1 and gens[0] != symbol:
+        f1 = f.subs(gens[0], symbol)
+        f2 = gens[0]
+        return [f1] + decompogen(f2, symbol)
+
+    # ===== Polynomial decompose() ====== #
+    try:
+        return decompose(f)
+    except ValueError:
+        return [f]
+
+
+def compogen(g_s, symbol):
+    """
+    Returns the composition of functions.
+    Given a list of functions ``g_s``, returns their composition ``f``,
+    where:
+        f = g_1 o g_2 o .. o g_n
+
+    Note: This is a General composition function. It also composes Polynomials.
+    For only Polynomial composition see ``compose`` in polys.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.decompogen import compogen
+    >>> from sympy.abc import x
+    >>> from sympy import sqrt, sin, cos
+    >>> compogen([sin(x), cos(x)], x)
+    sin(cos(x))
+    >>> compogen([x**2 + x + 1, sin(x)], x)
+    sin(x)**2 + sin(x) + 1
+    >>> compogen([sqrt(x), 6*x**2 - 5], x)
+    sqrt(6*x**2 - 5)
+    >>> compogen([sin(x), sqrt(x), cos(x), x**2 + 1], x)
+    sin(sqrt(cos(x**2 + 1)))
+    >>> compogen([x**2 - x - 1, x**2 + x], x)
+    -x**2 - x + (x**2 + x)**2 - 1
+    """
+    if len(g_s) == 1:
+        return g_s[0]
+
+    foo = g_s[0].subs(symbol, g_s[1])
+
+    if len(g_s) == 2:
+        return foo
+
+    return compogen([foo] + g_s[2:], symbol)

pllava/lib/python3.10/site-packages/sympy/solvers/deutils.py

@@ -0,0 +1,273 @@
+"""Utility functions for classifying and solving
+ordinary and partial differential equations.
+
+Contains
+========
+_preprocess
+ode_order
+_desolve
+
+"""
+from sympy.core import Pow
+from sympy.core.function import Derivative, AppliedUndef
+from sympy.core.relational import Equality
+from sympy.core.symbol import Wild
+
+def _preprocess(expr, func=None, hint='_Integral'):
+    """Prepare expr for solving by making sure that differentiation
+    is done so that only func remains in unevaluated derivatives and
+    (if hint does not end with _Integral) that doit is applied to all
+    other derivatives. If hint is None, do not do any differentiation.
+    (Currently this may cause some simple differential equations to
+    fail.)
+
+    In case func is None, an attempt will be made to autodetect the
+    function to be solved for.
+
+    >>> from sympy.solvers.deutils import _preprocess
+    >>> from sympy import Derivative, Function
+    >>> from sympy.abc import x, y, z
+    >>> f, g = map(Function, 'fg')
+
+    If f(x)**p == 0 and p>0 then we can solve for f(x)=0
+    >>> _preprocess((f(x).diff(x)-4)**5, f(x))
+    (Derivative(f(x), x) - 4, f(x))
+
+    Apply doit to derivatives that contain more than the function
+    of interest:
+
+    >>> _preprocess(Derivative(f(x) + x, x))
+    (Derivative(f(x), x) + 1, f(x))
+
+    Do others if the differentiation variable(s) intersect with those
+    of the function of interest or contain the function of interest:
+
+    >>> _preprocess(Derivative(g(x), y, z), f(y))
+    (0, f(y))
+    >>> _preprocess(Derivative(f(y), z), f(y))
+    (0, f(y))
+
+    Do others if the hint does not end in '_Integral' (the default
+    assumes that it does):
+
+    >>> _preprocess(Derivative(g(x), y), f(x))
+    (Derivative(g(x), y), f(x))
+    >>> _preprocess(Derivative(f(x), y), f(x), hint='')
+    (0, f(x))
+
+    Do not do any derivatives if hint is None:
+
+    >>> eq = Derivative(f(x) + 1, x) + Derivative(f(x), y)
+    >>> _preprocess(eq, f(x), hint=None)
+    (Derivative(f(x) + 1, x) + Derivative(f(x), y), f(x))
+
+    If it's not clear what the function of interest is, it must be given:
+
+    >>> eq = Derivative(f(x) + g(x), x)
+    >>> _preprocess(eq, g(x))
+    (Derivative(f(x), x) + Derivative(g(x), x), g(x))
+    >>> try: _preprocess(eq)
+    ... except ValueError: print("A ValueError was raised.")
+    A ValueError was raised.
+
+    """
+    if isinstance(expr, Pow):
+        # if f(x)**p=0 then f(x)=0 (p>0)
+        if (expr.exp).is_positive:
+            expr = expr.base
+    derivs = expr.atoms(Derivative)
+    if not func:
+        funcs = set().union(*[d.atoms(AppliedUndef) for d in derivs])
+        if len(funcs) != 1:
+            raise ValueError('The function cannot be '
+                'automatically detected for %s.' % expr)
+        func = funcs.pop()
+    fvars = set(func.args)
+    if hint is None:
+        return expr, func
+    reps = [(d, d.doit()) for d in derivs if not hint.endswith('_Integral') or
+            d.has(func) or set(d.variables) & fvars]
+    eq = expr.subs(reps)
+    return eq, func
+
+
+def ode_order(expr, func):
+    """
+    Returns the order of a given differential
+    equation with respect to func.
+
+    This function is implemented recursively.
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.solvers.deutils import ode_order
+    >>> from sympy.abc import x
+    >>> f, g = map(Function, ['f', 'g'])
+    >>> ode_order(f(x).diff(x, 2) + f(x).diff(x)**2 +
+    ... f(x).diff(x), f(x))
+    2
+    >>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), f(x))
+    2
+    >>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), g(x))
+    3
+
+    """
+    a = Wild('a', exclude=[func])
+    if expr.match(a):
+        return 0
+
+    if isinstance(expr, Derivative):
+        if expr.args[0] == func:
+            return len(expr.variables)
+        else:
+            args = expr.args[0].args
+            rv = len(expr.variables)
+            if args:
+                rv += max(ode_order(_, func) for _ in args)
+            return rv
+    else:
+        return max(ode_order(_, func) for _ in expr.args) if expr.args else 0
+
+
+def _desolve(eq, func=None, hint="default", ics=None, simplify=True, *, prep=True, **kwargs):
+    """This is a helper function to dsolve and pdsolve in the ode
+    and pde modules.
+
+    If the hint provided to the function is "default", then a dict with
+    the following keys are returned
+
+    'func'    - It provides the function for which the differential equation
+                has to be solved. This is useful when the expression has
+                more than one function in it.
+
+    'default' - The default key as returned by classifier functions in ode
+                and pde.py
+
+    'hint'    - The hint given by the user for which the differential equation
+                is to be solved. If the hint given by the user is 'default',
+                then the value of 'hint' and 'default' is the same.
+
+    'order'   - The order of the function as returned by ode_order
+
+    'match'   - It returns the match as given by the classifier functions, for
+                the default hint.
+
+    If the hint provided to the function is not "default" and is not in
+    ('all', 'all_Integral', 'best'), then a dict with the above mentioned keys
+    is returned along with the keys which are returned when dict in
+    classify_ode or classify_pde is set True
+
+    If the hint given is in ('all', 'all_Integral', 'best'), then this function
+    returns a nested dict, with the keys, being the set of classified hints
+    returned by classifier functions, and the values being the dict of form
+    as mentioned above.
+
+    Key 'eq' is a common key to all the above mentioned hints which returns an
+    expression if eq given by user is an Equality.
+
+    See Also
+    ========
+    classify_ode(ode.py)
+    classify_pde(pde.py)
+    """
+    if isinstance(eq, Equality):
+        eq = eq.lhs - eq.rhs
+
+    # preprocess the equation and find func if not given
+    if prep or func is None:
+        eq, func = _preprocess(eq, func)
+        prep = False
+
+    # type is an argument passed by the solve functions in ode and pde.py
+    # that identifies whether the function caller is an ordinary
+    # or partial differential equation. Accordingly corresponding
+    # changes are made in the function.
+    type = kwargs.get('type', None)
+    xi = kwargs.get('xi')
+    eta = kwargs.get('eta')
+    x0 = kwargs.get('x0', 0)
+    terms = kwargs.get('n')
+
+    if type == 'ode':
+        from sympy.solvers.ode import classify_ode, allhints
+        classifier = classify_ode
+        string = 'ODE '
+        dummy = ''
+
+    elif type == 'pde':
+        from sympy.solvers.pde import classify_pde, allhints
+        classifier = classify_pde
+        string = 'PDE '
+        dummy = 'p'
+
+    # Magic that should only be used internally.  Prevents classify_ode from
+    # being called more than it needs to be by passing its results through
+    # recursive calls.
+    if kwargs.get('classify', True):
+        hints = classifier(eq, func, dict=True, ics=ics, xi=xi, eta=eta,
+        n=terms, x0=x0, hint=hint, prep=prep)
+
+    else:
+        # Here is what all this means:
+        #
+        # hint:    The hint method given to _desolve() by the user.
+        # hints:   The dictionary of hints that match the DE, along with other
+        #          information (including the internal pass-through magic).
+        # default: The default hint to return, the first hint from allhints
+        #          that matches the hint; obtained from classify_ode().
+        # match:   Dictionary containing the match dictionary for each hint
+        #          (the parts of the DE for solving).  When going through the
+        #          hints in "all", this holds the match string for the current
+        #          hint.
+        # order:   The order of the DE, as determined by ode_order().
+        hints = kwargs.get('hint',
+                           {'default': hint,
+                            hint: kwargs['match'],
+                            'order': kwargs['order']})
+    if not hints['default']:
+        # classify_ode will set hints['default'] to None if no hints match.
+        if hint not in allhints and hint != 'default':
+            raise ValueError("Hint not recognized: " + hint)
+        elif hint not in hints['ordered_hints'] and hint != 'default':
+            raise ValueError(string + str(eq) + " does not match hint " + hint)
+        # If dsolve can't solve the purely algebraic equation then dsolve will raise
+        # ValueError
+        elif hints['order'] == 0:
+            raise ValueError(
+                str(eq) + " is not a solvable differential equation in " + str(func))
+        else:
+            raise NotImplementedError(dummy + "solve" + ": Cannot solve " + str(eq))
+    if hint == 'default':
+        return _desolve(eq, func, ics=ics, hint=hints['default'], simplify=simplify,
+                      prep=prep, x0=x0, classify=False, order=hints['order'],
+                      match=hints[hints['default']], xi=xi, eta=eta, n=terms, type=type)
+    elif hint in ('all', 'all_Integral', 'best'):
+        retdict = {}
+        gethints = set(hints) - {'order', 'default', 'ordered_hints'}
+        if hint == 'all_Integral':
+            for i in hints:
+                if i.endswith('_Integral'):
+                    gethints.remove(i[:-len('_Integral')])
+            # special cases
+            for k in ["1st_homogeneous_coeff_best", "1st_power_series",
+                "lie_group", "2nd_power_series_ordinary", "2nd_power_series_regular"]:
+                if k in gethints:
+                    gethints.remove(k)
+        for i in gethints:
+            sol = _desolve(eq, func, ics=ics, hint=i, x0=x0, simplify=simplify, prep=prep,
+                classify=False, n=terms, order=hints['order'], match=hints[i], type=type)
+            retdict[i] = sol
+        retdict['all'] = True
+        retdict['eq'] = eq
+        return retdict
+    elif hint not in allhints:  # and hint not in ('default', 'ordered_hints'):
+        raise ValueError("Hint not recognized: " + hint)
+    elif hint not in hints:
+        raise ValueError(string + str(eq) + " does not match hint " + hint)
+    else:
+        # Key added to identify the hint needed to solve the equation
+        hints['hint'] = hint
+    hints.update({'func': func, 'eq': eq})
+    return hints

pllava/lib/python3.10/site-packages/sympy/solvers/diophantine/__init__.py

@@ -0,0 +1,5 @@
+from .diophantine import diophantine, classify_diop, diop_solve
+
+__all__ = [
+    'diophantine', 'classify_diop', 'diop_solve'
+]

pllava/lib/python3.10/site-packages/sympy/solvers/diophantine/tests/test_diophantine.py

@@ -0,0 +1,1051 @@
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import Matrix
+from sympy.ntheory.factor_ import factorint
+from sympy.simplify.powsimp import powsimp
+from sympy.core.function import _mexpand
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.functions.elementary.trigonometric import sin
+from sympy.solvers.diophantine import diophantine
+from sympy.solvers.diophantine.diophantine import (diop_DN,
+    diop_solve, diop_ternary_quadratic_normal,
+    diop_general_pythagorean, diop_ternary_quadratic, diop_linear,
+    diop_quadratic, diop_general_sum_of_squares, diop_general_sum_of_even_powers,
+    descent, diop_bf_DN, divisible, equivalent, find_DN, ldescent, length,
+    reconstruct, partition, power_representation,
+    prime_as_sum_of_two_squares, square_factor, sum_of_four_squares,
+    sum_of_three_squares, transformation_to_DN, transformation_to_normal,
+    classify_diop, base_solution_linear, cornacchia, sqf_normal, gaussian_reduce, holzer,
+    check_param, parametrize_ternary_quadratic, sum_of_powers, sum_of_squares,
+    _diop_ternary_quadratic_normal, _nint_or_floor,
+    _odd, _even, _remove_gcd, _can_do_sum_of_squares, DiophantineSolutionSet, GeneralPythagorean,
+    BinaryQuadratic)
+
+from sympy.testing.pytest import slow, raises, XFAIL
+from sympy.utilities.iterables import (
+        signed_permutations)
+
+a, b, c, d, p, q, x, y, z, w, t, u, v, X, Y, Z = symbols(
+    "a, b, c, d, p, q, x, y, z, w, t, u, v, X, Y, Z", integer=True)
+t_0, t_1, t_2, t_3, t_4, t_5, t_6 = symbols("t_:7", integer=True)
+m1, m2, m3 = symbols('m1:4', integer=True)
+n1 = symbols('n1', integer=True)
+
+
+def diop_simplify(eq):
+    return _mexpand(powsimp(_mexpand(eq)))
+
+
+def test_input_format():
+    raises(TypeError, lambda: diophantine(sin(x)))
+    raises(TypeError, lambda: diophantine(x/pi - 3))
+
+
+def test_nosols():
+    # diophantine should sympify eq so that these are equivalent
+    assert diophantine(3) == set()
+    assert diophantine(S(3)) == set()
+
+
+def test_univariate():
+    assert diop_solve((x - 1)*(x - 2)**2) == {(1,), (2,)}
+    assert diop_solve((x - 1)*(x - 2)) == {(1,), (2,)}
+
+
+def test_classify_diop():
+    raises(TypeError, lambda: classify_diop(x**2/3 - 1))
+    raises(ValueError, lambda: classify_diop(1))
+    raises(NotImplementedError, lambda: classify_diop(w*x*y*z - 1))
+    raises(NotImplementedError, lambda: classify_diop(x**3 + y**3 + z**4 - 90))
+    assert classify_diop(14*x**2 + 15*x - 42) == (
+        [x], {1: -42, x: 15, x**2: 14}, 'univariate')
+    assert classify_diop(x*y + z) == (
+        [x, y, z], {x*y: 1, z: 1}, 'inhomogeneous_ternary_quadratic')
+    assert classify_diop(x*y + z + w + x**2) == (
+        [w, x, y, z], {x*y: 1, w: 1, x**2: 1, z: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + x*z + x**2 + 1) == (
+        [x, y, z], {x*y: 1, x*z: 1, x**2: 1, 1: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + z + w + 42) == (
+        [w, x, y, z], {x*y: 1, w: 1, 1: 42, z: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + z*w) == (
+        [w, x, y, z], {x*y: 1, w*z: 1}, 'homogeneous_general_quadratic')
+    assert classify_diop(x*y**2 + 1) == (
+        [x, y], {x*y**2: 1, 1: 1}, 'cubic_thue')
+    assert classify_diop(x**4 + y**4 + z**4 - (1 + 16 + 81)) == (
+        [x, y, z], {1: -98, x**4: 1, z**4: 1, y**4: 1}, 'general_sum_of_even_powers')
+    assert classify_diop(x**2 + y**2 + z**2) == (
+        [x, y, z], {x**2: 1, y**2: 1, z**2: 1}, 'homogeneous_ternary_quadratic_normal')
+
+
+def test_linear():
+    assert diop_solve(x) == (0,)
+    assert diop_solve(1*x) == (0,)
+    assert diop_solve(3*x) == (0,)
+    assert diop_solve(x + 1) == (-1,)
+    assert diop_solve(2*x + 1) == (None,)
+    assert diop_solve(2*x + 4) == (-2,)
+    assert diop_solve(y + x) == (t_0, -t_0)
+    assert diop_solve(y + x + 0) == (t_0, -t_0)
+    assert diop_solve(y + x - 0) == (t_0, -t_0)
+    assert diop_solve(0*x - y - 5) == (-5,)
+    assert diop_solve(3*y + 2*x - 5) == (3*t_0 - 5, -2*t_0 + 5)
+    assert diop_solve(2*x - 3*y - 5) == (3*t_0 - 5, 2*t_0 - 5)
+    assert diop_solve(-2*x - 3*y - 5) == (3*t_0 + 5, -2*t_0 - 5)
+    assert diop_solve(7*x + 5*y) == (5*t_0, -7*t_0)
+    assert diop_solve(2*x + 4*y) == (-2*t_0, t_0)
+    assert diop_solve(4*x + 6*y - 4) == (3*t_0 - 2, -2*t_0 + 2)
+    assert diop_solve(4*x + 6*y - 3) == (None, None)
+    assert diop_solve(0*x + 3*y - 4*z + 5) == (4*t_0 + 5, 3*t_0 + 5)
+    assert diop_solve(4*x + 3*y - 4*z + 5) == (t_0, 8*t_0 + 4*t_1 + 5, 7*t_0 + 3*t_1 + 5)
+    assert diop_solve(4*x + 3*y - 4*z + 5, None) == (0, 5, 5)
+    assert diop_solve(4*x + 2*y + 8*z - 5) == (None, None, None)
+    assert diop_solve(5*x + 7*y - 2*z - 6) == (t_0, -3*t_0 + 2*t_1 + 6, -8*t_0 + 7*t_1 + 18)
+    assert diop_solve(3*x - 6*y + 12*z - 9) == (2*t_0 + 3, t_0 + 2*t_1, t_1)
+    assert diop_solve(6*w + 9*x + 20*y - z) == (t_0, t_1, t_1 + t_2, 6*t_0 + 29*t_1 + 20*t_2)
+
+    # to ignore constant factors, use diophantine
+    raises(TypeError, lambda: diop_solve(x/2))
+
+
+def test_quadratic_simple_hyperbolic_case():
+    # Simple Hyperbolic case: A = C = 0 and B != 0
+    assert diop_solve(3*x*y + 34*x - 12*y + 1) == \
+           {(-133, -11), (5, -57)}
+    assert diop_solve(6*x*y + 2*x + 3*y + 1) == set()
+    assert diop_solve(-13*x*y + 2*x - 4*y - 54) == {(27, 0)}
+    assert diop_solve(-27*x*y - 30*x - 12*y - 54) == {(-14, -1)}
+    assert diop_solve(2*x*y + 5*x + 56*y + 7) == {(-161, -3), (-47, -6), (-35, -12),
+                                                  (-29, -69), (-27, 64), (-21, 7),
+                                                  (-9, 1), (105, -2)}
+    assert diop_solve(6*x*y + 9*x + 2*y + 3) == set()
+    assert diop_solve(x*y + x + y + 1) == {(-1, t), (t, -1)}
+    assert diophantine(48*x*y)
+
+
+def test_quadratic_elliptical_case():
+    # Elliptical case: B**2 - 4AC < 0
+
+    assert diop_solve(42*x**2 + 8*x*y + 15*y**2 + 23*x + 17*y - 4915) == {(-11, -1)}
+    assert diop_solve(4*x**2 + 3*y**2 + 5*x - 11*y + 12) == set()
+    assert diop_solve(x**2 + y**2 + 2*x + 2*y + 2) == {(-1, -1)}
+    assert diop_solve(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950) == {(-15, 6)}
+    assert diop_solve(10*x**2 + 12*x*y + 12*y**2 - 34) == \
+           {(-1, -1), (-1, 2), (1, -2), (1, 1)}
+
+
+def test_quadratic_parabolic_case():
+    # Parabolic case: B**2 - 4AC = 0
+    assert check_solutions(8*x**2 - 24*x*y + 18*y**2 + 5*x + 7*y + 16)
+    assert check_solutions(8*x**2 - 24*x*y + 18*y**2 + 6*x + 12*y - 6)
+    assert check_solutions(8*x**2 + 24*x*y + 18*y**2 + 4*x + 6*y - 7)
+    assert check_solutions(-4*x**2 + 4*x*y - y**2 + 2*x - 3)
+    assert check_solutions(x**2 + 2*x*y + y**2 + 2*x + 2*y + 1)
+    assert check_solutions(x**2 - 2*x*y + y**2 + 2*x + 2*y + 1)
+    assert check_solutions(y**2 - 41*x + 40)
+
+
+def test_quadratic_perfect_square():
+    # B**2 - 4*A*C > 0
+    # B**2 - 4*A*C is a perfect square
+    assert check_solutions(48*x*y)
+    assert check_solutions(4*x**2 - 5*x*y + y**2 + 2)
+    assert check_solutions(-2*x**2 - 3*x*y + 2*y**2 -2*x - 17*y + 25)
+    assert check_solutions(12*x**2 + 13*x*y + 3*y**2 - 2*x + 3*y - 12)
+    assert check_solutions(8*x**2 + 10*x*y + 2*y**2 - 32*x - 13*y - 23)
+    assert check_solutions(4*x**2 - 4*x*y - 3*y- 8*x - 3)
+    assert check_solutions(- 4*x*y - 4*y**2 - 3*y- 5*x - 10)
+    assert check_solutions(x**2 - y**2 - 2*x - 2*y)
+    assert check_solutions(x**2 - 9*y**2 - 2*x - 6*y)
+    assert check_solutions(4*x**2 - 9*y**2 - 4*x - 12*y - 3)
+
+
+def test_quadratic_non_perfect_square():
+    # B**2 - 4*A*C is not a perfect square
+    # Used check_solutions() since the solutions are complex expressions involving
+    # square roots and exponents
+    assert check_solutions(x**2 - 2*x - 5*y**2)
+    assert check_solutions(3*x**2 - 2*y**2 - 2*x - 2*y)
+    assert check_solutions(x**2 - x*y - y**2 - 3*y)
+    assert check_solutions(x**2 - 9*y**2 - 2*x - 6*y)
+    assert BinaryQuadratic(x**2 + y**2 + 2*x + 2*y + 2).solve() == {(-1, -1)}
+
+
+def test_issue_9106():
+    eq = -48 - 2*x*(3*x - 1) + y*(3*y - 1)
+    v = (x, y)
+    for sol in diophantine(eq):
+        assert not diop_simplify(eq.xreplace(dict(zip(v, sol))))
+
+
+def test_issue_18138():
+    eq = x**2 - x - y**2
+    v = (x, y)
+    for sol in diophantine(eq):
+        assert not diop_simplify(eq.xreplace(dict(zip(v, sol))))
+
+
+@slow
+def test_quadratic_non_perfect_slow():
+    assert check_solutions(8*x**2 + 10*x*y - 2*y**2 - 32*x - 13*y - 23)
+    # This leads to very large numbers.
+    # assert check_solutions(5*x**2 - 13*x*y + y**2 - 4*x - 4*y - 15)
+    assert check_solutions(-3*x**2 - 2*x*y + 7*y**2 - 5*x - 7)
+    assert check_solutions(-4 - x + 4*x**2 - y - 3*x*y - 4*y**2)
+    assert check_solutions(1 + 2*x + 2*x**2 + 2*y + x*y - 2*y**2)
+
+
+def test_DN():
+    # Most of the test cases were adapted from,
+    # Solving the generalized Pell equation x**2 - D*y**2 = N, John P. Robertson, July 31, 2004.
+    # https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+    # others are verified using Wolfram Alpha.
+
+    # Covers cases where D <= 0 or D > 0 and D is a square or N = 0
+    # Solutions are straightforward in these cases.
+    assert diop_DN(3, 0) == [(0, 0)]
+    assert diop_DN(-17, -5) == []
+    assert diop_DN(-19, 23) == [(2, 1)]
+    assert diop_DN(-13, 17) == [(2, 1)]
+    assert diop_DN(-15, 13) == []
+    assert diop_DN(0, 5) == []
+    assert diop_DN(0, 9) == [(3, t)]
+    assert diop_DN(9, 0) == [(3*t, t)]
+    assert diop_DN(16, 24) == []
+    assert diop_DN(9, 180) == [(18, 4)]
+    assert diop_DN(9, -180) == [(12, 6)]
+    assert diop_DN(7, 0) == [(0, 0)]
+
+    # When equation is x**2 + y**2 = N
+    # Solutions are interchangeable
+    assert diop_DN(-1, 5) == [(2, 1), (1, 2)]
+    assert diop_DN(-1, 169) == [(12, 5), (5, 12), (13, 0), (0, 13)]
+
+    # D > 0 and D is not a square
+
+    # N = 1
+    assert diop_DN(13, 1) == [(649, 180)]
+    assert diop_DN(980, 1) == [(51841, 1656)]
+    assert diop_DN(981, 1) == [(158070671986249, 5046808151700)]
+    assert diop_DN(986, 1) == [(49299, 1570)]
+    assert diop_DN(991, 1) == [(379516400906811930638014896080, 12055735790331359447442538767)]
+    assert diop_DN(17, 1) == [(33, 8)]
+    assert diop_DN(19, 1) == [(170, 39)]
+
+    # N = -1
+    assert diop_DN(13, -1) == [(18, 5)]
+    assert diop_DN(991, -1) == []
+    assert diop_DN(41, -1) == [(32, 5)]
+    assert diop_DN(290, -1) == [(17, 1)]
+    assert diop_DN(21257, -1) == [(13913102721304, 95427381109)]
+    assert diop_DN(32, -1) == []
+
+    # |N| > 1
+    # Some tests were created using calculator at
+    # http://www.numbertheory.org/php/patz.html
+
+    assert diop_DN(13, -4) == [(3, 1), (393, 109), (36, 10)]
+    # Source I referred returned (3, 1), (393, 109) and (-3, 1) as fundamental solutions
+    # So (-3, 1) and (393, 109) should be in the same equivalent class
+    assert equivalent(-3, 1, 393, 109, 13, -4) == True
+
+    assert diop_DN(13, 27) == [(220, 61), (40, 11), (768, 213), (12, 3)]
+    assert set(diop_DN(157, 12)) == {(13, 1), (10663, 851), (579160, 46222),
+                                     (483790960, 38610722), (26277068347, 2097138361),
+                                     (21950079635497, 1751807067011)}
+    assert diop_DN(13, 25) == [(3245, 900)]
+    assert diop_DN(192, 18) == []
+    assert diop_DN(23, 13) == [(-6, 1), (6, 1)]
+    assert diop_DN(167, 2) == [(13, 1)]
+    assert diop_DN(167, -2) == []
+
+    assert diop_DN(123, -2) == [(11, 1)]
+    # One calculator returned [(11, 1), (-11, 1)] but both of these are in
+    # the same equivalence class
+    assert equivalent(11, 1, -11, 1, 123, -2)
+
+    assert diop_DN(123, -23) == [(-10, 1), (10, 1)]
+
+    assert diop_DN(0, 0, t) == [(0, t)]
+    assert diop_DN(0, -1, t) == []
+
+
+def test_bf_pell():
+    assert diop_bf_DN(13, -4) == [(3, 1), (-3, 1), (36, 10)]
+    assert diop_bf_DN(13, 27) == [(12, 3), (-12, 3), (40, 11), (-40, 11)]
+    assert diop_bf_DN(167, -2) == []
+    assert diop_bf_DN(1729, 1) == [(44611924489705, 1072885712316)]
+    assert diop_bf_DN(89, -8) == [(9, 1), (-9, 1)]
+    assert diop_bf_DN(21257, -1) == [(13913102721304, 95427381109)]
+    assert diop_bf_DN(340, -4) == [(756, 41)]
+    assert diop_bf_DN(-1, 0, t) == [(0, 0)]
+    assert diop_bf_DN(0, 0, t) == [(0, t)]
+    assert diop_bf_DN(4, 0, t) == [(2*t, t), (-2*t, t)]
+    assert diop_bf_DN(3, 0, t) == [(0, 0)]
+    assert diop_bf_DN(1, -2, t) == []
+
+
+def test_length():
+    assert length(2, 1, 0) == 1
+    assert length(-2, 4, 5) == 3
+    assert length(-5, 4, 17) == 4
+    assert length(0, 4, 13) == 6
+    assert length(7, 13, 11) == 23
+    assert length(1, 6, 4) == 2
+
+
+def is_pell_transformation_ok(eq):
+    """
+    Test whether X*Y, X, or Y terms are present in the equation
+    after transforming the equation using the transformation returned
+    by transformation_to_pell(). If they are not present we are good.
+    Moreover, coefficient of X**2 should be a divisor of coefficient of
+    Y**2 and the constant term.
+    """
+    A, B = transformation_to_DN(eq)
+    u = (A*Matrix([X, Y]) + B)[0]
+    v = (A*Matrix([X, Y]) + B)[1]
+    simplified = diop_simplify(eq.subs(zip((x, y), (u, v))))
+
+    coeff = dict([reversed(t.as_independent(*[X, Y])) for t in simplified.args])
+
+    for term in [X*Y, X, Y]:
+        if term in coeff.keys():
+            return False
+
+    for term in [X**2, Y**2, 1]:
+        if term not in coeff.keys():
+            coeff[term] = 0
+
+    if coeff[X**2] != 0:
+        return divisible(coeff[Y**2], coeff[X**2]) and \
+        divisible(coeff[1], coeff[X**2])
+
+    return True
+
+
+def test_transformation_to_pell():
+    assert is_pell_transformation_ok(-13*x**2 - 7*x*y + y**2 + 2*x - 2*y - 14)
+    assert is_pell_transformation_ok(-17*x**2 + 19*x*y - 7*y**2 - 5*x - 13*y - 23)
+    assert is_pell_transformation_ok(x**2 - y**2 + 17)
+    assert is_pell_transformation_ok(-x**2 + 7*y**2 - 23)
+    assert is_pell_transformation_ok(25*x**2 - 45*x*y + 5*y**2 - 5*x - 10*y + 5)
+    assert is_pell_transformation_ok(190*x**2 + 30*x*y + y**2 - 3*y - 170*x - 130)
+    assert is_pell_transformation_ok(x**2 - 2*x*y -190*y**2 - 7*y - 23*x - 89)
+    assert is_pell_transformation_ok(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950)
+
+
+def test_find_DN():
+    assert find_DN(x**2 - 2*x - y**2) == (1, 1)
+    assert find_DN(x**2 - 3*y**2 - 5) == (3, 5)
+    assert find_DN(x**2 - 2*x*y - 4*y**2 - 7) == (5, 7)
+    assert find_DN(4*x**2 - 8*x*y - y**2 - 9) == (20, 36)
+    assert find_DN(7*x**2 - 2*x*y - y**2 - 12) == (8, 84)
+    assert find_DN(-3*x**2 + 4*x*y -y**2) == (1, 0)
+    assert find_DN(-13*x**2 - 7*x*y + y**2 + 2*x - 2*y -14) == (101, -7825480)
+
+
+def test_ldescent():
+    # Equations which have solutions
+    u = ([(13, 23), (3, -11), (41, -113), (4, -7), (-7, 4), (91, -3), (1, 1), (1, -1),
+        (4, 32), (17, 13), (123689, 1), (19, -570)])
+    for a, b in u:
+        w, x, y = ldescent(a, b)
+        assert a*x**2 + b*y**2 == w**2
+    assert ldescent(-1, -1) is None
+    assert ldescent(2, 6) is None
+
+
+def test_diop_ternary_quadratic_normal():
+    assert check_solutions(234*x**2 - 65601*y**2 - z**2)
+    assert check_solutions(23*x**2 + 616*y**2 - z**2)
+    assert check_solutions(5*x**2 + 4*y**2 - z**2)
+    assert check_solutions(3*x**2 + 6*y**2 - 3*z**2)
+    assert check_solutions(x**2 + 3*y**2 - z**2)
+    assert check_solutions(4*x**2 + 5*y**2 - z**2)
+    assert check_solutions(x**2 + y**2 - z**2)
+    assert check_solutions(16*x**2 + y**2 - 25*z**2)
+    assert check_solutions(6*x**2 - y**2 + 10*z**2)
+    assert check_solutions(213*x**2 + 12*y**2 - 9*z**2)
+    assert check_solutions(34*x**2 - 3*y**2 - 301*z**2)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+
+
+def is_normal_transformation_ok(eq):
+    A = transformation_to_normal(eq)
+    X, Y, Z = A*Matrix([x, y, z])
+    simplified = diop_simplify(eq.subs(zip((x, y, z), (X, Y, Z))))
+
+    coeff = dict([reversed(t.as_independent(*[X, Y, Z])) for t in simplified.args])
+    for term in [X*Y, Y*Z, X*Z]:
+        if term in coeff.keys():
+            return False
+
+    return True
+
+
+def test_transformation_to_normal():
+    assert is_normal_transformation_ok(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z)
+    assert is_normal_transformation_ok(x**2 + 3*y**2 - 100*z**2)
+    assert is_normal_transformation_ok(x**2 + 23*y*z)
+    assert is_normal_transformation_ok(3*y**2 - 100*z**2 - 12*x*y)
+    assert is_normal_transformation_ok(x**2 + 23*x*y - 34*y*z + 12*x*z)
+    assert is_normal_transformation_ok(z**2 + 34*x*y - 23*y*z + x*z)
+    assert is_normal_transformation_ok(x**2 + y**2 + z**2 - x*y - y*z - x*z)
+    assert is_normal_transformation_ok(x**2 + 2*y*z + 3*z**2)
+    assert is_normal_transformation_ok(x*y + 2*x*z + 3*y*z)
+    assert is_normal_transformation_ok(2*x*z + 3*y*z)
+
+
+def test_diop_ternary_quadratic():
+    assert check_solutions(2*x**2 + z**2 + y**2 - 4*x*y)
+    assert check_solutions(x**2 - y**2 - z**2 - x*y - y*z)
+    assert check_solutions(3*x**2 - x*y - y*z - x*z)
+    assert check_solutions(x**2 - y*z - x*z)
+    assert check_solutions(5*x**2 - 3*x*y - x*z)
+    assert check_solutions(4*x**2 - 5*y**2 - x*z)
+    assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z)
+    assert check_solutions(8*x**2 - 12*y*z)
+    assert check_solutions(45*x**2 - 7*y**2 - 8*x*y - z**2)
+    assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y -8*x*y)
+    assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 17*y*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 16*y*z + 12*x*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z)
+    assert check_solutions(x*y - 7*y*z + 13*x*z)
+
+    assert diop_ternary_quadratic_normal(x**2 + y**2 + z**2) == (None, None, None)
+    assert diop_ternary_quadratic_normal(x**2 + y**2) is None
+    raises(ValueError, lambda:
+        _diop_ternary_quadratic_normal((x, y, z),
+        {x*y: 1, x**2: 2, y**2: 3, z**2: 0}))
+    eq = -2*x*y - 6*x*z + 7*y**2 - 3*y*z + 4*z**2
+    assert diop_ternary_quadratic(eq) == (7, 2, 0)
+    assert diop_ternary_quadratic_normal(4*x**2 + 5*y**2 - z**2) == \
+        (1, 0, 2)
+    assert diop_ternary_quadratic(x*y + 2*y*z) == \
+        (-2, 0, n1)
+    eq = -5*x*y - 8*x*z - 3*y*z + 8*z**2
+    assert parametrize_ternary_quadratic(eq) == \
+        (8*p**2 - 3*p*q, -8*p*q + 8*q**2, 5*p*q)
+    # this cannot be tested with diophantine because it will
+    # factor into a product
+    assert diop_solve(x*y + 2*y*z) == (-2*p*q, -n1*p**2 + p**2, p*q)
+
+
+def test_square_factor():
+    assert square_factor(1) == square_factor(-1) == 1
+    assert square_factor(0) == 1
+    assert square_factor(5) == square_factor(-5) == 1
+    assert square_factor(4) == square_factor(-4) == 2
+    assert square_factor(12) == square_factor(-12) == 2
+    assert square_factor(6) == 1
+    assert square_factor(18) == 3
+    assert square_factor(52) == 2
+    assert square_factor(49) == 7
+    assert square_factor(392) == 14
+    assert square_factor(factorint(-12)) == 2
+
+
+def test_parametrize_ternary_quadratic():
+    assert check_solutions(x**2 + y**2 - z**2)
+    assert check_solutions(x**2 + 2*x*y + z**2)
+    assert check_solutions(234*x**2 - 65601*y**2 - z**2)
+    assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z)
+    assert check_solutions(x**2 - y**2 - z**2)
+    assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y - 8*x*y)
+    assert check_solutions(8*x*y + z**2)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+    assert check_solutions(236*x**2 - 225*y**2 - 11*x*y - 13*y*z - 17*x*z)
+    assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+
+
+def test_no_square_ternary_quadratic():
+    assert check_solutions(2*x*y + y*z - 3*x*z)
+    assert check_solutions(189*x*y - 345*y*z - 12*x*z)
+    assert check_solutions(23*x*y + 34*y*z)
+    assert check_solutions(x*y + y*z + z*x)
+    assert check_solutions(23*x*y + 23*y*z + 23*x*z)
+
+
+def test_descent():
+
+    u = ([(13, 23), (3, -11), (41, -113), (91, -3), (1, 1), (1, -1), (17, 13), (123689, 1), (19, -570)])
+    for a, b in u:
+        w, x, y = descent(a, b)
+        assert a*x**2 + b*y**2 == w**2
+    # the docstring warns against bad input, so these are expected results
+    # - can't both be negative
+    raises(TypeError, lambda: descent(-1, -3))
+    # A can't be zero unless B != 1
+    raises(ZeroDivisionError, lambda: descent(0, 3))
+    # supposed to be square-free
+    raises(TypeError, lambda: descent(4, 3))
+
+
+def test_diophantine():
+    assert check_solutions((x - y)*(y - z)*(z - x))
+    assert check_solutions((x - y)*(x**2 + y**2 - z**2))
+    assert check_solutions((x - 3*y + 7*z)*(x**2 + y**2 - z**2))
+    assert check_solutions(x**2 - 3*y**2 - 1)
+    assert check_solutions(y**2 + 7*x*y)
+    assert check_solutions(x**2 - 3*x*y + y**2)
+    assert check_solutions(z*(x**2 - y**2 - 15))
+    assert check_solutions(x*(2*y - 2*z + 5))
+    assert check_solutions((x**2 - 3*y**2 - 1)*(x**2 - y**2 - 15))
+    assert check_solutions((x**2 - 3*y**2 - 1)*(y - 7*z))
+    assert check_solutions((x**2 + y**2 - z**2)*(x - 7*y - 3*z + 4*w))
+    # Following test case caused problems in parametric representation
+    # But this can be solved by factoring out y.
+    # No need to use methods for ternary quadratic equations.
+    assert check_solutions(y**2 - 7*x*y + 4*y*z)
+    assert check_solutions(x**2 - 2*x + 1)
+
+    assert diophantine(x - y) == diophantine(Eq(x, y))
+    # 18196
+    eq = x**4 + y**4 - 97
+    assert diophantine(eq, permute=True) == diophantine(-eq, permute=True)
+    assert diophantine(3*x*pi - 2*y*pi) == {(2*t_0, 3*t_0)}
+    eq = x**2 + y**2 + z**2 - 14
+    base_sol = {(1, 2, 3)}
+    assert diophantine(eq) == base_sol
+    complete_soln = set(signed_permutations(base_sol.pop()))
+    assert diophantine(eq, permute=True) == complete_soln
+
+    assert diophantine(x**2 + x*Rational(15, 14) - 3) == set()
+    # test issue 11049
+    eq = 92*x**2 - 99*y**2 - z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(9, 7, 51)}
+    assert diophantine(eq) == {(
+        891*p**2 + 9*q**2, -693*p**2 - 102*p*q + 7*q**2,
+        5049*p**2 - 1386*p*q - 51*q**2)}
+    eq = 2*x**2 + 2*y**2 - z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(1, 1, 2)}
+    assert diophantine(eq) == {(
+        2*p**2 - q**2, -2*p**2 + 4*p*q - q**2,
+        4*p**2 - 4*p*q + 2*q**2)}
+    eq = 411*x**2+57*y**2-221*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(2021, 2645, 3066)}
+    assert diophantine(eq) == \
+           {(115197*p**2 - 446641*q**2, -150765*p**2 + 1355172*p*q -
+             584545*q**2, 174762*p**2 - 301530*p*q + 677586*q**2)}
+    eq = 573*x**2+267*y**2-984*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(49, 233, 127)}
+    assert diophantine(eq) == \
+           {(4361*p**2 - 16072*q**2, -20737*p**2 + 83312*p*q - 76424*q**2,
+             11303*p**2 - 41474*p*q + 41656*q**2)}
+    # this produces factors during reconstruction
+    eq = x**2 + 3*y**2 - 12*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(0, 2, 1)}
+    assert diophantine(eq) == \
+           {(24*p*q, 2*p**2 - 24*q**2, p**2 + 12*q**2)}
+    # solvers have not been written for every type
+    raises(NotImplementedError, lambda: diophantine(x*y**2 + 1))
+
+    # rational expressions
+    assert diophantine(1/x) == set()
+    assert diophantine(1/x + 1/y - S.Half) == {(6, 3), (-2, 1), (4, 4), (1, -2), (3, 6)}
+    assert diophantine(x**2 + y**2 +3*x- 5, permute=True) == \
+           {(-1, 1), (-4, -1), (1, -1), (1, 1), (-4, 1), (-1, -1), (4, 1), (4, -1)}
+
+
+    #test issue 18186
+    assert diophantine(y**4 + x**4 - 2**4 - 3**4, syms=(x, y), permute=True) == \
+           {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+    assert diophantine(y**4 + x**4 - 2**4 - 3**4, syms=(y, x), permute=True) == \
+           {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+
+    # issue 18122
+    assert check_solutions(x**2 - y)
+    assert check_solutions(y**2 - x)
+    assert diophantine((x**2 - y), t) == {(t, t**2)}
+    assert diophantine((y**2 - x), t) == {(t**2, t)}
+
+
+def test_general_pythagorean():
+    from sympy.abc import a, b, c, d, e
+
+    assert check_solutions(a**2 + b**2 + c**2 - d**2)
+    assert check_solutions(a**2 + 4*b**2 + 4*c**2 - d**2)
+    assert check_solutions(9*a**2 + 4*b**2 + 4*c**2 - d**2)
+    assert check_solutions(9*a**2 + 4*b**2 - 25*d**2 + 4*c**2 )
+    assert check_solutions(9*a**2 - 16*d**2 + 4*b**2 + 4*c**2)
+    assert check_solutions(-e**2 + 9*a**2 + 4*b**2 + 4*c**2 + 25*d**2)
+    assert check_solutions(16*a**2 - b**2 + 9*c**2 + d**2 + 25*e**2)
+
+    assert GeneralPythagorean(a**2 + b**2 + c**2 - d**2).solve(parameters=[x, y, z]) == \
+           {(x**2 + y**2 - z**2, 2*x*z, 2*y*z, x**2 + y**2 + z**2)}
+
+
+def test_diop_general_sum_of_squares_quick():
+    for i in range(3, 10):
+        assert check_solutions(sum(i**2 for i in symbols(':%i' % i)) - i)
+
+    assert diop_general_sum_of_squares(x**2 + y**2 - 2) is None
+    assert diop_general_sum_of_squares(x**2 + y**2 + z**2 + 2) == set()
+    eq = x**2 + y**2 + z**2 - (1 + 4 + 9)
+    assert diop_general_sum_of_squares(eq) == \
+           {(1, 2, 3)}
+    eq = u**2 + v**2 + x**2 + y**2 + z**2 - 1313
+    assert len(diop_general_sum_of_squares(eq, 3)) == 3
+    # issue 11016
+    var = symbols(':5') + (symbols('6', negative=True),)
+    eq = Add(*[i**2 for i in var]) - 112
+
+    base_soln = {(0, 1, 1, 5, 6, -7), (1, 1, 1, 3, 6, -8), (2, 3, 3, 4, 5, -7), (0, 1, 1, 1, 3, -10),
+                 (0, 0, 4, 4, 4, -8), (1, 2, 3, 3, 5, -8), (0, 1, 2, 3, 7, -7), (2, 2, 4, 4, 6, -6),
+                 (1, 1, 3, 4, 6, -7), (0, 2, 3, 3, 3, -9), (0, 0, 2, 2, 2, -10), (1, 1, 2, 3, 4, -9),
+                 (0, 1, 1, 2, 5, -9), (0, 0, 2, 6, 6, -6), (1, 3, 4, 5, 5, -6), (0, 2, 2, 2, 6, -8),
+                 (0, 3, 3, 3, 6, -7), (0, 2, 3, 5, 5, -7), (0, 1, 5, 5, 5, -6)}
+    assert diophantine(eq) == base_soln
+    assert len(diophantine(eq, permute=True)) == 196800
+
+    # handle negated squares with signsimp
+    assert diophantine(12 - x**2 - y**2 - z**2) == {(2, 2, 2)}
+    # diophantine handles simplification, so classify_diop should
+    # not have to look for additional patterns that are removed
+    # by diophantine
+    eq = a**2 + b**2 + c**2 + d**2 - 4
+    raises(NotImplementedError, lambda: classify_diop(-eq))
+
+
+def test_issue_23807():
+    # fixes recursion error
+    eq = x**2 + y**2 + z**2 - 1000000
+    base_soln = {(0, 0, 1000), (0, 352, 936), (480, 600, 640), (24, 640, 768), (192, 640, 744),
+                 (192, 480, 856), (168, 224, 960), (0, 600, 800), (280, 576, 768), (152, 480, 864),
+                 (0, 280, 960), (352, 360, 864), (424, 480, 768), (360, 480, 800), (224, 600, 768),
+                 (96, 360, 928), (168, 576, 800), (96, 480, 872)}
+
+    assert diophantine(eq) == base_soln
+
+
+def test_diop_partition():
+    for n in [8, 10]:
+        for k in range(1, 8):
+            for p in partition(n, k):
+                assert len(p) == k
+    assert list(partition(3, 5)) == []
+    assert [list(p) for p in partition(3, 5, 1)] == [
+        [0, 0, 0, 0, 3], [0, 0, 0, 1, 2], [0, 0, 1, 1, 1]]
+    assert list(partition(0)) == [()]
+    assert list(partition(1, 0)) == [()]
+    assert [list(i) for i in partition(3)] == [[1, 1, 1], [1, 2], [3]]
+
+
+def test_prime_as_sum_of_two_squares():
+    for i in [5, 13, 17, 29, 37, 41, 2341, 3557, 34841, 64601]:
+        a, b = prime_as_sum_of_two_squares(i)
+        assert a**2 + b**2 == i
+    assert prime_as_sum_of_two_squares(7) is None
+    ans = prime_as_sum_of_two_squares(800029)
+    assert ans == (450, 773) and type(ans[0]) is int
+
+
+def test_sum_of_three_squares():
+    for i in [0, 1, 2, 34, 123, 34304595905, 34304595905394941, 343045959052344,
+              800, 801, 802, 803, 804, 805, 806]:
+        a, b, c = sum_of_three_squares(i)
+        assert a**2 + b**2 + c**2 == i
+        assert a >= 0
+
+    # error
+    raises(ValueError, lambda: sum_of_three_squares(-1))
+
+    assert sum_of_three_squares(7) is None
+    assert sum_of_three_squares((4**5)*15) is None
+    # if there are two zeros, there might be a solution
+    # with only one zero, e.g. 25 => (0, 3, 4) or
+    # with no zeros, e.g. 49 => (2, 3, 6)
+    assert sum_of_three_squares(25) == (0, 0, 5)
+    assert sum_of_three_squares(4) == (0, 0, 2)
+
+
+def test_sum_of_four_squares():
+    from sympy.core.random import randint
+
+    # this should never fail
+    n = randint(1, 100000000000000)
+    assert sum(i**2 for i in sum_of_four_squares(n)) == n
+
+    # error
+    raises(ValueError, lambda: sum_of_four_squares(-1))
+
+    for n in range(1000):
+        result = sum_of_four_squares(n)
+        assert len(result) == 4
+        assert all(r >= 0 for r in result)
+        assert sum(r**2 for r in result) == n
+        assert list(result) == sorted(result)
+
+
+def test_power_representation():
+    tests = [(1729, 3, 2), (234, 2, 4), (2, 1, 2), (3, 1, 3), (5, 2, 2), (12352, 2, 4),
+             (32760, 2, 3)]
+
+    for test in tests:
+        n, p, k = test
+        f = power_representation(n, p, k)
+
+        while True:
+            try:
+                l = next(f)
+                assert len(l) == k
+
+                chk_sum = 0
+                for l_i in l:
+                    chk_sum = chk_sum + l_i**p
+                assert chk_sum == n
+
+            except StopIteration:
+                break
+
+    assert list(power_representation(20, 2, 4, True)) == \
+        [(1, 1, 3, 3), (0, 0, 2, 4)]
+    raises(ValueError, lambda: list(power_representation(1.2, 2, 2)))
+    raises(ValueError, lambda: list(power_representation(2, 0, 2)))
+    raises(ValueError, lambda: list(power_representation(2, 2, 0)))
+    assert list(power_representation(-1, 2, 2)) == []
+    assert list(power_representation(1, 1, 1)) == [(1,)]
+    assert list(power_representation(3, 2, 1)) == []
+    assert list(power_representation(4, 2, 1)) == [(2,)]
+    assert list(power_representation(3**4, 4, 6, zeros=True)) == \
+        [(1, 2, 2, 2, 2, 2), (0, 0, 0, 0, 0, 3)]
+    assert list(power_representation(3**4, 4, 5, zeros=False)) == []
+    assert list(power_representation(-2, 3, 2)) == [(-1, -1)]
+    assert list(power_representation(-2, 4, 2)) == []
+    assert list(power_representation(0, 3, 2, True)) == [(0, 0)]
+    assert list(power_representation(0, 3, 2, False)) == []
+    # when we are dealing with squares, do feasibility checks
+    assert len(list(power_representation(4**10*(8*10 + 7), 2, 3))) == 0
+    # there will be a recursion error if these aren't recognized
+    big = 2**30
+    for i in [13, 10, 7, 5, 4, 2, 1]:
+        assert list(sum_of_powers(big, 2, big - i)) == []
+
+
+def test_assumptions():
+    """
+    Test whether diophantine respects the assumptions.
+    """
+    #Test case taken from the below so question regarding assumptions in diophantine module
+    #https://stackoverflow.com/questions/23301941/how-can-i-declare-natural-symbols-with-sympy
+    m, n = symbols('m n', integer=True, positive=True)
+    diof = diophantine(n**2 + m*n - 500)
+    assert diof == {(5, 20), (40, 10), (95, 5), (121, 4), (248, 2), (499, 1)}
+
+    a, b = symbols('a b', integer=True, positive=False)
+    diof = diophantine(a*b + 2*a + 3*b - 6)
+    assert diof == {(-15, -3), (-9, -4), (-7, -5), (-6, -6), (-5, -8), (-4, -14)}
+
+
+def check_solutions(eq):
+    """
+    Determines whether solutions returned by diophantine() satisfy the original
+    equation. Hope to generalize this so we can remove functions like check_ternay_quadratic,
+    check_solutions_normal, check_solutions()
+    """
+    s = diophantine(eq)
+
+    factors = Mul.make_args(eq)
+
+    var = list(eq.free_symbols)
+    var.sort(key=default_sort_key)
+
+    while s:
+        solution = s.pop()
+        for f in factors:
+            if diop_simplify(f.subs(zip(var, solution))) == 0:
+                break
+        else:
+            return False
+    return True
+
+
+def test_diopcoverage():
+    eq = (2*x + y + 1)**2
+    assert diop_solve(eq) == {(t_0, -2*t_0 - 1)}
+    eq = 2*x**2 + 6*x*y + 12*x + 4*y**2 + 18*y + 18
+    assert diop_solve(eq) == {(t, -t - 3), (-2*t - 3, t)}
+    assert diop_quadratic(x + y**2 - 3) == {(-t**2 + 3, t)}
+
+    assert diop_linear(x + y - 3) == (t_0, 3 - t_0)
+
+    assert base_solution_linear(0, 1, 2, t=None) == (0, 0)
+    ans = (3*t - 1, -2*t + 1)
+    assert base_solution_linear(4, 8, 12, t) == ans
+    assert base_solution_linear(4, 8, 12, t=None) == tuple(_.subs(t, 0) for _ in ans)
+
+    assert cornacchia(1, 1, 20) == set()
+    assert cornacchia(1, 1, 5) == {(2, 1)}
+    assert cornacchia(1, 2, 17) == {(3, 2)}
+
+    raises(ValueError, lambda: reconstruct(4, 20, 1))
+
+    assert gaussian_reduce(4, 1, 3) == (1, 1)
+    eq = -w**2 - x**2 - y**2 + z**2
+
+    assert diop_general_pythagorean(eq) == \
+        diop_general_pythagorean(-eq) == \
+            (m1**2 + m2**2 - m3**2, 2*m1*m3,
+            2*m2*m3, m1**2 + m2**2 + m3**2)
+
+    assert len(check_param(S(3) + x/3, S(4) + x/2, S(2), [x])) == 0
+    assert len(check_param(Rational(3, 2), S(4) + x, S(2), [x])) == 0
+    assert len(check_param(S(4) + x, Rational(3, 2), S(2), [x])) == 0
+
+    assert _nint_or_floor(16, 10) == 2
+    assert _odd(1) == (not _even(1)) == True
+    assert _odd(0) == (not _even(0)) == False
+    assert _remove_gcd(2, 4, 6) == (1, 2, 3)
+    raises(TypeError, lambda: _remove_gcd((2, 4, 6)))
+    assert sqf_normal(2*3**2*5, 2*5*11, 2*7**2*11)  == \
+        (11, 1, 5)
+
+    # it's ok if these pass some day when the solvers are implemented
+    raises(NotImplementedError, lambda: diophantine(x**2 + y**2 + x*y + 2*y*z - 12))
+    raises(NotImplementedError, lambda: diophantine(x**3 + y**2))
+    assert diop_quadratic(x**2 + y**2 - 1**2 - 3**4) == \
+           {(-9, -1), (-9, 1), (-1, -9), (-1, 9), (1, -9), (1, 9), (9, -1), (9, 1)}
+
+
+def test_holzer():
+    # if the input is good, don't let it diverge in holzer()
+    # (but see test_fail_holzer below)
+    assert holzer(2, 7, 13, 4, 79, 23) == (2, 7, 13)
+
+    # None in uv condition met; solution is not Holzer reduced
+    # so this will hopefully change but is here for coverage
+    assert holzer(2, 6, 2, 1, 1, 10) == (2, 6, 2)
+
+    raises(ValueError, lambda: holzer(2, 7, 14, 4, 79, 23))
+
+
+@XFAIL
+def test_fail_holzer():
+    eq = lambda x, y, z: a*x**2 + b*y**2 - c*z**2
+    a, b, c = 4, 79, 23
+    x, y, z = xyz = 26, 1, 11
+    X, Y, Z = ans = 2, 7, 13
+    assert eq(*xyz) == 0
+    assert eq(*ans) == 0
+    assert max(a*x**2, b*y**2, c*z**2) <= a*b*c
+    assert max(a*X**2, b*Y**2, c*Z**2) <= a*b*c
+    h = holzer(x, y, z, a, b, c)
+    assert h == ans  # it would be nice to get the smaller soln
+
+
+def test_issue_9539():
+    assert diophantine(6*w + 9*y + 20*x - z) == \
+           {(t_0, t_1, t_1 + t_2, 6*t_0 + 29*t_1 + 9*t_2)}
+
+
+def test_issue_8943():
+    assert diophantine(
+        3*(x**2 + y**2 + z**2) - 14*(x*y + y*z + z*x)) == \
+           {(0, 0, 0)}
+
+
+def test_diop_sum_of_even_powers():
+    eq = x**4 + y**4 + z**4 - 2673
+    assert diop_solve(eq) == {(3, 6, 6), (2, 4, 7)}
+    assert diop_general_sum_of_even_powers(eq, 2) == {(3, 6, 6), (2, 4, 7)}
+    raises(NotImplementedError, lambda: diop_general_sum_of_even_powers(-eq, 2))
+    neg = symbols('neg', negative=True)
+    eq = x**4 + y**4 + neg**4 - 2673
+    assert diop_general_sum_of_even_powers(eq) == {(-3, 6, 6)}
+    assert diophantine(x**4 + y**4 + 2) == set()
+    assert diop_general_sum_of_even_powers(x**4 + y**4 - 2, limit=0) == set()
+
+
+def test_sum_of_squares_powers():
+    tru = {(0, 0, 1, 1, 11), (0, 0, 5, 7, 7), (0, 1, 3, 7, 8), (0, 1, 4, 5, 9), (0, 3, 4, 7, 7), (0, 3, 5, 5, 8),
+           (1, 1, 2, 6, 9), (1, 1, 6, 6, 7), (1, 2, 3, 3, 10), (1, 3, 4, 4, 9), (1, 5, 5, 6, 6), (2, 2, 3, 5, 9),
+           (2, 3, 5, 6, 7), (3, 3, 4, 5, 8)}
+    eq = u**2 + v**2 + x**2 + y**2 + z**2 - 123
+    ans = diop_general_sum_of_squares(eq, oo)  # allow oo to be used
+    assert len(ans) == 14
+    assert ans == tru
+
+    raises(ValueError, lambda: list(sum_of_squares(10, -1)))
+    assert list(sum_of_squares(1, 1)) == [(1,)]
+    assert list(sum_of_squares(1, 2)) == []
+    assert list(sum_of_squares(1, 2, True)) == [(0, 1)]
+    assert list(sum_of_squares(-10, 2)) == []
+    assert list(sum_of_squares(2, 3)) == []
+    assert list(sum_of_squares(0, 3, True)) == [(0, 0, 0)]
+    assert list(sum_of_squares(0, 3)) == []
+    assert list(sum_of_squares(4, 1)) == [(2,)]
+    assert list(sum_of_squares(5, 1)) == []
+    assert list(sum_of_squares(50, 2)) == [(5, 5), (1, 7)]
+    assert list(sum_of_squares(11, 5, True)) == [
+        (1, 1, 1, 2, 2), (0, 0, 1, 1, 3)]
+    assert list(sum_of_squares(8, 8)) == [(1, 1, 1, 1, 1, 1, 1, 1)]
+
+    assert [len(list(sum_of_squares(i, 5, True))) for i in range(30)] == [
+        1, 1, 1, 1, 2,
+        2, 1, 1, 2, 2,
+        2, 2, 2, 3, 2,
+        1, 3, 3, 3, 3,
+        4, 3, 3, 2, 2,
+        4, 4, 4, 4, 5]
+    assert [len(list(sum_of_squares(i, 5))) for i in range(30)] == [
+        0, 0, 0, 0, 0,
+        1, 0, 0, 1, 0,
+        0, 1, 0, 1, 1,
+        0, 1, 1, 0, 1,
+        2, 1, 1, 1, 1,
+        1, 1, 1, 1, 3]
+    for i in range(30):
+        s1 = set(sum_of_squares(i, 5, True))
+        assert not s1 or all(sum(j**2 for j in t) == i for t in s1)
+        s2 = set(sum_of_squares(i, 5))
+        assert all(sum(j**2 for j in t) == i for t in s2)
+
+    raises(ValueError, lambda: list(sum_of_powers(2, -1, 1)))
+    raises(ValueError, lambda: list(sum_of_powers(2, 1, -1)))
+    assert list(sum_of_powers(-2, 3, 2)) == [(-1, -1)]
+    assert list(sum_of_powers(-2, 4, 2)) == []
+    assert list(sum_of_powers(2, 1, 1)) == [(2,)]
+    assert list(sum_of_powers(2, 1, 3, True)) == [(0, 0, 2), (0, 1, 1)]
+    assert list(sum_of_powers(5, 1, 2, True)) == [(0, 5), (1, 4), (2, 3)]
+    assert list(sum_of_powers(6, 2, 2)) == []
+    assert list(sum_of_powers(3**5, 3, 1)) == []
+    assert list(sum_of_powers(3**6, 3, 1)) == [(9,)] and (9**3 == 3**6)
+    assert list(sum_of_powers(2**1000, 5, 2)) == []
+
+
+def test__can_do_sum_of_squares():
+    assert _can_do_sum_of_squares(3, -1) is False
+    assert _can_do_sum_of_squares(-3, 1) is False
+    assert _can_do_sum_of_squares(0, 1)
+    assert _can_do_sum_of_squares(4, 1)
+    assert _can_do_sum_of_squares(1, 2)
+    assert _can_do_sum_of_squares(2, 2)
+    assert _can_do_sum_of_squares(3, 2) is False
+
+
+def test_diophantine_permute_sign():
+    from sympy.abc import a, b, c, d, e
+    eq = a**4 + b**4 - (2**4 + 3**4)
+    base_sol = {(2, 3)}
+    assert diophantine(eq) == base_sol
+    complete_soln = set(signed_permutations(base_sol.pop()))
+    assert diophantine(eq, permute=True) == complete_soln
+
+    eq = a**2 + b**2 + c**2 + d**2 + e**2 - 234
+    assert len(diophantine(eq)) == 35
+    assert len(diophantine(eq, permute=True)) == 62000
+    soln = {(-1, -1), (-1, 2), (1, -2), (1, 1)}
+    assert diophantine(10*x**2 + 12*x*y + 12*y**2 - 34, permute=True) == soln
+
+
+@XFAIL
+def test_not_implemented():
+    eq = x**2 + y**4 - 1**2 - 3**4
+    assert diophantine(eq, syms=[x, y]) == {(9, 1), (1, 3)}
+
+
+def test_issue_9538():
+    eq = x - 3*y + 2
+    assert diophantine(eq, syms=[y,x]) == {(t_0, 3*t_0 - 2)}
+    raises(TypeError, lambda: diophantine(eq, syms={y, x}))
+
+
+def test_ternary_quadratic():
+    # solution with 3 parameters
+    s = diophantine(2*x**2 + y**2 - 2*z**2)
+    p, q, r = ordered(S(s).free_symbols)
+    assert s == {(
+        p**2 - 2*q**2,
+        -2*p**2 + 4*p*q - 4*p*r - 4*q**2,
+        p**2 - 4*p*q + 2*q**2 - 4*q*r)}
+    # solution with Mul in solution
+    s = diophantine(x**2 + 2*y**2 - 2*z**2)
+    assert s == {(4*p*q, p**2 - 2*q**2, p**2 + 2*q**2)}
+    # solution with no Mul in solution
+    s = diophantine(2*x**2 + 2*y**2 - z**2)
+    assert s == {(2*p**2 - q**2, -2*p**2 + 4*p*q - q**2,
+        4*p**2 - 4*p*q + 2*q**2)}
+    # reduced form when parametrized
+    s = diophantine(3*x**2 + 72*y**2 - 27*z**2)
+    assert s == {(24*p**2 - 9*q**2, 6*p*q, 8*p**2 + 3*q**2)}
+    assert parametrize_ternary_quadratic(
+        3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z) == (
+        2*p**2 - 2*p*q - q**2, 2*p**2 + 2*p*q - q**2, 2*p**2 -
+        2*p*q + 3*q**2)
+    assert parametrize_ternary_quadratic(
+        124*x**2 - 30*y**2 - 7729*z**2) == (
+        -1410*p**2 - 363263*q**2, 2700*p**2 + 30916*p*q -
+        695610*q**2, -60*p**2 + 5400*p*q + 15458*q**2)
+
+
+def test_diophantine_solution_set():
+    s1 = DiophantineSolutionSet([], [])
+    assert set(s1) == set()
+    assert s1.symbols == ()
+    assert s1.parameters == ()
+    raises(ValueError, lambda: s1.add((x,)))
+    assert list(s1.dict_iterator()) == []
+
+    s2 = DiophantineSolutionSet([x, y], [t, u])
+    assert s2.symbols == (x, y)
+    assert s2.parameters == (t, u)
+    raises(ValueError, lambda: s2.add((1,)))
+    s2.add((3, 4))
+    assert set(s2) == {(3, 4)}
+    s2.update((3, 4), (-1, u))
+    assert set(s2) == {(3, 4), (-1, u)}
+    raises(ValueError, lambda: s1.update(s2))
+    assert list(s2.dict_iterator()) == [{x: -1, y: u}, {x: 3, y: 4}]
+
+    s3 = DiophantineSolutionSet([x, y, z], [t, u])
+    assert len(s3.parameters) == 2
+    s3.add((t**2 + u, t - u, 1))
+    assert set(s3) == {(t**2 + u, t - u, 1)}
+    assert s3.subs(t, 2) == {(u + 4, 2 - u, 1)}
+    assert s3(2) == {(u + 4, 2 - u, 1)}
+    assert s3.subs({t: 7, u: 8}) == {(57, -1, 1)}
+    assert s3(7, 8) == {(57, -1, 1)}
+    assert s3.subs({t: 5}) == {(u + 25, 5 - u, 1)}
+    assert s3(5) == {(u + 25, 5 - u, 1)}
+    assert s3.subs(u, -3) == {(t**2 - 3, t + 3, 1)}
+    assert s3(None, -3) == {(t**2 - 3, t + 3, 1)}
+    assert s3.subs({t: 2, u: 8}) == {(12, -6, 1)}
+    assert s3(2, 8) == {(12, -6, 1)}
+    assert s3.subs({t: 5, u: -3}) == {(22, 8, 1)}
+    assert s3(5, -3) == {(22, 8, 1)}
+    raises(ValueError, lambda: s3.subs(x=1))
+    raises(ValueError, lambda: s3.subs(1, 2, 3))
+    raises(ValueError, lambda: s3.add(()))
+    raises(ValueError, lambda: s3.add((1, 2, 3, 4)))
+    raises(ValueError, lambda: s3.add((1, 2)))
+    raises(ValueError, lambda: s3(1, 2, 3))
+    raises(TypeError, lambda: s3(t=1))
+
+    s4 = DiophantineSolutionSet([x, y], [t, u])
+    s4.add((t, 11*t))
+    s4.add((-t, 22*t))
+    assert s4(0, 0) == {(0, 0)}
+
+
+def test_quadratic_parameter_passing():
+    eq = -33*x*y + 3*y**2
+    solution = BinaryQuadratic(eq).solve(parameters=[t, u])
+    # test that parameters are passed all the way to the final solution
+    assert solution == {(t, 11*t), (t, -22*t)}
+    assert solution(0, 0) == {(0, 0)}

pllava/lib/python3.10/site-packages/sympy/solvers/inequalities.py

@@ -0,0 +1,986 @@
+"""Tools for solving inequalities and systems of inequalities. """
+import itertools
+
+from sympy.calculus.util import (continuous_domain, periodicity,
+    function_range)
+from sympy.core import sympify
+from sympy.core.exprtools import factor_terms
+from sympy.core.relational import Relational, Lt, Ge, Eq
+from sympy.core.symbol import Symbol, Dummy
+from sympy.sets.sets import Interval, FiniteSet, Union, Intersection
+from sympy.core.singleton import S
+from sympy.core.function import expand_mul
+from sympy.functions.elementary.complexes import Abs
+from sympy.logic import And
+from sympy.polys import Poly, PolynomialError, parallel_poly_from_expr
+from sympy.polys.polyutils import _nsort
+from sympy.solvers.solveset import solvify, solveset
+from sympy.utilities.iterables import sift, iterable
+from sympy.utilities.misc import filldedent
+
+
+def solve_poly_inequality(poly, rel):
+    """Solve a polynomial inequality with rational coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy import solve_poly_inequality, Poly
+    >>> from sympy.abc import x
+
+    >>> solve_poly_inequality(Poly(x, x, domain='ZZ'), '==')
+    [{0}]
+
+    >>> solve_poly_inequality(Poly(x**2 - 1, x, domain='ZZ'), '!=')
+    [Interval.open(-oo, -1), Interval.open(-1, 1), Interval.open(1, oo)]
+
+    >>> solve_poly_inequality(Poly(x**2 - 1, x, domain='ZZ'), '==')
+    [{-1}, {1}]
+
+    See Also
+    ========
+    solve_poly_inequalities
+    """
+    if not isinstance(poly, Poly):
+        raise ValueError(
+            'For efficiency reasons, `poly` should be a Poly instance')
+    if poly.as_expr().is_number:
+        t = Relational(poly.as_expr(), 0, rel)
+        if t is S.true:
+            return [S.Reals]
+        elif t is S.false:
+            return [S.EmptySet]
+        else:
+            raise NotImplementedError(
+                "could not determine truth value of %s" % t)
+
+    reals, intervals = poly.real_roots(multiple=False), []
+
+    if rel == '==':
+        for root, _ in reals:
+            interval = Interval(root, root)
+            intervals.append(interval)
+    elif rel == '!=':
+        left = S.NegativeInfinity
+
+        for right, _ in reals + [(S.Infinity, 1)]:
+            interval = Interval(left, right, True, True)
+            intervals.append(interval)
+            left = right
+    else:
+        if poly.LC() > 0:
+            sign = +1
+        else:
+            sign = -1
+
+        eq_sign, equal = None, False
+
+        if rel == '>':
+            eq_sign = +1
+        elif rel == '<':
+            eq_sign = -1
+        elif rel == '>=':
+            eq_sign, equal = +1, True
+        elif rel == '<=':
+            eq_sign, equal = -1, True
+        else:
+            raise ValueError("'%s' is not a valid relation" % rel)
+
+        right, right_open = S.Infinity, True
+
+        for left, multiplicity in reversed(reals):
+            if multiplicity % 2:
+                if sign == eq_sign:
+                    intervals.insert(
+                        0, Interval(left, right, not equal, right_open))
+
+                sign, right, right_open = -sign, left, not equal
+            else:
+                if sign == eq_sign and not equal:
+                    intervals.insert(
+                        0, Interval(left, right, True, right_open))
+                    right, right_open = left, True
+                elif sign != eq_sign and equal:
+                    intervals.insert(0, Interval(left, left))
+
+        if sign == eq_sign:
+            intervals.insert(
+                0, Interval(S.NegativeInfinity, right, True, right_open))
+
+    return intervals
+
+
+def solve_poly_inequalities(polys):
+    """Solve polynomial inequalities with rational coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy import Poly
+    >>> from sympy.solvers.inequalities import solve_poly_inequalities
+    >>> from sympy.abc import x
+    >>> solve_poly_inequalities(((
+    ... Poly(x**2 - 3), ">"), (
+    ... Poly(-x**2 + 1), ">")))
+    Union(Interval.open(-oo, -sqrt(3)), Interval.open(-1, 1), Interval.open(sqrt(3), oo))
+    """
+    return Union(*[s for p in polys for s in solve_poly_inequality(*p)])
+
+
+def solve_rational_inequalities(eqs):
+    """Solve a system of rational inequalities with rational coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy import solve_rational_inequalities, Poly
+
+    >>> solve_rational_inequalities([[
+    ... ((Poly(-x + 1), Poly(1, x)), '>='),
+    ... ((Poly(-x + 1), Poly(1, x)), '<=')]])
+    {1}
+
+    >>> solve_rational_inequalities([[
+    ... ((Poly(x), Poly(1, x)), '!='),
+    ... ((Poly(-x + 1), Poly(1, x)), '>=')]])
+    Union(Interval.open(-oo, 0), Interval.Lopen(0, 1))
+
+    See Also
+    ========
+    solve_poly_inequality
+    """
+    result = S.EmptySet
+
+    for _eqs in eqs:
+        if not _eqs:
+            continue
+
+        global_intervals = [Interval(S.NegativeInfinity, S.Infinity)]
+
+        for (numer, denom), rel in _eqs:
+            numer_intervals = solve_poly_inequality(numer*denom, rel)
+            denom_intervals = solve_poly_inequality(denom, '==')
+
+            intervals = []
+
+            for numer_interval, global_interval in itertools.product(
+                    numer_intervals, global_intervals):
+                interval = numer_interval.intersect(global_interval)
+
+                if interval is not S.EmptySet:
+                    intervals.append(interval)
+
+            global_intervals = intervals
+
+            intervals = []
+
+            for global_interval in global_intervals:
+                for denom_interval in denom_intervals:
+                    global_interval -= denom_interval
+
+                if global_interval is not S.EmptySet:
+                    intervals.append(global_interval)
+
+            global_intervals = intervals
+
+            if not global_intervals:
+                break
+
+        for interval in global_intervals:
+            result = result.union(interval)
+
+    return result
+
+
+def reduce_rational_inequalities(exprs, gen, relational=True):
+    """Reduce a system of rational inequalities with rational coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.solvers.inequalities import reduce_rational_inequalities
+
+    >>> x = Symbol('x', real=True)
+
+    >>> reduce_rational_inequalities([[x**2 <= 0]], x)
+    Eq(x, 0)
+
+    >>> reduce_rational_inequalities([[x + 2 > 0]], x)
+    -2 < x
+    >>> reduce_rational_inequalities([[(x + 2, ">")]], x)
+    -2 < x
+    >>> reduce_rational_inequalities([[x + 2]], x)
+    Eq(x, -2)
+
+    This function find the non-infinite solution set so if the unknown symbol
+    is declared as extended real rather than real then the result may include
+    finiteness conditions:
+
+    >>> y = Symbol('y', extended_real=True)
+    >>> reduce_rational_inequalities([[y + 2 > 0]], y)
+    (-2 < y) & (y < oo)
+    """
+    exact = True
+    eqs = []
+    solution = S.EmptySet  # add pieces for each group
+    for _exprs in exprs:
+        if not _exprs:
+            continue
+        _eqs = []
+        _sol = S.Reals
+        for expr in _exprs:
+            if isinstance(expr, tuple):
+                expr, rel = expr
+            else:
+                if expr.is_Relational:
+                    expr, rel = expr.lhs - expr.rhs, expr.rel_op
+                else:
+                    expr, rel = expr, '=='
+
+            if expr is S.true:
+                numer, denom, rel = S.Zero, S.One, '=='
+            elif expr is S.false:
+                numer, denom, rel = S.One, S.One, '=='
+            else:
+                numer, denom = expr.together().as_numer_denom()
+
+            try:
+                (numer, denom), opt = parallel_poly_from_expr(
+                    (numer, denom), gen)
+            except PolynomialError:
+                raise PolynomialError(filldedent('''
+                    only polynomials and rational functions are
+                    supported in this context.
+                    '''))
+
+            if not opt.domain.is_Exact:
+                numer, denom, exact = numer.to_exact(), denom.to_exact(), False
+
+            domain = opt.domain.get_exact()
+
+            if not (domain.is_ZZ or domain.is_QQ):
+                expr = numer/denom
+                expr = Relational(expr, 0, rel)
+                _sol &= solve_univariate_inequality(expr, gen, relational=False)
+            else:
+                _eqs.append(((numer, denom), rel))
+
+        if _eqs:
+            _sol &= solve_rational_inequalities([_eqs])
+            exclude = solve_rational_inequalities([[((d, d.one), '==')
+                for i in eqs for ((n, d), _) in i if d.has(gen)]])
+            _sol -= exclude
+
+        solution |= _sol
+
+    if not exact and solution:
+        solution = solution.evalf()
+
+    if relational:
+        solution = solution.as_relational(gen)
+
+    return solution
+
+
+def reduce_abs_inequality(expr, rel, gen):
+    """Reduce an inequality with nested absolute values.
+
+    Examples
+    ========
+
+    >>> from sympy import reduce_abs_inequality, Abs, Symbol
+    >>> x = Symbol('x', real=True)
+
+    >>> reduce_abs_inequality(Abs(x - 5) - 3, '<', x)
+    (2 < x) & (x < 8)
+
+    >>> reduce_abs_inequality(Abs(x + 2)*3 - 13, '<', x)
+    (-19/3 < x) & (x < 7/3)
+
+    See Also
+    ========
+
+    reduce_abs_inequalities
+    """
+    if gen.is_extended_real is False:
+         raise TypeError(filldedent('''
+            Cannot solve inequalities with absolute values containing
+            non-real variables.
+            '''))
+
+    def _bottom_up_scan(expr):
+        exprs = []
+
+        if expr.is_Add or expr.is_Mul:
+            op = expr.func
+
+            for arg in expr.args:
+                _exprs = _bottom_up_scan(arg)
+
+                if not exprs:
+                    exprs = _exprs
+                else:
+                    exprs = [(op(expr, _expr), conds + _conds) for (expr, conds), (_expr, _conds) in
+                            itertools.product(exprs, _exprs)]
+        elif expr.is_Pow:
+            n = expr.exp
+            if not n.is_Integer:
+                raise ValueError("Only Integer Powers are allowed on Abs.")
+
+            exprs.extend((expr**n, conds) for expr, conds in _bottom_up_scan(expr.base))
+        elif isinstance(expr, Abs):
+            _exprs = _bottom_up_scan(expr.args[0])
+
+            for expr, conds in _exprs:
+                exprs.append(( expr, conds + [Ge(expr, 0)]))
+                exprs.append((-expr, conds + [Lt(expr, 0)]))
+        else:
+            exprs = [(expr, [])]
+
+        return exprs
+
+    mapping = {'<': '>', '<=': '>='}
+    inequalities = []
+
+    for expr, conds in _bottom_up_scan(expr):
+        if rel not in mapping.keys():
+            expr = Relational( expr, 0, rel)
+        else:
+            expr = Relational(-expr, 0, mapping[rel])
+
+        inequalities.append([expr] + conds)
+
+    return reduce_rational_inequalities(inequalities, gen)
+
+
+def reduce_abs_inequalities(exprs, gen):
+    """Reduce a system of inequalities with nested absolute values.
+
+    Examples
+    ========
+
+    >>> from sympy import reduce_abs_inequalities, Abs, Symbol
+    >>> x = Symbol('x', extended_real=True)
+
+    >>> reduce_abs_inequalities([(Abs(3*x - 5) - 7, '<'),
+    ... (Abs(x + 25) - 13, '>')], x)
+    (-2/3 < x) & (x < 4) & (((-oo < x) & (x < -38)) | ((-12 < x) & (x < oo)))
+
+    >>> reduce_abs_inequalities([(Abs(x - 4) + Abs(3*x - 5) - 7, '<')], x)
+    (1/2 < x) & (x < 4)
+
+    See Also
+    ========
+
+    reduce_abs_inequality
+    """
+    return And(*[ reduce_abs_inequality(expr, rel, gen)
+        for expr, rel in exprs ])
+
+
+def solve_univariate_inequality(expr, gen, relational=True, domain=S.Reals, continuous=False):
+    """Solves a real univariate inequality.
+
+    Parameters
+    ==========
+
+    expr : Relational
+        The target inequality
+    gen : Symbol
+        The variable for which the inequality is solved
+    relational : bool
+        A Relational type output is expected or not
+    domain : Set
+        The domain over which the equation is solved
+    continuous: bool
+        True if expr is known to be continuous over the given domain
+        (and so continuous_domain() does not need to be called on it)
+
+    Raises
+    ======
+
+    NotImplementedError
+        The solution of the inequality cannot be determined due to limitation
+        in :func:`sympy.solvers.solveset.solvify`.
+
+    Notes
+    =====
+
+    Currently, we cannot solve all the inequalities due to limitations in
+    :func:`sympy.solvers.solveset.solvify`. Also, the solution returned for trigonometric inequalities
+    are restricted in its periodic interval.
+
+    See Also
+    ========
+
+    sympy.solvers.solveset.solvify: solver returning solveset solutions with solve's output API
+
+    Examples
+    ========
+
+    >>> from sympy import solve_univariate_inequality, Symbol, sin, Interval, S
+    >>> x = Symbol('x')
+
+    >>> solve_univariate_inequality(x**2 >= 4, x)
+    ((2 <= x) & (x < oo)) | ((-oo < x) & (x <= -2))
+
+    >>> solve_univariate_inequality(x**2 >= 4, x, relational=False)
+    Union(Interval(-oo, -2), Interval(2, oo))
+
+    >>> domain = Interval(0, S.Infinity)
+    >>> solve_univariate_inequality(x**2 >= 4, x, False, domain)
+    Interval(2, oo)
+
+    >>> solve_univariate_inequality(sin(x) > 0, x, relational=False)
+    Interval.open(0, pi)
+
+    """
+    from sympy.solvers.solvers import denoms
+
+    if domain.is_subset(S.Reals) is False:
+        raise NotImplementedError(filldedent('''
+        Inequalities in the complex domain are
+        not supported. Try the real domain by
+        setting domain=S.Reals'''))
+    elif domain is not S.Reals:
+        rv = solve_univariate_inequality(
+        expr, gen, relational=False, continuous=continuous).intersection(domain)
+        if relational:
+            rv = rv.as_relational(gen)
+        return rv
+    else:
+        pass  # continue with attempt to solve in Real domain
+
+    # This keeps the function independent of the assumptions about `gen`.
+    # `solveset` makes sure this function is called only when the domain is
+    # real.
+    _gen = gen
+    _domain = domain
+    if gen.is_extended_real is False:
+        rv = S.EmptySet
+        return rv if not relational else rv.as_relational(_gen)
+    elif gen.is_extended_real is None:
+        gen = Dummy('gen', extended_real=True)
+        try:
+            expr = expr.xreplace({_gen: gen})
+        except TypeError:
+            raise TypeError(filldedent('''
+                When gen is real, the relational has a complex part
+                which leads to an invalid comparison like I < 0.
+                '''))
+
+    rv = None
+
+    if expr is S.true:
+        rv = domain
+
+    elif expr is S.false:
+        rv = S.EmptySet
+
+    else:
+        e = expr.lhs - expr.rhs
+        period = periodicity(e, gen)
+        if period == S.Zero:
+            e = expand_mul(e)
+            const = expr.func(e, 0)
+            if const is S.true:
+                rv = domain
+            elif const is S.false:
+                rv = S.EmptySet
+        elif period is not None:
+            frange = function_range(e, gen, domain)
+
+            rel = expr.rel_op
+            if rel in ('<', '<='):
+                if expr.func(frange.sup, 0):
+                    rv = domain
+                elif not expr.func(frange.inf, 0):
+                    rv = S.EmptySet
+
+            elif rel in ('>', '>='):
+                if expr.func(frange.inf, 0):
+                    rv = domain
+                elif not expr.func(frange.sup, 0):
+                    rv = S.EmptySet
+
+            inf, sup = domain.inf, domain.sup
+            if sup - inf is S.Infinity:
+                domain = Interval(0, period, False, True).intersect(_domain)
+                _domain = domain
+
+        if rv is None:
+            n, d = e.as_numer_denom()
+            try:
+                if gen not in n.free_symbols and len(e.free_symbols) > 1:
+                    raise ValueError
+                # this might raise ValueError on its own
+                # or it might give None...
+                solns = solvify(e, gen, domain)
+                if solns is None:
+                    # in which case we raise ValueError
+                    raise ValueError
+            except (ValueError, NotImplementedError):
+                # replace gen with generic x since it's
+                # univariate anyway
+                raise NotImplementedError(filldedent('''
+                    The inequality, %s, cannot be solved using
+                    solve_univariate_inequality.
+                    ''' % expr.subs(gen, Symbol('x'))))
+
+            expanded_e = expand_mul(e)
+            def valid(x):
+                # this is used to see if gen=x satisfies the
+                # relational by substituting it into the
+                # expanded form and testing against 0, e.g.
+                # if expr = x*(x + 1) < 2 then e = x*(x + 1) - 2
+                # and expanded_e = x**2 + x - 2; the test is
+                # whether a given value of x satisfies
+                # x**2 + x - 2 < 0
+                #
+                # expanded_e, expr and gen used from enclosing scope
+                v = expanded_e.subs(gen, expand_mul(x))
+                try:
+                    r = expr.func(v, 0)
+                except TypeError:
+                    r = S.false
+                if r in (S.true, S.false):
+                    return r
+                if v.is_extended_real is False:
+                    return S.false
+                else:
+                    v = v.n(2)
+                    if v.is_comparable:
+                        return expr.func(v, 0)
+                    # not comparable or couldn't be evaluated
+                    raise NotImplementedError(
+                        'relationship did not evaluate: %s' % r)
+
+            singularities = []
+            for d in denoms(expr, gen):
+                singularities.extend(solvify(d, gen, domain))
+            if not continuous:
+                domain = continuous_domain(expanded_e, gen, domain)
+
+            include_x = '=' in expr.rel_op and expr.rel_op != '!='
+
+            try:
+                discontinuities = set(domain.boundary -
+                    FiniteSet(domain.inf, domain.sup))
+                # remove points that are not between inf and sup of domain
+                critical_points = FiniteSet(*(solns + singularities + list(
+                    discontinuities))).intersection(
+                    Interval(domain.inf, domain.sup,
+                    domain.inf not in domain, domain.sup not in domain))
+                if all(r.is_number for r in critical_points):
+                    reals = _nsort(critical_points, separated=True)[0]
+                else:
+                    sifted = sift(critical_points, lambda x: x.is_extended_real)
+                    if sifted[None]:
+                        # there were some roots that weren't known
+                        # to be real
+                        raise NotImplementedError
+                    try:
+                        reals = sifted[True]
+                        if len(reals) > 1:
+                            reals = sorted(reals)
+                    except TypeError:
+                        raise NotImplementedError
+            except NotImplementedError:
+                raise NotImplementedError('sorting of these roots is not supported')
+
+            # If expr contains imaginary coefficients, only take real
+            # values of x for which the imaginary part is 0
+            make_real = S.Reals
+            if (coeffI := expanded_e.coeff(S.ImaginaryUnit)) != S.Zero:
+                check = True
+                im_sol = FiniteSet()
+                try:
+                    a = solveset(coeffI, gen, domain)
+                    if not isinstance(a, Interval):
+                        for z in a:
+                            if z not in singularities and valid(z) and z.is_extended_real:
+                                im_sol += FiniteSet(z)
+                    else:
+                        start, end = a.inf, a.sup
+                        for z in _nsort(critical_points + FiniteSet(end)):
+                            valid_start = valid(start)
+                            if start != end:
+                                valid_z = valid(z)
+                                pt = _pt(start, z)
+                                if pt not in singularities and pt.is_extended_real and valid(pt):
+                                    if valid_start and valid_z:
+                                        im_sol += Interval(start, z)
+                                    elif valid_start:
+                                        im_sol += Interval.Ropen(start, z)
+                                    elif valid_z:
+                                        im_sol += Interval.Lopen(start, z)
+                                    else:
+                                        im_sol += Interval.open(start, z)
+                            start = z
+                        for s in singularities:
+                            im_sol -= FiniteSet(s)
+                except (TypeError):
+                    im_sol = S.Reals
+                    check = False
+
+                if im_sol is S.EmptySet:
+                    raise ValueError(filldedent('''
+                        %s contains imaginary parts which cannot be
+                        made 0 for any value of %s satisfying the
+                        inequality, leading to relations like I < 0.
+                        '''  % (expr.subs(gen, _gen), _gen)))
+
+                make_real = make_real.intersect(im_sol)
+
+            sol_sets = [S.EmptySet]
+
+            start = domain.inf
+            if start in domain and valid(start) and start.is_finite:
+                sol_sets.append(FiniteSet(start))
+
+            for x in reals:
+                end = x
+
+                if valid(_pt(start, end)):
+                    sol_sets.append(Interval(start, end, True, True))
+
+                if x in singularities:
+                    singularities.remove(x)
+                else:
+                    if x in discontinuities:
+                        discontinuities.remove(x)
+                        _valid = valid(x)
+                    else:  # it's a solution
+                        _valid = include_x
+                    if _valid:
+                        sol_sets.append(FiniteSet(x))
+
+                start = end
+
+            end = domain.sup
+            if end in domain and valid(end) and end.is_finite:
+                sol_sets.append(FiniteSet(end))
+
+            if valid(_pt(start, end)):
+                sol_sets.append(Interval.open(start, end))
+
+            if coeffI != S.Zero and check:
+                rv = (make_real).intersect(_domain)
+            else:
+                rv = Intersection(
+                    (Union(*sol_sets)), make_real, _domain).subs(gen, _gen)
+
+    return rv if not relational else rv.as_relational(_gen)
+
+
+def _pt(start, end):
+    """Return a point between start and end"""
+    if not start.is_infinite and not end.is_infinite:
+        pt = (start + end)/2
+    elif start.is_infinite and end.is_infinite:
+        pt = S.Zero
+    else:
+        if (start.is_infinite and start.is_extended_positive is None or
+                end.is_infinite and end.is_extended_positive is None):
+            raise ValueError('cannot proceed with unsigned infinite values')
+        if (end.is_infinite and end.is_extended_negative or
+                start.is_infinite and start.is_extended_positive):
+            start, end = end, start
+        # if possible, use a multiple of self which has
+        # better behavior when checking assumptions than
+        # an expression obtained by adding or subtracting 1
+        if end.is_infinite:
+            if start.is_extended_positive:
+                pt = start*2
+            elif start.is_extended_negative:
+                pt = start*S.Half
+            else:
+                pt = start + 1
+        elif start.is_infinite:
+            if end.is_extended_positive:
+                pt = end*S.Half
+            elif end.is_extended_negative:
+                pt = end*2
+            else:
+                pt = end - 1
+    return pt
+
+
+def _solve_inequality(ie, s, linear=False):
+    """Return the inequality with s isolated on the left, if possible.
+    If the relationship is non-linear, a solution involving And or Or
+    may be returned. False or True are returned if the relationship
+    is never True or always True, respectively.
+
+    If `linear` is True (default is False) an `s`-dependent expression
+    will be isolated on the left, if possible
+    but it will not be solved for `s` unless the expression is linear
+    in `s`. Furthermore, only "safe" operations which do not change the
+    sense of the relationship are applied: no division by an unsigned
+    value is attempted unless the relationship involves Eq or Ne and
+    no division by a value not known to be nonzero is ever attempted.
+
+    Examples
+    ========
+
+    >>> from sympy import Eq, Symbol
+    >>> from sympy.solvers.inequalities import _solve_inequality as f
+    >>> from sympy.abc import x, y
+
+    For linear expressions, the symbol can be isolated:
+
+    >>> f(x - 2 < 0, x)
+    x < 2
+    >>> f(-x - 6 < x, x)
+    x > -3
+
+    Sometimes nonlinear relationships will be False
+
+    >>> f(x**2 + 4 < 0, x)
+    False
+
+    Or they may involve more than one region of values:
+
+    >>> f(x**2 - 4 < 0, x)
+    (-2 < x) & (x < 2)
+
+    To restrict the solution to a relational, set linear=True
+    and only the x-dependent portion will be isolated on the left:
+
+    >>> f(x**2 - 4 < 0, x, linear=True)
+    x**2 < 4
+
+    Division of only nonzero quantities is allowed, so x cannot
+    be isolated by dividing by y:
+
+    >>> y.is_nonzero is None  # it is unknown whether it is 0 or not
+    True
+    >>> f(x*y < 1, x)
+    x*y < 1
+
+    And while an equality (or inequality) still holds after dividing by a
+    non-zero quantity
+
+    >>> nz = Symbol('nz', nonzero=True)
+    >>> f(Eq(x*nz, 1), x)
+    Eq(x, 1/nz)
+
+    the sign must be known for other inequalities involving > or <:
+
+    >>> f(x*nz <= 1, x)
+    nz*x <= 1
+    >>> p = Symbol('p', positive=True)
+    >>> f(x*p <= 1, x)
+    x <= 1/p
+
+    When there are denominators in the original expression that
+    are removed by expansion, conditions for them will be returned
+    as part of the result:
+
+    >>> f(x < x*(2/x - 1), x)
+    (x < 1) & Ne(x, 0)
+    """
+    from sympy.solvers.solvers import denoms
+    if s not in ie.free_symbols:
+        return ie
+    if ie.rhs == s:
+        ie = ie.reversed
+    if ie.lhs == s and s not in ie.rhs.free_symbols:
+        return ie
+
+    def classify(ie, s, i):
+        # return True or False if ie evaluates when substituting s with
+        # i else None (if unevaluated) or NaN (when there is an error
+        # in evaluating)
+        try:
+            v = ie.subs(s, i)
+            if v is S.NaN:
+                return v
+            elif v not in (True, False):
+                return
+            return v
+        except TypeError:
+            return S.NaN
+
+    rv = None
+    oo = S.Infinity
+    expr = ie.lhs - ie.rhs
+    try:
+        p = Poly(expr, s)
+        if p.degree() == 0:
+            rv = ie.func(p.as_expr(), 0)
+        elif not linear and p.degree() > 1:
+            # handle in except clause
+            raise NotImplementedError
+    except (PolynomialError, NotImplementedError):
+        if not linear:
+            try:
+                rv = reduce_rational_inequalities([[ie]], s)
+            except PolynomialError:
+                rv = solve_univariate_inequality(ie, s)
+            # remove restrictions wrt +/-oo that may have been
+            # applied when using sets to simplify the relationship
+            okoo = classify(ie, s, oo)
+            if okoo is S.true and classify(rv, s, oo) is S.false:
+                rv = rv.subs(s < oo, True)
+            oknoo = classify(ie, s, -oo)
+            if (oknoo is S.true and
+                    classify(rv, s, -oo) is S.false):
+                rv = rv.subs(-oo < s, True)
+                rv = rv.subs(s > -oo, True)
+            if rv is S.true:
+                rv = (s <= oo) if okoo is S.true else (s < oo)
+                if oknoo is not S.true:
+                    rv = And(-oo < s, rv)
+        else:
+            p = Poly(expr)
+
+    conds = []
+    if rv is None:
+        e = p.as_expr()  # this is in expanded form
+        # Do a safe inversion of e, moving non-s terms
+        # to the rhs and dividing by a nonzero factor if
+        # the relational is Eq/Ne; for other relationals
+        # the sign must also be positive or negative
+        rhs = 0
+        b, ax = e.as_independent(s, as_Add=True)
+        e -= b
+        rhs -= b
+        ef = factor_terms(e)
+        a, e = ef.as_independent(s, as_Add=False)
+        if (a.is_zero != False or  # don't divide by potential 0
+                a.is_negative ==
+                a.is_positive is None and  # if sign is not known then
+                ie.rel_op not in ('!=', '==')): # reject if not Eq/Ne
+            e = ef
+            a = S.One
+        rhs /= a
+        if a.is_positive:
+            rv = ie.func(e, rhs)
+        else:
+            rv = ie.reversed.func(e, rhs)
+
+        # return conditions under which the value is
+        # valid, too.
+        beginning_denoms = denoms(ie.lhs) | denoms(ie.rhs)
+        current_denoms = denoms(rv)
+        for d in beginning_denoms - current_denoms:
+            c = _solve_inequality(Eq(d, 0), s, linear=linear)
+            if isinstance(c, Eq) and c.lhs == s:
+                if classify(rv, s, c.rhs) is S.true:
+                    # rv is permitting this value but it shouldn't
+                    conds.append(~c)
+        for i in (-oo, oo):
+            if (classify(rv, s, i) is S.true and
+                    classify(ie, s, i) is not S.true):
+                conds.append(s < i if i is oo else i < s)
+
+    conds.append(rv)
+    return And(*conds)
+
+
+def _reduce_inequalities(inequalities, symbols):
+    # helper for reduce_inequalities
+
+    poly_part, abs_part = {}, {}
+    other = []
+
+    for inequality in inequalities:
+
+        expr, rel = inequality.lhs, inequality.rel_op  # rhs is 0
+
+        # check for gens using atoms which is more strict than free_symbols to
+        # guard against EX domain which won't be handled by
+        # reduce_rational_inequalities
+        gens = expr.atoms(Symbol)
+
+        if len(gens) == 1:
+            gen = gens.pop()
+        else:
+            common = expr.free_symbols & symbols
+            if len(common) == 1:
+                gen = common.pop()
+                other.append(_solve_inequality(Relational(expr, 0, rel), gen))
+                continue
+            else:
+                raise NotImplementedError(filldedent('''
+                    inequality has more than one symbol of interest.
+                    '''))
+
+        if expr.is_polynomial(gen):
+            poly_part.setdefault(gen, []).append((expr, rel))
+        else:
+            components = expr.find(lambda u:
+                u.has(gen) and (
+                u.is_Function or u.is_Pow and not u.exp.is_Integer))
+            if components and all(isinstance(i, Abs) for i in components):
+                abs_part.setdefault(gen, []).append((expr, rel))
+            else:
+                other.append(_solve_inequality(Relational(expr, 0, rel), gen))
+
+    poly_reduced = [reduce_rational_inequalities([exprs], gen) for gen, exprs in poly_part.items()]
+    abs_reduced = [reduce_abs_inequalities(exprs, gen) for gen, exprs in abs_part.items()]
+
+    return And(*(poly_reduced + abs_reduced + other))
+
+
+def reduce_inequalities(inequalities, symbols=[]):
+    """Reduce a system of inequalities with rational coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import reduce_inequalities
+
+    >>> reduce_inequalities(0 <= x + 3, [])
+    (-3 <= x) & (x < oo)
+
+    >>> reduce_inequalities(0 <= x + y*2 - 1, [x])
+    (x < oo) & (x >= 1 - 2*y)
+    """
+    if not iterable(inequalities):
+        inequalities = [inequalities]
+    inequalities = [sympify(i) for i in inequalities]
+
+    gens = set().union(*[i.free_symbols for i in inequalities])
+
+    if not iterable(symbols):
+        symbols = [symbols]
+    symbols = (set(symbols) or gens) & gens
+    if any(i.is_extended_real is False for i in symbols):
+        raise TypeError(filldedent('''
+            inequalities cannot contain symbols that are not real.
+            '''))
+
+    # make vanilla symbol real
+    recast = {i: Dummy(i.name, extended_real=True)
+        for i in gens if i.is_extended_real is None}
+    inequalities = [i.xreplace(recast) for i in inequalities]
+    symbols = {i.xreplace(recast) for i in symbols}
+
+    # prefilter
+    keep = []
+    for i in inequalities:
+        if isinstance(i, Relational):
+            i = i.func(i.lhs.as_expr() - i.rhs.as_expr(), 0)
+        elif i not in (True, False):
+            i = Eq(i, 0)
+        if i == True:
+            continue
+        elif i == False:
+            return S.false
+        if i.lhs.is_number:
+            raise NotImplementedError(
+                "could not determine truth value of %s" % i)
+        keep.append(i)
+    inequalities = keep
+    del keep
+
+    # solve system
+    rv = _reduce_inequalities(inequalities, symbols)
+
+    # restore original symbols and return
+    return rv.xreplace({v: k for k, v in recast.items()})

pllava/lib/python3.10/site-packages/sympy/solvers/ode/__init__.py

@@ -0,0 +1,16 @@
+from .ode import (allhints, checkinfsol, classify_ode,
+        constantsimp, dsolve, homogeneous_order)
+
+from .lie_group import infinitesimals
+
+from .subscheck import checkodesol
+
+from .systems import (canonical_odes, linear_ode_to_matrix,
+        linodesolve)
+
+
+__all__ = [
+    'allhints', 'checkinfsol', 'checkodesol', 'classify_ode', 'constantsimp',
+    'dsolve', 'homogeneous_order', 'infinitesimals', 'canonical_odes', 'linear_ode_to_matrix',
+    'linodesolve'
+]

pllava/lib/python3.10/site-packages/sympy/solvers/ode/nonhomogeneous.py

@@ -0,0 +1,499 @@
+r"""
+This File contains helper functions for nth_linear_constant_coeff_undetermined_coefficients,
+nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients,
+nth_linear_constant_coeff_variation_of_parameters,
+and nth_linear_euler_eq_nonhomogeneous_variation_of_parameters.
+
+All the functions in this file are used by more than one solvers so, instead of creating
+instances in other classes for using them it is better to keep it here as separate helpers.
+
+"""
+from collections import defaultdict
+from sympy.core import Add, S
+from sympy.core.function import diff, expand, _mexpand, expand_mul
+from sympy.core.relational import Eq
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy, Wild
+from sympy.functions import exp, cos, cosh, im, log, re, sin, sinh, \
+    atan2, conjugate
+from sympy.integrals import Integral
+from sympy.polys import (Poly, RootOf, rootof, roots)
+from sympy.simplify import collect, simplify, separatevars, powsimp, trigsimp # type: ignore
+from sympy.utilities import numbered_symbols
+from sympy.solvers.solvers import solve
+from sympy.matrices import wronskian
+from .subscheck import sub_func_doit
+from sympy.solvers.ode.ode import get_numbered_constants
+
+
+def _test_term(coeff, func, order):
+    r"""
+    Linear Euler ODEs have the form  K*x**order*diff(y(x), x, order) = F(x),
+    where K is independent of x and y(x), order>= 0.
+    So we need to check that for each term, coeff == K*x**order from
+    some K.  We have a few cases, since coeff may have several
+    different types.
+    """
+    x = func.args[0]
+    f = func.func
+    if order < 0:
+        raise ValueError("order should be greater than 0")
+    if coeff == 0:
+        return True
+    if order == 0:
+        if x in coeff.free_symbols:
+            return False
+        return True
+    if coeff.is_Mul:
+        if coeff.has(f(x)):
+            return False
+        return x**order in coeff.args
+    elif coeff.is_Pow:
+        return coeff.as_base_exp() == (x, order)
+    elif order == 1:
+        return x == coeff
+    return False
+
+
+def _get_euler_characteristic_eq_sols(eq, func, match_obj):
+    r"""
+    Returns the solution of homogeneous part of the linear euler ODE and
+    the list of roots of characteristic equation.
+
+    The parameter ``match_obj`` is a dict of order:coeff terms, where order is the order
+    of the derivative on each term, and coeff is the coefficient of that derivative.
+
+    """
+    x = func.args[0]
+    f = func.func
+
+    # First, set up characteristic equation.
+    chareq, symbol = S.Zero, Dummy('x')
+
+    for i in match_obj:
+        if i >= 0:
+            chareq += (match_obj[i]*diff(x**symbol, x, i)*x**-symbol).expand()
+
+    chareq = Poly(chareq, symbol)
+    chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
+    collectterms = []
+
+    # A generator of constants
+    constants = list(get_numbered_constants(eq, num=chareq.degree()*2))
+    constants.reverse()
+
+    # Create a dict root: multiplicity or charroots
+    charroots = defaultdict(int)
+    for root in chareqroots:
+        charroots[root] += 1
+    gsol = S.Zero
+    ln = log
+    for root, multiplicity in charroots.items():
+        for i in range(multiplicity):
+            if isinstance(root, RootOf):
+                gsol += (x**root) * constants.pop()
+                if multiplicity != 1:
+                    raise ValueError("Value should be 1")
+                collectterms = [(0, root, 0)] + collectterms
+            elif root.is_real:
+                gsol += ln(x)**i*(x**root) * constants.pop()
+                collectterms = [(i, root, 0)] + collectterms
+            else:
+                reroot = re(root)
+                imroot = im(root)
+                gsol += ln(x)**i * (x**reroot) * (
+                    constants.pop() * sin(abs(imroot)*ln(x))
+                    + constants.pop() * cos(imroot*ln(x)))
+                collectterms = [(i, reroot, imroot)] + collectterms
+
+    gsol = Eq(f(x), gsol)
+
+    gensols = []
+    # Keep track of when to use sin or cos for nonzero imroot
+    for i, reroot, imroot in collectterms:
+        if imroot == 0:
+            gensols.append(ln(x)**i*x**reroot)
+        else:
+            sin_form = ln(x)**i*x**reroot*sin(abs(imroot)*ln(x))
+            if sin_form in gensols:
+                cos_form = ln(x)**i*x**reroot*cos(imroot*ln(x))
+                gensols.append(cos_form)
+            else:
+                gensols.append(sin_form)
+    return gsol, gensols
+
+
+def _solve_variation_of_parameters(eq, func, roots, homogen_sol, order, match_obj, simplify_flag=True):
+    r"""
+    Helper function for the method of variation of parameters and nonhomogeneous euler eq.
+
+    See the
+    :py:meth:`~sympy.solvers.ode.single.NthLinearConstantCoeffVariationOfParameters`
+    docstring for more information on this method.
+
+    The parameter are ``match_obj`` should be a dictionary that has the following
+    keys:
+
+    ``list``
+    A list of solutions to the homogeneous equation.
+
+    ``sol``
+    The general solution.
+
+    """
+    f = func.func
+    x = func.args[0]
+    r = match_obj
+    psol = 0
+    wr = wronskian(roots, x)
+
+    if simplify_flag:
+        wr = simplify(wr)  # We need much better simplification for
+                        # some ODEs. See issue 4662, for example.
+        # To reduce commonly occurring sin(x)**2 + cos(x)**2 to 1
+        wr = trigsimp(wr, deep=True, recursive=True)
+    if not wr:
+        # The wronskian will be 0 iff the solutions are not linearly
+        # independent.
+        raise NotImplementedError("Cannot find " + str(order) +
+        " solutions to the homogeneous equation necessary to apply " +
+        "variation of parameters to " + str(eq) + " (Wronskian == 0)")
+    if len(roots) != order:
+        raise NotImplementedError("Cannot find " + str(order) +
+        " solutions to the homogeneous equation necessary to apply " +
+        "variation of parameters to " +
+        str(eq) + " (number of terms != order)")
+    negoneterm = S.NegativeOne**(order)
+    for i in roots:
+        psol += negoneterm*Integral(wronskian([sol for sol in roots if sol != i], x)*r[-1]/wr, x)*i/r[order]
+        negoneterm *= -1
+
+    if simplify_flag:
+        psol = simplify(psol)
+        psol = trigsimp(psol, deep=True)
+    return Eq(f(x), homogen_sol.rhs + psol)
+
+
+def _get_const_characteristic_eq_sols(r, func, order):
+    r"""
+    Returns the roots of characteristic equation of constant coefficient
+    linear ODE and list of collectterms which is later on used by simplification
+    to use collect on solution.
+
+    The parameter `r` is a dict of order:coeff terms, where order is the order of the
+    derivative on each term, and coeff is the coefficient of that derivative.
+
+    """
+    x = func.args[0]
+    # First, set up characteristic equation.
+    chareq, symbol = S.Zero, Dummy('x')
+
+    for i in r.keys():
+        if isinstance(i, str) or i < 0:
+            pass
+        else:
+            chareq += r[i]*symbol**i
+
+    chareq = Poly(chareq, symbol)
+    # Can't just call roots because it doesn't return rootof for unsolveable
+    # polynomials.
+    chareqroots = roots(chareq, multiple=True)
+    if len(chareqroots) != order:
+        chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
+
+    chareq_is_complex = not all(i.is_real for i in chareq.all_coeffs())
+
+    # Create a dict root: multiplicity or charroots
+    charroots = defaultdict(int)
+    for root in chareqroots:
+        charroots[root] += 1
+    # We need to keep track of terms so we can run collect() at the end.
+    # This is necessary for constantsimp to work properly.
+    collectterms = []
+    gensols = []
+    conjugate_roots = [] # used to prevent double-use of conjugate roots
+    # Loop over roots in theorder provided by roots/rootof...
+    for root in chareqroots:
+        # but don't repoeat multiple roots.
+        if root not in charroots:
+            continue
+        multiplicity = charroots.pop(root)
+        for i in range(multiplicity):
+            if chareq_is_complex:
+                gensols.append(x**i*exp(root*x))
+                collectterms = [(i, root, 0)] + collectterms
+                continue
+            reroot = re(root)
+            imroot = im(root)
+            if imroot.has(atan2) and reroot.has(atan2):
+                # Remove this condition when re and im stop returning
+                # circular atan2 usages.
+                gensols.append(x**i*exp(root*x))
+                collectterms = [(i, root, 0)] + collectterms
+            else:
+                if root in conjugate_roots:
+                    collectterms = [(i, reroot, imroot)] + collectterms
+                    continue
+                if imroot == 0:
+                    gensols.append(x**i*exp(reroot*x))
+                    collectterms = [(i, reroot, 0)] + collectterms
+                    continue
+                conjugate_roots.append(conjugate(root))
+                gensols.append(x**i*exp(reroot*x) * sin(abs(imroot) * x))
+                gensols.append(x**i*exp(reroot*x) * cos(    imroot  * x))
+
+                # This ordering is important
+                collectterms = [(i, reroot, imroot)] + collectterms
+    return gensols, collectterms
+
+
+# Ideally these kind of simplification functions shouldn't be part of solvers.
+# odesimp should be improved to handle these kind of specific simplifications.
+def _get_simplified_sol(sol, func, collectterms):
+    r"""
+    Helper function which collects the solution on
+    collectterms. Ideally this should be handled by odesimp.It is used
+    only when the simplify is set to True in dsolve.
+
+    The parameter ``collectterms`` is a list of tuple (i, reroot, imroot) where `i` is
+    the multiplicity of the root, reroot is real part and imroot being the imaginary part.
+
+    """
+    f = func.func
+    x = func.args[0]
+    collectterms.sort(key=default_sort_key)
+    collectterms.reverse()
+    assert len(sol) == 1 and sol[0].lhs == f(x)
+    sol = sol[0].rhs
+    sol = expand_mul(sol)
+    for i, reroot, imroot in collectterms:
+        sol = collect(sol, x**i*exp(reroot*x)*sin(abs(imroot)*x))
+        sol = collect(sol, x**i*exp(reroot*x)*cos(imroot*x))
+    for i, reroot, imroot in collectterms:
+        sol = collect(sol, x**i*exp(reroot*x))
+    sol = powsimp(sol)
+    return Eq(f(x), sol)
+
+
+def _undetermined_coefficients_match(expr, x, func=None, eq_homogeneous=S.Zero):
+    r"""
+    Returns a trial function match if undetermined coefficients can be applied
+    to ``expr``, and ``None`` otherwise.
+
+    A trial expression can be found for an expression for use with the method
+    of undetermined coefficients if the expression is an
+    additive/multiplicative combination of constants, polynomials in `x` (the
+    independent variable of expr), `\sin(a x + b)`, `\cos(a x + b)`, and
+    `e^{a x}` terms (in other words, it has a finite number of linearly
+    independent derivatives).
+
+    Note that you may still need to multiply each term returned here by
+    sufficient `x` to make it linearly independent with the solutions to the
+    homogeneous equation.
+
+    This is intended for internal use by ``undetermined_coefficients`` hints.
+
+    SymPy currently has no way to convert `\sin^n(x) \cos^m(y)` into a sum of
+    only `\sin(a x)` and `\cos(b x)` terms, so these are not implemented.  So,
+    for example, you will need to manually convert `\sin^2(x)` into `[1 +
+    \cos(2 x)]/2` to properly apply the method of undetermined coefficients on
+    it.
+
+    Examples
+    ========
+
+    >>> from sympy import log, exp
+    >>> from sympy.solvers.ode.nonhomogeneous import _undetermined_coefficients_match
+    >>> from sympy.abc import x
+    >>> _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x)
+    {'test': True, 'trialset': {x*exp(x), exp(-x), exp(x)}}
+    >>> _undetermined_coefficients_match(log(x), x)
+    {'test': False}
+
+    """
+    a = Wild('a', exclude=[x])
+    b = Wild('b', exclude=[x])
+    expr = powsimp(expr, combine='exp')  # exp(x)*exp(2*x + 1) => exp(3*x + 1)
+    retdict = {}
+
+    def _test_term(expr, x):
+        r"""
+        Test if ``expr`` fits the proper form for undetermined coefficients.
+        """
+        if not expr.has(x):
+            return True
+        elif expr.is_Add:
+            return all(_test_term(i, x) for i in expr.args)
+        elif expr.is_Mul:
+            if expr.has(sin, cos):
+                foundtrig = False
+                # Make sure that there is only one trig function in the args.
+                # See the docstring.
+                for i in expr.args:
+                    if i.has(sin, cos):
+                        if foundtrig:
+                            return False
+                        else:
+                            foundtrig = True
+            return all(_test_term(i, x) for i in expr.args)
+        elif expr.is_Function:
+            if expr.func in (sin, cos, exp, sinh, cosh):
+                if expr.args[0].match(a*x + b):
+                    return True
+                else:
+                    return False
+            else:
+                return False
+        elif expr.is_Pow and expr.base.is_Symbol and expr.exp.is_Integer and \
+                expr.exp >= 0:
+            return True
+        elif expr.is_Pow and expr.base.is_number:
+            if expr.exp.match(a*x + b):
+                return True
+            else:
+                return False
+        elif expr.is_Symbol or expr.is_number:
+            return True
+        else:
+            return False
+
+    def _get_trial_set(expr, x, exprs=set()):
+        r"""
+        Returns a set of trial terms for undetermined coefficients.
+
+        The idea behind undetermined coefficients is that the terms expression
+        repeat themselves after a finite number of derivatives, except for the
+        coefficients (they are linearly dependent).  So if we collect these,
+        we should have the terms of our trial function.
+        """
+        def _remove_coefficient(expr, x):
+            r"""
+            Returns the expression without a coefficient.
+
+            Similar to expr.as_independent(x)[1], except it only works
+            multiplicatively.
+            """
+            term = S.One
+            if expr.is_Mul:
+                for i in expr.args:
+                    if i.has(x):
+                        term *= i
+            elif expr.has(x):
+                term = expr
+            return term
+
+        expr = expand_mul(expr)
+        if expr.is_Add:
+            for term in expr.args:
+                if _remove_coefficient(term, x) in exprs:
+                    pass
+                else:
+                    exprs.add(_remove_coefficient(term, x))
+                    exprs = exprs.union(_get_trial_set(term, x, exprs))
+        else:
+            term = _remove_coefficient(expr, x)
+            tmpset = exprs.union({term})
+            oldset = set()
+            while tmpset != oldset:
+                # If you get stuck in this loop, then _test_term is probably
+                # broken
+                oldset = tmpset.copy()
+                expr = expr.diff(x)
+                term = _remove_coefficient(expr, x)
+                if term.is_Add:
+                    tmpset = tmpset.union(_get_trial_set(term, x, tmpset))
+                else:
+                    tmpset.add(term)
+            exprs = tmpset
+        return exprs
+
+    def is_homogeneous_solution(term):
+        r""" This function checks whether the given trialset contains any root
+            of homogeneous equation"""
+        return expand(sub_func_doit(eq_homogeneous, func, term)).is_zero
+
+    retdict['test'] = _test_term(expr, x)
+    if retdict['test']:
+        # Try to generate a list of trial solutions that will have the
+        # undetermined coefficients. Note that if any of these are not linearly
+        # independent with any of the solutions to the homogeneous equation,
+        # then they will need to be multiplied by sufficient x to make them so.
+        # This function DOES NOT do that (it doesn't even look at the
+        # homogeneous equation).
+        temp_set = set()
+        for i in Add.make_args(expr):
+            act = _get_trial_set(i, x)
+            if eq_homogeneous is not S.Zero:
+                while any(is_homogeneous_solution(ts) for ts in act):
+                    act = {x*ts for ts in act}
+            temp_set = temp_set.union(act)
+
+        retdict['trialset'] = temp_set
+    return retdict
+
+
+def _solve_undetermined_coefficients(eq, func, order, match, trialset):
+    r"""
+    Helper function for the method of undetermined coefficients.
+
+    See the
+    :py:meth:`~sympy.solvers.ode.single.NthLinearConstantCoeffUndeterminedCoefficients`
+    docstring for more information on this method.
+
+    The parameter ``trialset`` is the set of trial functions as returned by
+    ``_undetermined_coefficients_match()['trialset']``.
+
+    The parameter ``match`` should be a dictionary that has the following
+    keys:
+
+    ``list``
+    A list of solutions to the homogeneous equation.
+
+    ``sol``
+    The general solution.
+
+    """
+    r = match
+    coeffs = numbered_symbols('a', cls=Dummy)
+    coefflist = []
+    gensols = r['list']
+    gsol = r['sol']
+    f = func.func
+    x = func.args[0]
+
+    if len(gensols) != order:
+        raise NotImplementedError("Cannot find " + str(order) +
+        " solutions to the homogeneous equation necessary to apply" +
+        " undetermined coefficients to " + str(eq) +
+        " (number of terms != order)")
+
+    trialfunc = 0
+    for i in trialset:
+        c = next(coeffs)
+        coefflist.append(c)
+        trialfunc += c*i
+
+    eqs = sub_func_doit(eq, f(x), trialfunc)
+
+    coeffsdict = dict(list(zip(trialset, [0]*(len(trialset) + 1))))
+
+    eqs = _mexpand(eqs)
+
+    for i in Add.make_args(eqs):
+        s = separatevars(i, dict=True, symbols=[x])
+        if coeffsdict.get(s[x]):
+            coeffsdict[s[x]] += s['coeff']
+        else:
+            coeffsdict[s[x]] = s['coeff']
+
+    coeffvals = solve(list(coeffsdict.values()), coefflist)
+
+    if not coeffvals:
+        raise NotImplementedError(
+            "Could not solve `%s` using the "
+            "method of undetermined coefficients "
+            "(unable to solve for coefficients)." % eq)
+
+    psol = trialfunc.subs(coeffvals)
+
+    return Eq(f(x), gsol.rhs + psol)

pllava/lib/python3.10/site-packages/sympy/solvers/ode/riccati.py

@@ -0,0 +1,893 @@
+r"""
+This module contains :py:meth:`~sympy.solvers.ode.riccati.solve_riccati`,
+a function which gives all rational particular solutions to first order
+Riccati ODEs. A general first order Riccati ODE is given by -
+
+.. math:: y' = b_0(x) + b_1(x)w + b_2(x)w^2
+
+where `b_0, b_1` and `b_2` can be arbitrary rational functions of `x`
+with `b_2 \ne 0`. When `b_2 = 0`, the equation is not a Riccati ODE
+anymore and becomes a Linear ODE. Similarly, when `b_0 = 0`, the equation
+is a Bernoulli ODE. The algorithm presented below can find rational
+solution(s) to all ODEs with `b_2 \ne 0` that have a rational solution,
+or prove that no rational solution exists for the equation.
+
+Background
+==========
+
+A Riccati equation can be transformed to its normal form
+
+.. math:: y' + y^2 = a(x)
+
+using the transformation
+
+.. math:: y = -b_2(x) - \frac{b'_2(x)}{2 b_2(x)} - \frac{b_1(x)}{2}
+
+where `a(x)` is given by
+
+.. math:: a(x) = \frac{1}{4}\left(\frac{b_2'}{b_2} + b_1\right)^2 - \frac{1}{2}\left(\frac{b_2'}{b_2} + b_1\right)' - b_0 b_2
+
+Thus, we can develop an algorithm to solve for the Riccati equation
+in its normal form, which would in turn give us the solution for
+the original Riccati equation.
+
+Algorithm
+=========
+
+The algorithm implemented here is presented in the Ph.D thesis
+"Rational and Algebraic Solutions of First-Order Algebraic ODEs"
+by N. Thieu Vo. The entire thesis can be found here -
+https://www3.risc.jku.at/publications/download/risc_5387/PhDThesisThieu.pdf
+
+We have only implemented the Rational Riccati solver (Algorithm 11,
+Pg 78-82 in Thesis). Before we proceed towards the implementation
+of the algorithm, a few definitions to understand are -
+
+1. Valuation of a Rational Function at `\infty`:
+    The valuation of a rational function `p(x)` at `\infty` is equal
+    to the difference between the degree of the denominator and the
+    numerator of `p(x)`.
+
+    NOTE: A general definition of valuation of a rational function
+    at any value of `x` can be found in Pg 63 of the thesis, but
+    is not of any interest for this algorithm.
+
+2. Zeros and Poles of a Rational Function:
+    Let `a(x) = \frac{S(x)}{T(x)}, T \ne 0` be a rational function
+    of `x`. Then -
+
+    a. The Zeros of `a(x)` are the roots of `S(x)`.
+    b. The Poles of `a(x)` are the roots of `T(x)`. However, `\infty`
+    can also be a pole of a(x). We say that `a(x)` has a pole at
+    `\infty` if `a(\frac{1}{x})` has a pole at 0.
+
+Every pole is associated with an order that is equal to the multiplicity
+of its appearance as a root of `T(x)`. A pole is called a simple pole if
+it has an order 1. Similarly, a pole is called a multiple pole if it has
+an order `\ge` 2.
+
+Necessary Conditions
+====================
+
+For a Riccati equation in its normal form,
+
+.. math:: y' + y^2 = a(x)
+
+we can define
+
+a. A pole is called a movable pole if it is a pole of `y(x)` and is not
+a pole of `a(x)`.
+b. Similarly, a pole is called a non-movable pole if it is a pole of both
+`y(x)` and `a(x)`.
+
+Then, the algorithm states that a rational solution exists only if -
+
+a. Every pole of `a(x)` must be either a simple pole or a multiple pole
+of even order.
+b. The valuation of `a(x)` at `\infty` must be even or be `\ge` 2.
+
+This algorithm finds all possible rational solutions for the Riccati ODE.
+If no rational solutions are found, it means that no rational solutions
+exist.
+
+The algorithm works for Riccati ODEs where the coefficients are rational
+functions in the independent variable `x` with rational number coefficients
+i.e. in `Q(x)`. The coefficients in the rational function cannot be floats,
+irrational numbers, symbols or any other kind of expression. The reasons
+for this are -
+
+1. When using symbols, different symbols could take the same value and this
+would affect the multiplicity of poles if symbols are present here.
+
+2. An integer degree bound is required to calculate a polynomial solution
+to an auxiliary differential equation, which in turn gives the particular
+solution for the original ODE. If symbols/floats/irrational numbers are
+present, we cannot determine if the expression for the degree bound is an
+integer or not.
+
+Solution
+========
+
+With these definitions, we can state a general form for the solution of
+the equation. `y(x)` must have the form -
+
+.. math:: y(x) = \sum_{i=1}^{n} \sum_{j=1}^{r_i} \frac{c_{ij}}{(x - x_i)^j} + \sum_{i=1}^{m} \frac{1}{x - \chi_i} + \sum_{i=0}^{N} d_i x^i
+
+where `x_1, x_2, \dots, x_n` are non-movable poles of `a(x)`,
+`\chi_1, \chi_2, \dots, \chi_m` are movable poles of `a(x)`, and the values
+of `N, n, r_1, r_2, \dots, r_n` can be determined from `a(x)`. The
+coefficient vectors `(d_0, d_1, \dots, d_N)` and `(c_{i1}, c_{i2}, \dots, c_{i r_i})`
+can be determined from `a(x)`. We will have 2 choices each of these vectors
+and part of the procedure is figuring out which of the 2 should be used
+to get the solution correctly.
+
+Implementation
+==============
+
+In this implementation, we use ``Poly`` to represent a rational function
+rather than using ``Expr`` since ``Poly`` is much faster. Since we cannot
+represent rational functions directly using ``Poly``, we instead represent
+a rational function with 2 ``Poly`` objects - one for its numerator and
+the other for its denominator.
+
+The code is written to match the steps given in the thesis (Pg 82)
+
+Step 0 : Match the equation -
+Find `b_0, b_1` and `b_2`. If `b_2 = 0` or no such functions exist, raise
+an error
+
+Step 1 : Transform the equation to its normal form as explained in the
+theory section.
+
+Step 2 : Initialize an empty set of solutions, ``sol``.
+
+Step 3 : If `a(x) = 0`, append `\frac{1}/{(x - C1)}` to ``sol``.
+
+Step 4 : If `a(x)` is a rational non-zero number, append `\pm \sqrt{a}`
+to ``sol``.
+
+Step 5 : Find the poles and their multiplicities of `a(x)`. Let
+the number of poles be `n`. Also find the valuation of `a(x)` at
+`\infty` using ``val_at_inf``.
+
+NOTE: Although the algorithm considers `\infty` as a pole, it is
+not mentioned if it a part of the set of finite poles. `\infty`
+is NOT a part of the set of finite poles. If a pole exists at
+`\infty`, we use its multiplicity to find the laurent series of
+`a(x)` about `\infty`.
+
+Step 6 : Find `n` c-vectors (one for each pole) and 1 d-vector using
+``construct_c`` and ``construct_d``. Now, determine all the ``2**(n + 1)``
+combinations of choosing between 2 choices for each of the `n` c-vectors
+and 1 d-vector.
+
+NOTE: The equation for `d_{-1}` in Case 4 (Pg 80) has a printinig
+mistake. The term `- d_N` must be replaced with `-N d_N`. The same
+has been explained in the code as well.
+
+For each of these above combinations, do
+
+Step 8 : Compute `m` in ``compute_m_ybar``. `m` is the degree bound of
+the polynomial solution we must find for the auxiliary equation.
+
+Step 9 : In ``compute_m_ybar``, compute ybar as well where ``ybar`` is
+one part of y(x) -
+
+.. math:: \overline{y}(x) = \sum_{i=1}^{n} \sum_{j=1}^{r_i} \frac{c_{ij}}{(x - x_i)^j} + \sum_{i=0}^{N} d_i x^i
+
+Step 10 : If `m` is a non-negative integer -
+
+Step 11: Find a polynomial solution of degree `m` for the auxiliary equation.
+
+There are 2 cases possible -
+
+    a. `m` is a non-negative integer: We can solve for the coefficients
+    in `p(x)` using Undetermined Coefficients.
+
+    b. `m` is not a non-negative integer: In this case, we cannot find
+    a polynomial solution to the auxiliary equation, and hence, we ignore
+    this value of `m`.
+
+Step 12 : For each `p(x)` that exists, append `ybar + \frac{p'(x)}{p(x)}`
+to ``sol``.
+
+Step 13 : For each solution in ``sol``, apply an inverse transformation,
+so that the solutions of the original equation are found using the
+solutions of the equation in its normal form.
+"""
+
+
+from itertools import product
+from sympy.core import S
+from sympy.core.add import Add
+from sympy.core.numbers import oo, Float
+from sympy.core.function import count_ops
+from sympy.core.relational import Eq
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.functions import sqrt, exp
+from sympy.functions.elementary.complexes import sign
+from sympy.integrals.integrals import Integral
+from sympy.polys.domains import ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.polyroots import roots
+from sympy.solvers.solveset import linsolve
+
+
+def riccati_normal(w, x, b1, b2):
+    """
+    Given a solution `w(x)` to the equation
+
+    .. math:: w'(x) = b_0(x) + b_1(x)*w(x) + b_2(x)*w(x)^2
+
+    and rational function coefficients `b_1(x)` and
+    `b_2(x)`, this function transforms the solution to
+    give a solution `y(x)` for its corresponding normal
+    Riccati ODE
+
+    .. math:: y'(x) + y(x)^2 = a(x)
+
+    using the transformation
+
+    .. math:: y(x) = -b_2(x)*w(x) - b'_2(x)/(2*b_2(x)) - b_1(x)/2
+    """
+    return -b2*w - b2.diff(x)/(2*b2) - b1/2
+
+
+def riccati_inverse_normal(y, x, b1, b2, bp=None):
+    """
+    Inverse transforming the solution to the normal
+    Riccati ODE to get the solution to the Riccati ODE.
+    """
+    # bp is the expression which is independent of the solution
+    # and hence, it need not be computed again
+    if bp is None:
+        bp = -b2.diff(x)/(2*b2**2) - b1/(2*b2)
+    # w(x) = -y(x)/b2(x) - b2'(x)/(2*b2(x)^2) - b1(x)/(2*b2(x))
+    return -y/b2 + bp
+
+
+def riccati_reduced(eq, f, x):
+    """
+    Convert a Riccati ODE into its corresponding
+    normal Riccati ODE.
+    """
+    match, funcs = match_riccati(eq, f, x)
+    # If equation is not a Riccati ODE, exit
+    if not match:
+        return False
+    # Using the rational functions, find the expression for a(x)
+    b0, b1, b2 = funcs
+    a = -b0*b2 + b1**2/4 - b1.diff(x)/2 + 3*b2.diff(x)**2/(4*b2**2) + b1*b2.diff(x)/(2*b2) - \
+        b2.diff(x, 2)/(2*b2)
+    # Normal form of Riccati ODE is f'(x) + f(x)^2 = a(x)
+    return f(x).diff(x) + f(x)**2 - a
+
+def linsolve_dict(eq, syms):
+    """
+    Get the output of linsolve as a dict
+    """
+    # Convert tuple type return value of linsolve
+    # to a dictionary for ease of use
+    sol = linsolve(eq, syms)
+    if not sol:
+        return {}
+    return dict(zip(syms, list(sol)[0]))
+
+
+def match_riccati(eq, f, x):
+    """
+    A function that matches and returns the coefficients
+    if an equation is a Riccati ODE
+
+    Parameters
+    ==========
+
+    eq: Equation to be matched
+    f: Dependent variable
+    x: Independent variable
+
+    Returns
+    =======
+
+    match: True if equation is a Riccati ODE, False otherwise
+    funcs: [b0, b1, b2] if match is True, [] otherwise. Here,
+    b0, b1 and b2 are rational functions which match the equation.
+    """
+    # Group terms based on f(x)
+    if isinstance(eq, Eq):
+        eq = eq.lhs - eq.rhs
+    eq = eq.expand().collect(f(x))
+    cf = eq.coeff(f(x).diff(x))
+
+    # There must be an f(x).diff(x) term.
+    # eq must be an Add object since we are using the expanded
+    # equation and it must have atleast 2 terms (b2 != 0)
+    if cf != 0 and isinstance(eq, Add):
+
+        # Divide all coefficients by the coefficient of f(x).diff(x)
+        # and add the terms again to get the same equation
+        eq = Add(*((x/cf).cancel() for x in eq.args)).collect(f(x))
+
+        # Match the equation with the pattern
+        b1 = -eq.coeff(f(x))
+        b2 = -eq.coeff(f(x)**2)
+        b0 = (f(x).diff(x) - b1*f(x) - b2*f(x)**2 - eq).expand()
+        funcs = [b0, b1, b2]
+
+        # Check if coefficients are not symbols and floats
+        if any(len(x.atoms(Symbol)) > 1 or len(x.atoms(Float)) for x in funcs):
+            return False, []
+
+        # If b_0(x) contains f(x), it is not a Riccati ODE
+        if len(b0.atoms(f)) or not all((b2 != 0, b0.is_rational_function(x),
+            b1.is_rational_function(x), b2.is_rational_function(x))):
+            return False, []
+        return True, funcs
+    return False, []
+
+
+def val_at_inf(num, den, x):
+    # Valuation of a rational function at oo = deg(denom) - deg(numer)
+    return den.degree(x) - num.degree(x)
+
+
+def check_necessary_conds(val_inf, muls):
+    """
+    The necessary conditions for a rational solution
+    to exist are as follows -
+
+    i) Every pole of a(x) must be either a simple pole
+    or a multiple pole of even order.
+
+    ii) The valuation of a(x) at infinity must be even
+    or be greater than or equal to 2.
+
+    Here, a simple pole is a pole with multiplicity 1
+    and a multiple pole is a pole with multiplicity
+    greater than 1.
+    """
+    return (val_inf >= 2 or (val_inf <= 0 and val_inf%2 == 0)) and \
+        all(mul == 1 or (mul%2 == 0 and mul >= 2) for mul in muls)
+
+
+def inverse_transform_poly(num, den, x):
+    """
+    A function to make the substitution
+    x -> 1/x in a rational function that
+    is represented using Poly objects for
+    numerator and denominator.
+    """
+    # Declare for reuse
+    one = Poly(1, x)
+    xpoly = Poly(x, x)
+
+    # Check if degree of numerator is same as denominator
+    pwr = val_at_inf(num, den, x)
+    if pwr >= 0:
+        # Denominator has greater degree. Substituting x with
+        # 1/x would make the extra power go to the numerator
+        if num.expr != 0:
+            num = num.transform(one, xpoly) * x**pwr
+            den = den.transform(one, xpoly)
+    else:
+        # Numerator has greater degree. Substituting x with
+        # 1/x would make the extra power go to the denominator
+        num = num.transform(one, xpoly)
+        den = den.transform(one, xpoly) * x**(-pwr)
+    return num.cancel(den, include=True)
+
+
+def limit_at_inf(num, den, x):
+    """
+    Find the limit of a rational function
+    at oo
+    """
+    # pwr = degree(num) - degree(den)
+    pwr = -val_at_inf(num, den, x)
+    # Numerator has a greater degree than denominator
+    # Limit at infinity would depend on the sign of the
+    # leading coefficients of numerator and denominator
+    if pwr > 0:
+        return oo*sign(num.LC()/den.LC())
+    # Degree of numerator is equal to that of denominator
+    # Limit at infinity is just the ratio of leading coeffs
+    elif pwr == 0:
+        return num.LC()/den.LC()
+    # Degree of numerator is less than that of denominator
+    # Limit at infinity is just 0
+    else:
+        return 0
+
+
+def construct_c_case_1(num, den, x, pole):
+    # Find the coefficient of 1/(x - pole)**2 in the
+    # Laurent series expansion of a(x) about pole.
+    num1, den1 = (num*Poly((x - pole)**2, x, extension=True)).cancel(den, include=True)
+    r = (num1.subs(x, pole))/(den1.subs(x, pole))
+
+    # If multiplicity is 2, the coefficient to be added
+    # in the c-vector is c = (1 +- sqrt(1 + 4*r))/2
+    if r != -S(1)/4:
+        return [[(1 + sqrt(1 + 4*r))/2], [(1 - sqrt(1 + 4*r))/2]]
+    return [[S.Half]]
+
+
+def construct_c_case_2(num, den, x, pole, mul):
+    # Generate the coefficients using the recurrence
+    # relation mentioned in (5.14) in the thesis (Pg 80)
+
+    # r_i = mul/2
+    ri = mul//2
+
+    # Find the Laurent series coefficients about the pole
+    ser = rational_laurent_series(num, den, x, pole, mul, 6)
+
+    # Start with an empty memo to store the coefficients
+    # This is for the plus case
+    cplus = [0 for i in range(ri)]
+
+    # Base Case
+    cplus[ri-1] = sqrt(ser[2*ri])
+
+    # Iterate backwards to find all coefficients
+    s = ri - 1
+    sm = 0
+    for s in range(ri-1, 0, -1):
+        sm = 0
+        for j in range(s+1, ri):
+            sm += cplus[j-1]*cplus[ri+s-j-1]
+        if s!= 1:
+            cplus[s-1] = (ser[ri+s] - sm)/(2*cplus[ri-1])
+
+    # Memo for the minus case
+    cminus = [-x for x in cplus]
+
+    # Find the 0th coefficient in the recurrence
+    cplus[0] = (ser[ri+s] - sm - ri*cplus[ri-1])/(2*cplus[ri-1])
+    cminus[0] = (ser[ri+s] - sm  - ri*cminus[ri-1])/(2*cminus[ri-1])
+
+    # Add both the plus and minus cases' coefficients
+    if cplus != cminus:
+        return [cplus, cminus]
+    return cplus
+
+
+def construct_c_case_3():
+    # If multiplicity is 1, the coefficient to be added
+    # in the c-vector is 1 (no choice)
+    return [[1]]
+
+
+def construct_c(num, den, x, poles, muls):
+    """
+    Helper function to calculate the coefficients
+    in the c-vector for each pole.
+    """
+    c = []
+    for pole, mul in zip(poles, muls):
+        c.append([])
+
+        # Case 3
+        if mul == 1:
+            # Add the coefficients from Case 3
+            c[-1].extend(construct_c_case_3())
+
+        # Case 1
+        elif mul == 2:
+            # Add the coefficients from Case 1
+            c[-1].extend(construct_c_case_1(num, den, x, pole))
+
+        # Case 2
+        else:
+            # Add the coefficients from Case 2
+            c[-1].extend(construct_c_case_2(num, den, x, pole, mul))
+
+    return c
+
+
+def construct_d_case_4(ser, N):
+    # Initialize an empty vector
+    dplus = [0 for i in range(N+2)]
+    # d_N = sqrt(a_{2*N})
+    dplus[N] = sqrt(ser[2*N])
+
+    # Use the recurrence relations to find
+    # the value of d_s
+    for s in range(N-1, -2, -1):
+        sm = 0
+        for j in range(s+1, N):
+            sm += dplus[j]*dplus[N+s-j]
+        if s != -1:
+            dplus[s] = (ser[N+s] - sm)/(2*dplus[N])
+
+    # Coefficients for the case of d_N = -sqrt(a_{2*N})
+    dminus = [-x for x in dplus]
+
+    # The third equation in Eq 5.15 of the thesis is WRONG!
+    # d_N must be replaced with N*d_N in that equation.
+    dplus[-1] = (ser[N+s] - N*dplus[N] - sm)/(2*dplus[N])
+    dminus[-1] = (ser[N+s] - N*dminus[N] - sm)/(2*dminus[N])
+
+    if dplus != dminus:
+        return [dplus, dminus]
+    return dplus
+
+
+def construct_d_case_5(ser):
+    # List to store coefficients for plus case
+    dplus = [0, 0]
+
+    # d_0  = sqrt(a_0)
+    dplus[0] = sqrt(ser[0])
+
+    # d_(-1) = a_(-1)/(2*d_0)
+    dplus[-1] = ser[-1]/(2*dplus[0])
+
+    # Coefficients for the minus case are just the negative
+    # of the coefficients for the positive case.
+    dminus = [-x for x in dplus]
+
+    if dplus != dminus:
+        return [dplus, dminus]
+    return dplus
+
+
+def construct_d_case_6(num, den, x):
+    # s_oo = lim x->0 1/x**2 * a(1/x) which is equivalent to
+    # s_oo = lim x->oo x**2 * a(x)
+    s_inf = limit_at_inf(Poly(x**2, x)*num, den, x)
+
+    # d_(-1) = (1 +- sqrt(1 + 4*s_oo))/2
+    if s_inf != -S(1)/4:
+        return [[(1 + sqrt(1 + 4*s_inf))/2], [(1 - sqrt(1 + 4*s_inf))/2]]
+    return [[S.Half]]
+
+
+def construct_d(num, den, x, val_inf):
+    """
+    Helper function to calculate the coefficients
+    in the d-vector based on the valuation of the
+    function at oo.
+    """
+    N = -val_inf//2
+    # Multiplicity of oo as a pole
+    mul = -val_inf if val_inf < 0 else 0
+    ser = rational_laurent_series(num, den, x, oo, mul, 1)
+
+    # Case 4
+    if val_inf < 0:
+        d = construct_d_case_4(ser, N)
+
+    # Case 5
+    elif val_inf == 0:
+        d = construct_d_case_5(ser)
+
+    # Case 6
+    else:
+        d = construct_d_case_6(num, den, x)
+
+    return d
+
+
+def rational_laurent_series(num, den, x, r, m, n):
+    r"""
+    The function computes the Laurent series coefficients
+    of a rational function.
+
+    Parameters
+    ==========
+
+    num: A Poly object that is the numerator of `f(x)`.
+    den: A Poly object that is the denominator of `f(x)`.
+    x: The variable of expansion of the series.
+    r: The point of expansion of the series.
+    m: Multiplicity of r if r is a pole of `f(x)`. Should
+    be zero otherwise.
+    n: Order of the term upto which the series is expanded.
+
+    Returns
+    =======
+
+    series: A dictionary that has power of the term as key
+    and coefficient of that term as value.
+
+    Below is a basic outline of how the Laurent series of a
+    rational function `f(x)` about `x_0` is being calculated -
+
+    1. Substitute `x + x_0` in place of `x`. If `x_0`
+    is a pole of `f(x)`, multiply the expression by `x^m`
+    where `m` is the multiplicity of `x_0`. Denote the
+    the resulting expression as g(x). We do this substitution
+    so that we can now find the Laurent series of g(x) about
+    `x = 0`.
+
+    2. We can then assume that the Laurent series of `g(x)`
+    takes the following form -
+
+    .. math:: g(x) = \frac{num(x)}{den(x)} = \sum_{m = 0}^{\infty} a_m x^m
+
+    where `a_m` denotes the Laurent series coefficients.
+
+    3. Multiply the denominator to the RHS of the equation
+    and form a recurrence relation for the coefficients `a_m`.
+    """
+    one = Poly(1, x, extension=True)
+
+    if r == oo:
+        # Series at x = oo is equal to first transforming
+        # the function from x -> 1/x and finding the
+        # series at x = 0
+        num, den = inverse_transform_poly(num, den, x)
+        r = S(0)
+
+    if r:
+        # For an expansion about a non-zero point, a
+        # transformation from x -> x + r must be made
+        num = num.transform(Poly(x + r, x, extension=True), one)
+        den = den.transform(Poly(x + r, x, extension=True), one)
+
+    # Remove the pole from the denominator if the series
+    # expansion is about one of the poles
+    num, den = (num*x**m).cancel(den, include=True)
+
+    # Equate coefficients for the first terms (base case)
+    maxdegree = 1 + max(num.degree(), den.degree())
+    syms = symbols(f'a:{maxdegree}', cls=Dummy)
+    diff = num - den * Poly(syms[::-1], x)
+    coeff_diffs = diff.all_coeffs()[::-1][:maxdegree]
+    (coeffs, ) = linsolve(coeff_diffs, syms)
+
+    # Use the recursion relation for the rest
+    recursion = den.all_coeffs()[::-1]
+    div, rec_rhs = recursion[0], recursion[1:]
+    series = list(coeffs)
+    while len(series) < n:
+        next_coeff = Add(*(c*series[-1-n] for n, c in enumerate(rec_rhs))) / div
+        series.append(-next_coeff)
+    series = {m - i: val for i, val in enumerate(series)}
+    return series
+
+def compute_m_ybar(x, poles, choice, N):
+    """
+    Helper function to calculate -
+
+    1. m - The degree bound for the polynomial
+    solution that must be found for the auxiliary
+    differential equation.
+
+    2. ybar - Part of the solution which can be
+    computed using the poles, c and d vectors.
+    """
+    ybar = 0
+    m = Poly(choice[-1][-1], x, extension=True)
+
+    # Calculate the first (nested) summation for ybar
+    # as given in Step 9 of the Thesis (Pg 82)
+    dybar = []
+    for i, polei in enumerate(poles):
+        for j, cij in enumerate(choice[i]):
+            dybar.append(cij/(x - polei)**(j + 1))
+        m -=Poly(choice[i][0], x, extension=True)  # can't accumulate Poly and use with Add
+    ybar += Add(*dybar)
+
+    # Calculate the second summation for ybar
+    for i in range(N+1):
+        ybar += choice[-1][i]*x**i
+    return (m.expr, ybar)
+
+
+def solve_aux_eq(numa, dena, numy, deny, x, m):
+    """
+    Helper function to find a polynomial solution
+    of degree m for the auxiliary differential
+    equation.
+    """
+    # Assume that the solution is of the type
+    # p(x) = C_0 + C_1*x + ... + C_{m-1}*x**(m-1) + x**m
+    psyms = symbols(f'C0:{m}', cls=Dummy)
+    K = ZZ[psyms]
+    psol = Poly(K.gens, x, domain=K) + Poly(x**m, x, domain=K)
+
+    # Eq (5.16) in Thesis - Pg 81
+    auxeq = (dena*(numy.diff(x)*deny - numy*deny.diff(x) + numy**2) - numa*deny**2)*psol
+    if m >= 1:
+        px = psol.diff(x)
+        auxeq += px*(2*numy*deny*dena)
+    if m >= 2:
+        auxeq += px.diff(x)*(deny**2*dena)
+    if m != 0:
+        # m is a non-zero integer. Find the constant terms using undetermined coefficients
+        return psol, linsolve_dict(auxeq.all_coeffs(), psyms), True
+    else:
+        # m == 0 . Check if 1 (x**0) is a solution to the auxiliary equation
+        return S.One, auxeq, auxeq == 0
+
+
+def remove_redundant_sols(sol1, sol2, x):
+    """
+    Helper function to remove redundant
+    solutions to the differential equation.
+    """
+    # If y1 and y2 are redundant solutions, there is
+    # some value of the arbitrary constant for which
+    # they will be equal
+
+    syms1 = sol1.atoms(Symbol, Dummy)
+    syms2 = sol2.atoms(Symbol, Dummy)
+    num1, den1 = [Poly(e, x, extension=True) for e in sol1.together().as_numer_denom()]
+    num2, den2 = [Poly(e, x, extension=True) for e in sol2.together().as_numer_denom()]
+    # Cross multiply
+    e = num1*den2 - den1*num2
+    # Check if there are any constants
+    syms = list(e.atoms(Symbol, Dummy))
+    if len(syms):
+        # Find values of constants for which solutions are equal
+        redn = linsolve(e.all_coeffs(), syms)
+        if len(redn):
+            # Return the general solution over a particular solution
+            if len(syms1) > len(syms2):
+                return sol2
+            # If both have constants, return the lesser complex solution
+            elif len(syms1) == len(syms2):
+                return sol1 if count_ops(syms1) >= count_ops(syms2) else sol2
+            else:
+                return sol1
+
+
+def get_gen_sol_from_part_sol(part_sols, a, x):
+    """"
+    Helper function which computes the general
+    solution for a Riccati ODE from its particular
+    solutions.
+
+    There are 3 cases to find the general solution
+    from the particular solutions for a Riccati ODE
+    depending on the number of particular solution(s)
+    we have - 1, 2 or 3.
+
+    For more information, see Section 6 of
+    "Methods of Solution of the Riccati Differential Equation"
+    by D. R. Haaheim and F. M. Stein
+    """
+
+    # If no particular solutions are found, a general
+    # solution cannot be found
+    if len(part_sols) == 0:
+        return []
+
+    # In case of a single particular solution, the general
+    # solution can be found by using the substitution
+    # y = y1 + 1/z and solving a Bernoulli ODE to find z.
+    elif len(part_sols) == 1:
+        y1 = part_sols[0]
+        i = exp(Integral(2*y1, x))
+        z = i * Integral(a/i, x)
+        z = z.doit()
+        if a == 0 or z == 0:
+            return y1
+        return y1 + 1/z
+
+    # In case of 2 particular solutions, the general solution
+    # can be found by solving a separable equation. This is
+    # the most common case, i.e. most Riccati ODEs have 2
+    # rational particular solutions.
+    elif len(part_sols) == 2:
+        y1, y2 = part_sols
+        # One of them already has a constant
+        if len(y1.atoms(Dummy)) + len(y2.atoms(Dummy)) > 0:
+            u = exp(Integral(y2 - y1, x)).doit()
+        # Introduce a constant
+        else:
+            C1 = Dummy('C1')
+            u = C1*exp(Integral(y2 - y1, x)).doit()
+        if u == 1:
+            return y2
+        return (y2*u - y1)/(u - 1)
+
+    # In case of 3 particular solutions, a closed form
+    # of the general solution can be obtained directly
+    else:
+        y1, y2, y3 = part_sols[:3]
+        C1 = Dummy('C1')
+        return (C1 + 1)*y2*(y1 - y3)/(C1*y1 + y2 - (C1 + 1)*y3)
+
+
+def solve_riccati(fx, x, b0, b1, b2, gensol=False):
+    """
+    The main function that gives particular/general
+    solutions to Riccati ODEs that have atleast 1
+    rational particular solution.
+    """
+    # Step 1 : Convert to Normal Form
+    a = -b0*b2 + b1**2/4 - b1.diff(x)/2 + 3*b2.diff(x)**2/(4*b2**2) + b1*b2.diff(x)/(2*b2) - \
+        b2.diff(x, 2)/(2*b2)
+    a_t = a.together()
+    num, den = [Poly(e, x, extension=True) for e in a_t.as_numer_denom()]
+    num, den = num.cancel(den, include=True)
+
+    # Step 2
+    presol = []
+
+    # Step 3 : a(x) is 0
+    if num == 0:
+        presol.append(1/(x + Dummy('C1')))
+
+    # Step 4 : a(x) is a non-zero constant
+    elif x not in num.free_symbols.union(den.free_symbols):
+        presol.extend([sqrt(a), -sqrt(a)])
+
+    # Step 5 : Find poles and valuation at infinity
+    poles = roots(den, x)
+    poles, muls = list(poles.keys()), list(poles.values())
+    val_inf = val_at_inf(num, den, x)
+
+    if len(poles):
+        # Check necessary conditions (outlined in the module docstring)
+        if not check_necessary_conds(val_inf, muls):
+            raise ValueError("Rational Solution doesn't exist")
+
+        # Step 6
+        # Construct c-vectors for each singular point
+        c = construct_c(num, den, x, poles, muls)
+
+        # Construct d vectors for each singular point
+        d = construct_d(num, den, x, val_inf)
+
+        # Step 7 : Iterate over all possible combinations and return solutions
+        # For each possible combination, generate an array of 0's and 1's
+        # where 0 means pick 1st choice and 1 means pick the second choice.
+
+        # NOTE: We could exit from the loop if we find 3 particular solutions,
+        # but it is not implemented here as -
+        #   a. Finding 3 particular solutions is very rare. Most of the time,
+        #      only 2 particular solutions are found.
+        #   b. In case we exit after finding 3 particular solutions, it might
+        #      happen that 1 or 2 of them are redundant solutions. So, instead of
+        #      spending some more time in computing the particular solutions,
+        #      we will end up computing the general solution from a single
+        #      particular solution which is usually slower than computing the
+        #      general solution from 2 or 3 particular solutions.
+        c.append(d)
+        choices = product(*c)
+        for choice in choices:
+            m, ybar = compute_m_ybar(x, poles, choice, -val_inf//2)
+            numy, deny = [Poly(e, x, extension=True) for e in ybar.together().as_numer_denom()]
+            # Step 10 : Check if a valid solution exists. If yes, also check
+            # if m is a non-negative integer
+            if m.is_nonnegative == True and m.is_integer == True:
+
+                # Step 11 : Find polynomial solutions of degree m for the auxiliary equation
+                psol, coeffs, exists = solve_aux_eq(num, den, numy, deny, x, m)
+
+                # Step 12 : If valid polynomial solution exists, append solution.
+                if exists:
+                    # m == 0 case
+                    if psol == 1 and coeffs == 0:
+                        # p(x) = 1, so p'(x)/p(x) term need not be added
+                        presol.append(ybar)
+                    # m is a positive integer and there are valid coefficients
+                    elif len(coeffs):
+                        # Substitute the valid coefficients to get p(x)
+                        psol = psol.xreplace(coeffs)
+                        # y(x) = ybar(x) + p'(x)/p(x)
+                        presol.append(ybar + psol.diff(x)/psol)
+
+    # Remove redundant solutions from the list of existing solutions
+    remove = set()
+    for i in range(len(presol)):
+        for j in range(i+1, len(presol)):
+            rem = remove_redundant_sols(presol[i], presol[j], x)
+            if rem is not None:
+                remove.add(rem)
+    sols = [x for x in presol if x not in remove]
+
+    # Step 15 : Inverse transform the solutions of the equation in normal form
+    bp = -b2.diff(x)/(2*b2**2) - b1/(2*b2)
+
+    # If general solution is required, compute it from the particular solutions
+    if gensol:
+        sols = [get_gen_sol_from_part_sol(sols, a, x)]
+
+    # Inverse transform the particular solutions
+    presol = [Eq(fx, riccati_inverse_normal(y, x, b1, b2, bp).cancel(extension=True)) for y in sols]
+    return presol

pllava/lib/python3.10/site-packages/sympy/solvers/ode/subscheck.py

@@ -0,0 +1,392 @@
+from sympy.core import S, Pow
+from sympy.core.function import (Derivative, AppliedUndef, diff)
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+
+from sympy.logic.boolalg import BooleanAtom
+from sympy.functions import exp
+from sympy.series import Order
+from sympy.simplify.simplify import simplify, posify, besselsimp
+from sympy.simplify.trigsimp import trigsimp
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.solvers import solve
+from sympy.solvers.deutils import _preprocess, ode_order
+from sympy.utilities.iterables import iterable, is_sequence
+
+
+def sub_func_doit(eq, func, new):
+    r"""
+    When replacing the func with something else, we usually want the
+    derivative evaluated, so this function helps in making that happen.
+
+    Examples
+    ========
+
+    >>> from sympy import Derivative, symbols, Function
+    >>> from sympy.solvers.ode.subscheck import sub_func_doit
+    >>> x, z = symbols('x, z')
+    >>> y = Function('y')
+
+    >>> sub_func_doit(3*Derivative(y(x), x) - 1, y(x), x)
+    2
+
+    >>> sub_func_doit(x*Derivative(y(x), x) - y(x)**2 + y(x), y(x),
+    ... 1/(x*(z + 1/x)))
+    x*(-1/(x**2*(z + 1/x)) + 1/(x**3*(z + 1/x)**2)) + 1/(x*(z + 1/x))
+    ...- 1/(x**2*(z + 1/x)**2)
+    """
+    reps= {func: new}
+    for d in eq.atoms(Derivative):
+        if d.expr == func:
+            reps[d] = new.diff(*d.variable_count)
+        else:
+            reps[d] = d.xreplace({func: new}).doit(deep=False)
+    return eq.xreplace(reps)
+
+
+def checkodesol(ode, sol, func=None, order='auto', solve_for_func=True):
+    r"""
+    Substitutes ``sol`` into ``ode`` and checks that the result is ``0``.
+
+    This works when ``func`` is one function, like `f(x)` or a list of
+    functions like `[f(x), g(x)]` when `ode` is a system of ODEs.  ``sol`` can
+    be a single solution or a list of solutions.  Each solution may be an
+    :py:class:`~sympy.core.relational.Equality` that the solution satisfies,
+    e.g. ``Eq(f(x), C1), Eq(f(x) + C1, 0)``; or simply an
+    :py:class:`~sympy.core.expr.Expr`, e.g. ``f(x) - C1``. In most cases it
+    will not be necessary to explicitly identify the function, but if the
+    function cannot be inferred from the original equation it can be supplied
+    through the ``func`` argument.
+
+    If a sequence of solutions is passed, the same sort of container will be
+    used to return the result for each solution.
+
+    It tries the following methods, in order, until it finds zero equivalence:
+
+    1. Substitute the solution for `f` in the original equation.  This only
+       works if ``ode`` is solved for `f`.  It will attempt to solve it first
+       unless ``solve_for_func == False``.
+    2. Take `n` derivatives of the solution, where `n` is the order of
+       ``ode``, and check to see if that is equal to the solution.  This only
+       works on exact ODEs.
+    3. Take the 1st, 2nd, ..., `n`\th derivatives of the solution, each time
+       solving for the derivative of `f` of that order (this will always be
+       possible because `f` is a linear operator). Then back substitute each
+       derivative into ``ode`` in reverse order.
+
+    This function returns a tuple.  The first item in the tuple is ``True`` if
+    the substitution results in ``0``, and ``False`` otherwise. The second
+    item in the tuple is what the substitution results in.  It should always
+    be ``0`` if the first item is ``True``. Sometimes this function will
+    return ``False`` even when an expression is identically equal to ``0``.
+    This happens when :py:meth:`~sympy.simplify.simplify.simplify` does not
+    reduce the expression to ``0``.  If an expression returned by this
+    function vanishes identically, then ``sol`` really is a solution to
+    the ``ode``.
+
+    If this function seems to hang, it is probably because of a hard
+    simplification.
+
+    To use this function to test, test the first item of the tuple.
+
+    Examples
+    ========
+
+    >>> from sympy import (Eq, Function, checkodesol, symbols,
+    ...     Derivative, exp)
+    >>> x, C1, C2 = symbols('x,C1,C2')
+    >>> f, g = symbols('f g', cls=Function)
+    >>> checkodesol(f(x).diff(x), Eq(f(x), C1))
+    (True, 0)
+    >>> assert checkodesol(f(x).diff(x), C1)[0]
+    >>> assert not checkodesol(f(x).diff(x), x)[0]
+    >>> checkodesol(f(x).diff(x, 2), x**2)
+    (False, 2)
+
+    >>> eqs = [Eq(Derivative(f(x), x), f(x)), Eq(Derivative(g(x), x), g(x))]
+    >>> sol = [Eq(f(x), C1*exp(x)), Eq(g(x), C2*exp(x))]
+    >>> checkodesol(eqs, sol)
+    (True, [0, 0])
+
+    """
+    if iterable(ode):
+        return checksysodesol(ode, sol, func=func)
+
+    if not isinstance(ode, Equality):
+        ode = Eq(ode, 0)
+    if func is None:
+        try:
+            _, func = _preprocess(ode.lhs)
+        except ValueError:
+            funcs = [s.atoms(AppliedUndef) for s in (
+                sol if is_sequence(sol, set) else [sol])]
+            funcs = set().union(*funcs)
+            if len(funcs) != 1:
+                raise ValueError(
+                    'must pass func arg to checkodesol for this case.')
+            func = funcs.pop()
+    if not isinstance(func, AppliedUndef) or len(func.args) != 1:
+        raise ValueError(
+            "func must be a function of one variable, not %s" % func)
+    if is_sequence(sol, set):
+        return type(sol)([checkodesol(ode, i, order=order, solve_for_func=solve_for_func) for i in sol])
+
+    if not isinstance(sol, Equality):
+        sol = Eq(func, sol)
+    elif sol.rhs == func:
+        sol = sol.reversed
+
+    if order == 'auto':
+        order = ode_order(ode, func)
+    solved = sol.lhs == func and not sol.rhs.has(func)
+    if solve_for_func and not solved:
+        rhs = solve(sol, func)
+        if rhs:
+            eqs = [Eq(func, t) for t in rhs]
+            if len(rhs) == 1:
+                eqs = eqs[0]
+            return checkodesol(ode, eqs, order=order,
+                solve_for_func=False)
+
+    x = func.args[0]
+
+    # Handle series solutions here
+    if sol.has(Order):
+        assert sol.lhs == func
+        Oterm = sol.rhs.getO()
+        solrhs = sol.rhs.removeO()
+
+        Oexpr = Oterm.expr
+        assert isinstance(Oexpr, Pow)
+        sorder = Oexpr.exp
+        assert Oterm == Order(x**sorder)
+
+        odesubs = (ode.lhs-ode.rhs).subs(func, solrhs).doit().expand()
+
+        neworder = Order(x**(sorder - order))
+        odesubs = odesubs + neworder
+        assert odesubs.getO() == neworder
+        residual = odesubs.removeO()
+
+        return (residual == 0, residual)
+
+    s = True
+    testnum = 0
+    while s:
+        if testnum == 0:
+            # First pass, try substituting a solved solution directly into the
+            # ODE. This has the highest chance of succeeding.
+            ode_diff = ode.lhs - ode.rhs
+
+            if sol.lhs == func:
+                s = sub_func_doit(ode_diff, func, sol.rhs)
+                s = besselsimp(s)
+            else:
+                testnum += 1
+                continue
+            ss = simplify(s.rewrite(exp))
+            if ss:
+                # with the new numer_denom in power.py, if we do a simple
+                # expansion then testnum == 0 verifies all solutions.
+                s = ss.expand(force=True)
+            else:
+                s = 0
+            testnum += 1
+        elif testnum == 1:
+            # Second pass. If we cannot substitute f, try seeing if the nth
+            # derivative is equal, this will only work for odes that are exact,
+            # by definition.
+            s = simplify(
+                trigsimp(diff(sol.lhs, x, order) - diff(sol.rhs, x, order)) -
+                trigsimp(ode.lhs) + trigsimp(ode.rhs))
+            # s2 = simplify(
+            #     diff(sol.lhs, x, order) - diff(sol.rhs, x, order) - \
+            #     ode.lhs + ode.rhs)
+            testnum += 1
+        elif testnum == 2:
+            # Third pass. Try solving for df/dx and substituting that into the
+            # ODE. Thanks to Chris Smith for suggesting this method.  Many of
+            # the comments below are his, too.
+            # The method:
+            # - Take each of 1..n derivatives of the solution.
+            # - Solve each nth derivative for d^(n)f/dx^(n)
+            #   (the differential of that order)
+            # - Back substitute into the ODE in decreasing order
+            #   (i.e., n, n-1, ...)
+            # - Check the result for zero equivalence
+            if sol.lhs == func and not sol.rhs.has(func):
+                diffsols = {0: sol.rhs}
+            elif sol.rhs == func and not sol.lhs.has(func):
+                diffsols = {0: sol.lhs}
+            else:
+                diffsols = {}
+            sol = sol.lhs - sol.rhs
+            for i in range(1, order + 1):
+                # Differentiation is a linear operator, so there should always
+                # be 1 solution. Nonetheless, we test just to make sure.
+                # We only need to solve once.  After that, we automatically
+                # have the solution to the differential in the order we want.
+                if i == 1:
+                    ds = sol.diff(x)
+                    try:
+                        sdf = solve(ds, func.diff(x, i))
+                        if not sdf:
+                            raise NotImplementedError
+                    except NotImplementedError:
+                        testnum += 1
+                        break
+                    else:
+                        diffsols[i] = sdf[0]
+                else:
+                    # This is what the solution says df/dx should be.
+                    diffsols[i] = diffsols[i - 1].diff(x)
+
+            # Make sure the above didn't fail.
+            if testnum > 2:
+                continue
+            else:
+                # Substitute it into ODE to check for self consistency.
+                lhs, rhs = ode.lhs, ode.rhs
+                for i in range(order, -1, -1):
+                    if i == 0 and 0 not in diffsols:
+                        # We can only substitute f(x) if the solution was
+                        # solved for f(x).
+                        break
+                    lhs = sub_func_doit(lhs, func.diff(x, i), diffsols[i])
+                    rhs = sub_func_doit(rhs, func.diff(x, i), diffsols[i])
+                    ode_or_bool = Eq(lhs, rhs)
+                    ode_or_bool = simplify(ode_or_bool)
+
+                    if isinstance(ode_or_bool, (bool, BooleanAtom)):
+                        if ode_or_bool:
+                            lhs = rhs = S.Zero
+                    else:
+                        lhs = ode_or_bool.lhs
+                        rhs = ode_or_bool.rhs
+                # No sense in overworking simplify -- just prove that the
+                # numerator goes to zero
+                num = trigsimp((lhs - rhs).as_numer_denom()[0])
+                # since solutions are obtained using force=True we test
+                # using the same level of assumptions
+                ## replace function with dummy so assumptions will work
+                _func = Dummy('func')
+                num = num.subs(func, _func)
+                ## posify the expression
+                num, reps = posify(num)
+                s = simplify(num).xreplace(reps).xreplace({_func: func})
+                testnum += 1
+        else:
+            break
+
+    if not s:
+        return (True, s)
+    elif s is True:  # The code above never was able to change s
+        raise NotImplementedError("Unable to test if " + str(sol) +
+            " is a solution to " + str(ode) + ".")
+    else:
+        return (False, s)
+
+
+def checksysodesol(eqs, sols, func=None):
+    r"""
+    Substitutes corresponding ``sols`` for each functions into each ``eqs`` and
+    checks that the result of substitutions for each equation is ``0``. The
+    equations and solutions passed can be any iterable.
+
+    This only works when each ``sols`` have one function only, like `x(t)` or `y(t)`.
+    For each function, ``sols`` can have a single solution or a list of solutions.
+    In most cases it will not be necessary to explicitly identify the function,
+    but if the function cannot be inferred from the original equation it
+    can be supplied through the ``func`` argument.
+
+    When a sequence of equations is passed, the same sequence is used to return
+    the result for each equation with each function substituted with corresponding
+    solutions.
+
+    It tries the following method to find zero equivalence for each equation:
+
+    Substitute the solutions for functions, like `x(t)` and `y(t)` into the
+    original equations containing those functions.
+    This function returns a tuple.  The first item in the tuple is ``True`` if
+    the substitution results for each equation is ``0``, and ``False`` otherwise.
+    The second item in the tuple is what the substitution results in.  Each element
+    of the ``list`` should always be ``0`` corresponding to each equation if the
+    first item is ``True``. Note that sometimes this function may return ``False``,
+    but with an expression that is identically equal to ``0``, instead of returning
+    ``True``.  This is because :py:meth:`~sympy.simplify.simplify.simplify` cannot
+    reduce the expression to ``0``.  If an expression returned by each function
+    vanishes identically, then ``sols`` really is a solution to ``eqs``.
+
+    If this function seems to hang, it is probably because of a difficult simplification.
+
+    Examples
+    ========
+
+    >>> from sympy import Eq, diff, symbols, sin, cos, exp, sqrt, S, Function
+    >>> from sympy.solvers.ode.subscheck import checksysodesol
+    >>> C1, C2 = symbols('C1:3')
+    >>> t = symbols('t')
+    >>> x, y = symbols('x, y', cls=Function)
+    >>> eq = (Eq(diff(x(t),t), x(t) + y(t) + 17), Eq(diff(y(t),t), -2*x(t) + y(t) + 12))
+    >>> sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - S(5)/3),
+    ... Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - S(46)/3)]
+    >>> checksysodesol(eq, sol)
+    (True, [0, 0])
+    >>> eq = (Eq(diff(x(t),t),x(t)*y(t)**4), Eq(diff(y(t),t),y(t)**3))
+    >>> sol = [Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), -sqrt(2)*sqrt(-1/(C2 + t))/2),
+    ... Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), sqrt(2)*sqrt(-1/(C2 + t))/2)]
+    >>> checksysodesol(eq, sol)
+    (True, [0, 0])
+
+    """
+    def _sympify(eq):
+        return list(map(sympify, eq if iterable(eq) else [eq]))
+    eqs = _sympify(eqs)
+    for i in range(len(eqs)):
+        if isinstance(eqs[i], Equality):
+            eqs[i] = eqs[i].lhs - eqs[i].rhs
+    if func is None:
+        funcs = []
+        for eq in eqs:
+            derivs = eq.atoms(Derivative)
+            func = set().union(*[d.atoms(AppliedUndef) for d in derivs])
+            funcs.extend(func)
+        funcs = list(set(funcs))
+    if not all(isinstance(func, AppliedUndef) and len(func.args) == 1 for func in funcs)\
+    and len({func.args for func in funcs})!=1:
+        raise ValueError("func must be a function of one variable, not %s" % func)
+    for sol in sols:
+        if len(sol.atoms(AppliedUndef)) != 1:
+            raise ValueError("solutions should have one function only")
+    if len(funcs) != len({sol.lhs for sol in sols}):
+        raise ValueError("number of solutions provided does not match the number of equations")
+    dictsol = {}
+    for sol in sols:
+        func = list(sol.atoms(AppliedUndef))[0]
+        if sol.rhs == func:
+            sol = sol.reversed
+        solved = sol.lhs == func and not sol.rhs.has(func)
+        if not solved:
+            rhs = solve(sol, func)
+            if not rhs:
+                raise NotImplementedError
+        else:
+            rhs = sol.rhs
+        dictsol[func] = rhs
+    checkeq = []
+    for eq in eqs:
+        for func in funcs:
+            eq = sub_func_doit(eq, func, dictsol[func])
+        ss = simplify(eq)
+        if ss != 0:
+            eq = ss.expand(force=True)
+            if eq != 0:
+                eq = sqrtdenest(eq).simplify()
+        else:
+            eq = 0
+        checkeq.append(eq)
+    if len(set(checkeq)) == 1 and list(set(checkeq))[0] == 0:
+        return (True, checkeq)
+    else:
+        return (False, checkeq)

pllava/lib/python3.10/site-packages/sympy/solvers/ode/systems.py

@@ -0,0 +1,2135 @@
+from sympy.core import Add, Mul, S
+from sympy.core.containers import Tuple
+from sympy.core.exprtools import factor_terms
+from sympy.core.numbers import I
+from sympy.core.relational import Eq, Equality
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Dummy, Symbol
+from sympy.core.function import (expand_mul, expand, Derivative,
+                                 AppliedUndef, Function, Subs)
+from sympy.functions import (exp, im, cos, sin, re, Piecewise,
+                             piecewise_fold, sqrt, log)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.matrices import zeros, Matrix, NonSquareMatrixError, MatrixBase, eye
+from sympy.polys import Poly, together
+from sympy.simplify import collect, radsimp, signsimp # type: ignore
+from sympy.simplify.powsimp import powdenest, powsimp
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import simplify
+from sympy.sets.sets import FiniteSet
+from sympy.solvers.deutils import ode_order
+from sympy.solvers.solveset import NonlinearError, solveset
+from sympy.utilities.iterables import (connected_components, iterable,
+                                       strongly_connected_components)
+from sympy.utilities.misc import filldedent
+from sympy.integrals.integrals import Integral, integrate
+
+
+def _get_func_order(eqs, funcs):
+    return {func: max(ode_order(eq, func) for eq in eqs) for func in funcs}
+
+
+class ODEOrderError(ValueError):
+    """Raised by linear_ode_to_matrix if the system has the wrong order"""
+    pass
+
+
+class ODENonlinearError(NonlinearError):
+    """Raised by linear_ode_to_matrix if the system is nonlinear"""
+    pass
+
+
+def _simpsol(soleq):
+    lhs = soleq.lhs
+    sol = soleq.rhs
+    sol = powsimp(sol)
+    gens = list(sol.atoms(exp))
+    p = Poly(sol, *gens, expand=False)
+    gens = [factor_terms(g) for g in gens]
+    if not gens:
+        gens = p.gens
+    syms = [Symbol('C1'), Symbol('C2')]
+    terms = []
+    for coeff, monom in zip(p.coeffs(), p.monoms()):
+        coeff = piecewise_fold(coeff)
+        if isinstance(coeff, Piecewise):
+            coeff = Piecewise(*((ratsimp(coef).collect(syms), cond) for coef, cond in coeff.args))
+        else:
+            coeff = ratsimp(coeff).collect(syms)
+        monom = Mul(*(g ** i for g, i in zip(gens, monom)))
+        terms.append(coeff * monom)
+    return Eq(lhs, Add(*terms))
+
+
+def _solsimp(e, t):
+    no_t, has_t = powsimp(expand_mul(e)).as_independent(t)
+
+    no_t = ratsimp(no_t)
+    has_t = has_t.replace(exp, lambda a: exp(factor_terms(a)))
+
+    return no_t + has_t
+
+
+def simpsol(sol, wrt1, wrt2, doit=True):
+    """Simplify solutions from dsolve_system."""
+
+    # The parameter sol is the solution as returned by dsolve (list of Eq).
+    #
+    # The parameters wrt1 and wrt2 are lists of symbols to be collected for
+    # with those in wrt1 being collected for first. This allows for collecting
+    # on any factors involving the independent variable before collecting on
+    # the integration constants or vice versa using e.g.:
+    #
+    #     sol = simpsol(sol, [t], [C1, C2])  # t first, constants after
+    #     sol = simpsol(sol, [C1, C2], [t])  # constants first, t after
+    #
+    # If doit=True (default) then simpsol will begin by evaluating any
+    # unevaluated integrals. Since many integrals will appear multiple times
+    # in the solutions this is done intelligently by computing each integral
+    # only once.
+    #
+    # The strategy is to first perform simple cancellation with factor_terms
+    # and then multiply out all brackets with expand_mul. This gives an Add
+    # with many terms.
+    #
+    # We split each term into two multiplicative factors dep and coeff where
+    # all factors that involve wrt1 are in dep and any constant factors are in
+    # coeff e.g.
+    #         sqrt(2)*C1*exp(t) -> ( exp(t), sqrt(2)*C1 )
+    #
+    # The dep factors are simplified using powsimp to combine expanded
+    # exponential factors e.g.
+    #              exp(a*t)*exp(b*t) -> exp(t*(a+b))
+    #
+    # We then collect coefficients for all terms having the same (simplified)
+    # dep. The coefficients are then simplified using together and ratsimp and
+    # lastly by recursively applying the same transformation to the
+    # coefficients to collect on wrt2.
+    #
+    # Finally the result is recombined into an Add and signsimp is used to
+    # normalise any minus signs.
+
+    def simprhs(rhs, rep, wrt1, wrt2):
+        """Simplify the rhs of an ODE solution"""
+        if rep:
+            rhs = rhs.subs(rep)
+        rhs = factor_terms(rhs)
+        rhs = simp_coeff_dep(rhs, wrt1, wrt2)
+        rhs = signsimp(rhs)
+        return rhs
+
+    def simp_coeff_dep(expr, wrt1, wrt2=None):
+        """Split rhs into terms, split terms into dep and coeff and collect on dep"""
+        add_dep_terms = lambda e: e.is_Add and e.has(*wrt1)
+        expandable = lambda e: e.is_Mul and any(map(add_dep_terms, e.args))
+        expand_func = lambda e: expand_mul(e, deep=False)
+        expand_mul_mod = lambda e: e.replace(expandable, expand_func)
+        terms = Add.make_args(expand_mul_mod(expr))
+        dc = {}
+        for term in terms:
+            coeff, dep = term.as_independent(*wrt1, as_Add=False)
+            # Collect together the coefficients for terms that have the same
+            # dependence on wrt1 (after dep is normalised using simpdep).
+            dep = simpdep(dep, wrt1)
+
+            # See if the dependence on t cancels out...
+            if dep is not S.One:
+                dep2 = factor_terms(dep)
+                if not dep2.has(*wrt1):
+                    coeff *= dep2
+                    dep = S.One
+
+            if dep not in dc:
+                dc[dep] = coeff
+            else:
+                dc[dep] += coeff
+        # Apply the method recursively to the coefficients but this time
+        # collecting on wrt2 rather than wrt2.
+        termpairs = ((simpcoeff(c, wrt2), d) for d, c in dc.items())
+        if wrt2 is not None:
+            termpairs = ((simp_coeff_dep(c, wrt2), d) for c, d in termpairs)
+        return Add(*(c * d for c, d in termpairs))
+
+    def simpdep(term, wrt1):
+        """Normalise factors involving t with powsimp and recombine exp"""
+        def canonicalise(a):
+            # Using factor_terms here isn't quite right because it leads to things
+            # like exp(t*(1+t)) that we don't want. We do want to cancel factors
+            # and pull out a common denominator but ideally the numerator would be
+            # expressed as a standard form polynomial in t so we expand_mul
+            # and collect afterwards.
+            a = factor_terms(a)
+            num, den = a.as_numer_denom()
+            num = expand_mul(num)
+            num = collect(num, wrt1)
+            return num / den
+
+        term = powsimp(term)
+        rep = {e: exp(canonicalise(e.args[0])) for e in term.atoms(exp)}
+        term = term.subs(rep)
+        return term
+
+    def simpcoeff(coeff, wrt2):
+        """Bring to a common fraction and cancel with ratsimp"""
+        coeff = together(coeff)
+        if coeff.is_polynomial():
+            # Calling ratsimp can be expensive. The main reason is to simplify
+            # sums of terms with irrational denominators so we limit ourselves
+            # to the case where the expression is polynomial in any symbols.
+            # Maybe there's a better approach...
+            coeff = ratsimp(radsimp(coeff))
+        # collect on secondary variables first and any remaining symbols after
+        if wrt2 is not None:
+            syms = list(wrt2) + list(ordered(coeff.free_symbols - set(wrt2)))
+        else:
+            syms = list(ordered(coeff.free_symbols))
+        coeff = collect(coeff, syms)
+        coeff = together(coeff)
+        return coeff
+
+    # There are often repeated integrals. Collect unique integrals and
+    # evaluate each once and then substitute into the final result to replace
+    # all occurrences in each of the solution equations.
+    if doit:
+        integrals = set().union(*(s.atoms(Integral) for s in sol))
+        rep = {i: factor_terms(i).doit() for i in integrals}
+    else:
+        rep = {}
+
+    sol = [Eq(s.lhs, simprhs(s.rhs, rep, wrt1, wrt2)) for s in sol]
+    return sol
+
+
+def linodesolve_type(A, t, b=None):
+    r"""
+    Helper function that determines the type of the system of ODEs for solving with :obj:`sympy.solvers.ode.systems.linodesolve()`
+
+    Explanation
+    ===========
+
+    This function takes in the coefficient matrix and/or the non-homogeneous term
+    and returns the type of the equation that can be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`.
+
+    If the system is constant coefficient homogeneous, then "type1" is returned
+
+    If the system is constant coefficient non-homogeneous, then "type2" is returned
+
+    If the system is non-constant coefficient homogeneous, then "type3" is returned
+
+    If the system is non-constant coefficient non-homogeneous, then "type4" is returned
+
+    If the system has a non-constant coefficient matrix which can be factorized into constant
+    coefficient matrix, then "type5" or "type6" is returned for when the system is homogeneous or
+    non-homogeneous respectively.
+
+    Note that, if the system of ODEs is of "type3" or "type4", then along with the type,
+    the commutative antiderivative of the coefficient matrix is also returned.
+
+    If the system cannot be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`, then
+    NotImplementedError is raised.
+
+    Parameters
+    ==========
+
+    A : Matrix
+        Coefficient matrix of the system of ODEs
+    b : Matrix or None
+        Non-homogeneous term of the system. The default value is None.
+        If this argument is None, then the system is assumed to be homogeneous.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Matrix
+    >>> from sympy.solvers.ode.systems import linodesolve_type
+    >>> t = symbols("t")
+    >>> A = Matrix([[1, 1], [2, 3]])
+    >>> b = Matrix([t, 1])
+
+    >>> linodesolve_type(A, t)
+    {'antiderivative': None, 'type_of_equation': 'type1'}
+
+    >>> linodesolve_type(A, t, b=b)
+    {'antiderivative': None, 'type_of_equation': 'type2'}
+
+    >>> A_t = Matrix([[1, t], [-t, 1]])
+
+    >>> linodesolve_type(A_t, t)
+    {'antiderivative': Matrix([
+    [      t, t**2/2],
+    [-t**2/2,      t]]), 'type_of_equation': 'type3'}
+
+    >>> linodesolve_type(A_t, t, b=b)
+    {'antiderivative': Matrix([
+    [      t, t**2/2],
+    [-t**2/2,      t]]), 'type_of_equation': 'type4'}
+
+    >>> A_non_commutative = Matrix([[1, t], [t, -1]])
+    >>> linodesolve_type(A_non_commutative, t)
+    Traceback (most recent call last):
+    ...
+    NotImplementedError:
+    The system does not have a commutative antiderivative, it cannot be
+    solved by linodesolve.
+
+    Returns
+    =======
+
+    Dict
+
+    Raises
+    ======
+
+    NotImplementedError
+        When the coefficient matrix does not have a commutative antiderivative
+
+    See Also
+    ========
+
+    linodesolve: Function for which linodesolve_type gets the information
+
+    """
+
+    match = {}
+    is_non_constant = not _matrix_is_constant(A, t)
+    is_non_homogeneous = not (b is None or b.is_zero_matrix)
+    type = "type{}".format(int("{}{}".format(int(is_non_constant), int(is_non_homogeneous)), 2) + 1)
+
+    B = None
+    match.update({"type_of_equation": type, "antiderivative": B})
+
+    if is_non_constant:
+        B, is_commuting = _is_commutative_anti_derivative(A, t)
+        if not is_commuting:
+            raise NotImplementedError(filldedent('''
+                The system does not have a commutative antiderivative, it cannot be solved
+                by linodesolve.
+            '''))
+
+        match['antiderivative'] = B
+        match.update(_first_order_type5_6_subs(A, t, b=b))
+
+    return match
+
+
+def _first_order_type5_6_subs(A, t, b=None):
+    match = {}
+
+    factor_terms = _factor_matrix(A, t)
+    is_homogeneous = b is None or b.is_zero_matrix
+
+    if factor_terms is not None:
+        t_ = Symbol("{}_".format(t))
+        F_t = integrate(factor_terms[0], t)
+        inverse = solveset(Eq(t_, F_t), t)
+
+        # Note: A simple way to check if a function is invertible
+        # or not.
+        if isinstance(inverse, FiniteSet) and not inverse.has(Piecewise)\
+            and len(inverse) == 1:
+
+            A = factor_terms[1]
+            if not is_homogeneous:
+                b = b / factor_terms[0]
+                b = b.subs(t, list(inverse)[0])
+            type = "type{}".format(5 + (not is_homogeneous))
+            match.update({'func_coeff': A, 'tau': F_t,
+                          't_': t_, 'type_of_equation': type, 'rhs': b})
+
+    return match
+
+
+def linear_ode_to_matrix(eqs, funcs, t, order):
+    r"""
+    Convert a linear system of ODEs to matrix form
+
+    Explanation
+    ===========
+
+    Express a system of linear ordinary differential equations as a single
+    matrix differential equation [1]. For example the system $x' = x + y + 1$
+    and $y' = x - y$ can be represented as
+
+    .. math:: A_1 X' = A_0 X + b
+
+    where $A_1$ and $A_0$ are $2 \times 2$ matrices and $b$, $X$ and $X'$ are
+    $2 \times 1$ matrices with $X = [x, y]^T$.
+
+    Higher-order systems are represented with additional matrices e.g. a
+    second-order system would look like
+
+    .. math:: A_2 X'' =  A_1 X' + A_0 X  + b
+
+    Examples
+    ========
+
+    >>> from sympy import Function, Symbol, Matrix, Eq
+    >>> from sympy.solvers.ode.systems import linear_ode_to_matrix
+    >>> t = Symbol('t')
+    >>> x = Function('x')
+    >>> y = Function('y')
+
+    We can create a system of linear ODEs like
+
+    >>> eqs = [
+    ...     Eq(x(t).diff(t), x(t) + y(t) + 1),
+    ...     Eq(y(t).diff(t), x(t) - y(t)),
+    ... ]
+    >>> funcs = [x(t), y(t)]
+    >>> order = 1 # 1st order system
+
+    Now ``linear_ode_to_matrix`` can represent this as a matrix
+    differential equation.
+
+    >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, order)
+    >>> A1
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> A0
+    Matrix([
+    [1, 1],
+    [1,  -1]])
+    >>> b
+    Matrix([
+    [1],
+    [0]])
+
+    The original equations can be recovered from these matrices:
+
+    >>> eqs_mat = Matrix([eq.lhs - eq.rhs for eq in eqs])
+    >>> X = Matrix(funcs)
+    >>> A1 * X.diff(t) - A0 * X - b == eqs_mat
+    True
+
+    If the system of equations has a maximum order greater than the
+    order of the system specified, a ODEOrderError exception is raised.
+
+    >>> eqs = [Eq(x(t).diff(t, 2), x(t).diff(t) + x(t)), Eq(y(t).diff(t), y(t) + x(t))]
+    >>> linear_ode_to_matrix(eqs, funcs, t, 1)
+    Traceback (most recent call last):
+    ...
+    ODEOrderError: Cannot represent system in 1-order form
+
+    If the system of equations is nonlinear, then ODENonlinearError is
+    raised.
+
+    >>> eqs = [Eq(x(t).diff(t), x(t) + y(t)), Eq(y(t).diff(t), y(t)**2 + x(t))]
+    >>> linear_ode_to_matrix(eqs, funcs, t, 1)
+    Traceback (most recent call last):
+    ...
+    ODENonlinearError: The system of ODEs is nonlinear.
+
+    Parameters
+    ==========
+
+    eqs : list of SymPy expressions or equalities
+        The equations as expressions (assumed equal to zero).
+    funcs : list of applied functions
+        The dependent variables of the system of ODEs.
+    t : symbol
+        The independent variable.
+    order : int
+        The order of the system of ODEs.
+
+    Returns
+    =======
+
+    The tuple ``(As, b)`` where ``As`` is a tuple of matrices and ``b`` is the
+    the matrix representing the rhs of the matrix equation.
+
+    Raises
+    ======
+
+    ODEOrderError
+        When the system of ODEs have an order greater than what was specified
+    ODENonlinearError
+        When the system of ODEs is nonlinear
+
+    See Also
+    ========
+
+    linear_eq_to_matrix: for systems of linear algebraic equations.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_differential_equation
+
+    """
+    from sympy.solvers.solveset import linear_eq_to_matrix
+
+    if any(ode_order(eq, func) > order for eq in eqs for func in funcs):
+        msg = "Cannot represent system in {}-order form"
+        raise ODEOrderError(msg.format(order))
+
+    As = []
+
+    for o in range(order, -1, -1):
+        # Work from the highest derivative down
+        syms = [func.diff(t, o) for func in funcs]
+
+        # Ai is the matrix for X(t).diff(t, o)
+        # eqs is minus the remainder of the equations.
+        try:
+            Ai, b = linear_eq_to_matrix(eqs, syms)
+        except NonlinearError:
+            raise ODENonlinearError("The system of ODEs is nonlinear.")
+
+        Ai = Ai.applyfunc(expand_mul)
+
+        As.append(Ai if o == order else -Ai)
+
+        if o:
+            eqs = [-eq for eq in b]
+        else:
+            rhs = b
+
+    return As, rhs
+
+
+def matrix_exp(A, t):
+    r"""
+    Matrix exponential $\exp(A*t)$ for the matrix ``A`` and scalar ``t``.
+
+    Explanation
+    ===========
+
+    This functions returns the $\exp(A*t)$ by doing a simple
+    matrix multiplication:
+
+    .. math:: \exp(A*t) = P * expJ * P^{-1}
+
+    where $expJ$ is $\exp(J*t)$. $J$ is the Jordan normal
+    form of $A$ and $P$ is matrix such that:
+
+    .. math:: A = P * J * P^{-1}
+
+    The matrix exponential $\exp(A*t)$ appears in the solution of linear
+    differential equations. For example if $x$ is a vector and $A$ is a matrix
+    then the initial value problem
+
+    .. math:: \frac{dx(t)}{dt} = A \times x(t),   x(0) = x0
+
+    has the unique solution
+
+    .. math:: x(t) = \exp(A t) x0
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Matrix, pprint
+    >>> from sympy.solvers.ode.systems import matrix_exp
+    >>> t = Symbol('t')
+
+    We will consider a 2x2 matrix for comupting the exponential
+
+    >>> A = Matrix([[2, -5], [2, -4]])
+    >>> pprint(A)
+    [2  -5]
+    [     ]
+    [2  -4]
+
+    Now, exp(A*t) is given as follows:
+
+    >>> pprint(matrix_exp(A, t))
+    [   -t           -t                    -t              ]
+    [3*e  *sin(t) + e  *cos(t)         -5*e  *sin(t)       ]
+    [                                                      ]
+    [         -t                     -t           -t       ]
+    [      2*e  *sin(t)         - 3*e  *sin(t) + e  *cos(t)]
+
+    Parameters
+    ==========
+
+    A : Matrix
+        The matrix $A$ in the expression $\exp(A*t)$
+    t : Symbol
+        The independent variable
+
+    See Also
+    ========
+
+    matrix_exp_jordan_form: For exponential of Jordan normal form
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Jordan_normal_form
+    .. [2] https://en.wikipedia.org/wiki/Matrix_exponential
+
+    """
+    P, expJ = matrix_exp_jordan_form(A, t)
+    return P * expJ * P.inv()
+
+
+def matrix_exp_jordan_form(A, t):
+    r"""
+    Matrix exponential $\exp(A*t)$ for the matrix *A* and scalar *t*.
+
+    Explanation
+    ===========
+
+    Returns the Jordan form of the $\exp(A*t)$ along with the matrix $P$ such that:
+
+    .. math::
+        \exp(A*t) = P * expJ * P^{-1}
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, Symbol
+    >>> from sympy.solvers.ode.systems import matrix_exp, matrix_exp_jordan_form
+    >>> t = Symbol('t')
+
+    We will consider a 2x2 defective matrix. This shows that our method
+    works even for defective matrices.
+
+    >>> A = Matrix([[1, 1], [0, 1]])
+
+    It can be observed that this function gives us the Jordan normal form
+    and the required invertible matrix P.
+
+    >>> P, expJ = matrix_exp_jordan_form(A, t)
+
+    Here, it is shown that P and expJ returned by this function is correct
+    as they satisfy the formula: P * expJ * P_inverse = exp(A*t).
+
+    >>> P * expJ * P.inv() == matrix_exp(A, t)
+    True
+
+    Parameters
+    ==========
+
+    A : Matrix
+        The matrix $A$ in the expression $\exp(A*t)$
+    t : Symbol
+        The independent variable
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Defective_matrix
+    .. [2] https://en.wikipedia.org/wiki/Jordan_matrix
+    .. [3] https://en.wikipedia.org/wiki/Jordan_normal_form
+
+    """
+
+    N, M = A.shape
+    if N != M:
+        raise ValueError('Needed square matrix but got shape (%s, %s)' % (N, M))
+    elif A.has(t):
+        raise ValueError('Matrix A should not depend on t')
+
+    def jordan_chains(A):
+        '''Chains from Jordan normal form analogous to M.eigenvects().
+        Returns a dict with eignevalues as keys like:
+            {e1: [[v111,v112,...], [v121, v122,...]], e2:...}
+        where vijk is the kth vector in the jth chain for eigenvalue i.
+        '''
+        P, blocks = A.jordan_cells()
+        basis = [P[:,i] for i in range(P.shape[1])]
+        n = 0
+        chains = {}
+        for b in blocks:
+            eigval = b[0, 0]
+            size = b.shape[0]
+            if eigval not in chains:
+                chains[eigval] = []
+            chains[eigval].append(basis[n:n+size])
+            n += size
+        return chains
+
+    eigenchains = jordan_chains(A)
+
+    # Needed for consistency across Python versions
+    eigenchains_iter = sorted(eigenchains.items(), key=default_sort_key)
+    isreal = not A.has(I)
+
+    blocks = []
+    vectors = []
+    seen_conjugate = set()
+    for e, chains in eigenchains_iter:
+        for chain in chains:
+            n = len(chain)
+            if isreal and e != e.conjugate() and e.conjugate() in eigenchains:
+                if e in seen_conjugate:
+                    continue
+                seen_conjugate.add(e.conjugate())
+                exprt = exp(re(e) * t)
+                imrt = im(e) * t
+                imblock = Matrix([[cos(imrt), sin(imrt)],
+                                  [-sin(imrt), cos(imrt)]])
+                expJblock2 = Matrix(n, n, lambda i,j:
+                        imblock * t**(j-i) / factorial(j-i) if j >= i
+                        else zeros(2, 2))
+                expJblock = Matrix(2*n, 2*n, lambda i,j: expJblock2[i//2,j//2][i%2,j%2])
+
+                blocks.append(exprt * expJblock)
+                for i in range(n):
+                    vectors.append(re(chain[i]))
+                    vectors.append(im(chain[i]))
+            else:
+                vectors.extend(chain)
+                fun = lambda i,j: t**(j-i)/factorial(j-i) if j >= i else 0
+                expJblock = Matrix(n, n, fun)
+                blocks.append(exp(e * t) * expJblock)
+
+    expJ = Matrix.diag(*blocks)
+    P = Matrix(N, N, lambda i,j: vectors[j][i])
+
+    return P, expJ
+
+
+# Note: To add a docstring example with tau
+def linodesolve(A, t, b=None, B=None, type="auto", doit=False,
+                tau=None):
+    r"""
+    System of n equations linear first-order differential equations
+
+    Explanation
+    ===========
+
+    This solver solves the system of ODEs of the following form:
+
+    .. math::
+        X'(t) = A(t) X(t) +  b(t)
+
+    Here, $A(t)$ is the coefficient matrix, $X(t)$ is the vector of n independent variables,
+    $b(t)$ is the non-homogeneous term and $X'(t)$ is the derivative of $X(t)$
+
+    Depending on the properties of $A(t)$ and $b(t)$, this solver evaluates the solution
+    differently.
+
+    When $A(t)$ is constant coefficient matrix and $b(t)$ is zero vector i.e. system is homogeneous,
+    the system is "type1". The solution is:
+
+    .. math::
+        X(t) = \exp(A t) C
+
+    Here, $C$ is a vector of constants and $A$ is the constant coefficient matrix.
+
+    When $A(t)$ is constant coefficient matrix and $b(t)$ is non-zero i.e. system is non-homogeneous,
+    the system is "type2". The solution is:
+
+    .. math::
+        X(t) = e^{A t} ( \int e^{- A t} b \,dt + C)
+
+    When $A(t)$ is coefficient matrix such that its commutative with its antiderivative $B(t)$ and
+    $b(t)$ is a zero vector i.e. system is homogeneous, the system is "type3". The solution is:
+
+    .. math::
+        X(t) = \exp(B(t)) C
+
+    When $A(t)$ is commutative with its antiderivative $B(t)$ and $b(t)$ is non-zero i.e. system is
+    non-homogeneous, the system is "type4". The solution is:
+
+    .. math::
+        X(t) =  e^{B(t)} ( \int e^{-B(t)} b(t) \,dt + C)
+
+    When $A(t)$ is a coefficient matrix such that it can be factorized into a scalar and a constant
+    coefficient matrix:
+
+    .. math::
+        A(t) = f(t) * A
+
+    Where $f(t)$ is a scalar expression in the independent variable $t$ and $A$ is a constant matrix,
+    then we can do the following substitutions:
+
+    .. math::
+        tau = \int f(t) dt, X(t) = Y(tau), b(t) = b(f^{-1}(tau))
+
+    Here, the substitution for the non-homogeneous term is done only when its non-zero.
+    Using these substitutions, our original system becomes:
+
+    .. math::
+        Y'(tau) = A * Y(tau) + b(tau)/f(tau)
+
+    The above system can be easily solved using the solution for "type1" or "type2" depending
+    on the homogeneity of the system. After we get the solution for $Y(tau)$, we substitute the
+    solution for $tau$ as $t$ to get back $X(t)$
+
+    .. math::
+        X(t) = Y(tau)
+
+    Systems of "type5" and "type6" have a commutative antiderivative but we use this solution
+    because its faster to compute.
+
+    The final solution is the general solution for all the four equations since a constant coefficient
+    matrix is always commutative with its antidervative.
+
+    An additional feature of this function is, if someone wants to substitute for value of the independent
+    variable, they can pass the substitution `tau` and the solution will have the independent variable
+    substituted with the passed expression(`tau`).
+
+    Parameters
+    ==========
+
+    A : Matrix
+        Coefficient matrix of the system of linear first order ODEs.
+    t : Symbol
+        Independent variable in the system of ODEs.
+    b : Matrix or None
+        Non-homogeneous term in the system of ODEs. If None is passed,
+        a homogeneous system of ODEs is assumed.
+    B : Matrix or None
+        Antiderivative of the coefficient matrix. If the antiderivative
+        is not passed and the solution requires the term, then the solver
+        would compute it internally.
+    type : String
+        Type of the system of ODEs passed. Depending on the type, the
+        solution is evaluated. The type values allowed and the corresponding
+        system it solves are: "type1" for constant coefficient homogeneous
+        "type2" for constant coefficient non-homogeneous, "type3" for non-constant
+        coefficient homogeneous, "type4" for non-constant coefficient non-homogeneous,
+        "type5" and "type6" for non-constant coefficient homogeneous and non-homogeneous
+        systems respectively where the coefficient matrix can be factorized to a constant
+        coefficient matrix.
+        The default value is "auto" which will let the solver decide the correct type of
+        the system passed.
+    doit : Boolean
+        Evaluate the solution if True, default value is False
+    tau: Expression
+        Used to substitute for the value of `t` after we get the solution of the system.
+
+    Examples
+    ========
+
+    To solve the system of ODEs using this function directly, several things must be
+    done in the right order. Wrong inputs to the function will lead to incorrect results.
+
+    >>> from sympy import symbols, Function, Eq
+    >>> from sympy.solvers.ode.systems import canonical_odes, linear_ode_to_matrix, linodesolve, linodesolve_type
+    >>> from sympy.solvers.ode.subscheck import checkodesol
+    >>> f, g = symbols("f, g", cls=Function)
+    >>> x, a = symbols("x, a")
+    >>> funcs = [f(x), g(x)]
+    >>> eqs = [Eq(f(x).diff(x) - f(x), a*g(x) + 1), Eq(g(x).diff(x) + g(x), a*f(x))]
+
+    Here, it is important to note that before we derive the coefficient matrix, it is
+    important to get the system of ODEs into the desired form. For that we will use
+    :obj:`sympy.solvers.ode.systems.canonical_odes()`.
+
+    >>> eqs = canonical_odes(eqs, funcs, x)
+    >>> eqs
+    [[Eq(Derivative(f(x), x), a*g(x) + f(x) + 1), Eq(Derivative(g(x), x), a*f(x) - g(x))]]
+
+    Now, we will use :obj:`sympy.solvers.ode.systems.linear_ode_to_matrix()` to get the coefficient matrix and the
+    non-homogeneous term if it is there.
+
+    >>> eqs = eqs[0]
+    >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1)
+    >>> A = A0
+
+    We have the coefficient matrices and the non-homogeneous term ready. Now, we can use
+    :obj:`sympy.solvers.ode.systems.linodesolve_type()` to get the information for the system of ODEs
+    to finally pass it to the solver.
+
+    >>> system_info = linodesolve_type(A, x, b=b)
+    >>> sol_vector = linodesolve(A, x, b=b, B=system_info['antiderivative'], type=system_info['type_of_equation'])
+
+    Now, we can prove if the solution is correct or not by using :obj:`sympy.solvers.ode.checkodesol()`
+
+    >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+    >>> checkodesol(eqs, sol)
+    (True, [0, 0])
+
+    We can also use the doit method to evaluate the solutions passed by the function.
+
+    >>> sol_vector_evaluated = linodesolve(A, x, b=b, type="type2", doit=True)
+
+    Now, we will look at a system of ODEs which is non-constant.
+
+    >>> eqs = [Eq(f(x).diff(x), f(x) + x*g(x)), Eq(g(x).diff(x), -x*f(x) + g(x))]
+
+    The system defined above is already in the desired form, so we do not have to convert it.
+
+    >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1)
+    >>> A = A0
+
+    A user can also pass the commutative antiderivative required for type3 and type4 system of ODEs.
+    Passing an incorrect one will lead to incorrect results. If the coefficient matrix is not commutative
+    with its antiderivative, then :obj:`sympy.solvers.ode.systems.linodesolve_type()` raises a NotImplementedError.
+    If it does have a commutative antiderivative, then the function just returns the information about the system.
+
+    >>> system_info = linodesolve_type(A, x, b=b)
+
+    Now, we can pass the antiderivative as an argument to get the solution. If the system information is not
+    passed, then the solver will compute the required arguments internally.
+
+    >>> sol_vector = linodesolve(A, x, b=b)
+
+    Once again, we can verify the solution obtained.
+
+    >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+    >>> checkodesol(eqs, sol)
+    (True, [0, 0])
+
+    Returns
+    =======
+
+    List
+
+    Raises
+    ======
+
+    ValueError
+        This error is raised when the coefficient matrix, non-homogeneous term
+        or the antiderivative, if passed, are not a matrix or
+        do not have correct dimensions
+    NonSquareMatrixError
+        When the coefficient matrix or its antiderivative, if passed is not a
+        square matrix
+    NotImplementedError
+        If the coefficient matrix does not have a commutative antiderivative
+
+    See Also
+    ========
+
+    linear_ode_to_matrix: Coefficient matrix computation function
+    canonical_odes: System of ODEs representation change
+    linodesolve_type: Getting information about systems of ODEs to pass in this solver
+
+    """
+
+    if not isinstance(A, MatrixBase):
+        raise ValueError(filldedent('''\
+            The coefficients of the system of ODEs should be of type Matrix
+        '''))
+
+    if not A.is_square:
+        raise NonSquareMatrixError(filldedent('''\
+            The coefficient matrix must be a square
+        '''))
+
+    if b is not None:
+        if not isinstance(b, MatrixBase):
+            raise ValueError(filldedent('''\
+                The non-homogeneous terms of the system of ODEs should be of type Matrix
+            '''))
+
+        if A.rows != b.rows:
+            raise ValueError(filldedent('''\
+                The system of ODEs should have the same number of non-homogeneous terms and the number of
+                equations
+            '''))
+
+    if B is not None:
+        if not isinstance(B, MatrixBase):
+            raise ValueError(filldedent('''\
+                The antiderivative of coefficients of the system of ODEs should be of type Matrix
+            '''))
+
+        if not B.is_square:
+            raise NonSquareMatrixError(filldedent('''\
+                The antiderivative of the coefficient matrix must be a square
+            '''))
+
+        if A.rows != B.rows:
+            raise ValueError(filldedent('''\
+                        The coefficient matrix and its antiderivative should have same dimensions
+                    '''))
+
+    if not any(type == "type{}".format(i) for i in range(1, 7)) and not type == "auto":
+        raise ValueError(filldedent('''\
+                    The input type should be a valid one
+                '''))
+
+    n = A.rows
+
+    # constants = numbered_symbols(prefix='C', cls=Dummy, start=const_idx+1)
+    Cvect = Matrix([Dummy() for _ in range(n)])
+
+    if b is None and any(type == typ for typ in ["type2", "type4", "type6"]):
+        b = zeros(n, 1)
+
+    is_transformed = tau is not None
+    passed_type = type
+
+    if type == "auto":
+        system_info = linodesolve_type(A, t, b=b)
+        type = system_info["type_of_equation"]
+        B = system_info["antiderivative"]
+
+    if type in ("type5", "type6"):
+        is_transformed = True
+        if passed_type != "auto":
+            if tau is None:
+                system_info = _first_order_type5_6_subs(A, t, b=b)
+                if not system_info:
+                    raise ValueError(filldedent('''
+                        The system passed isn't {}.
+                    '''.format(type)))
+
+                tau = system_info['tau']
+                t = system_info['t_']
+                A = system_info['A']
+                b = system_info['b']
+
+    intx_wrtt = lambda x: Integral(x, t) if x else 0
+    if type in ("type1", "type2", "type5", "type6"):
+        P, J = matrix_exp_jordan_form(A, t)
+        P = simplify(P)
+
+        if type in ("type1", "type5"):
+            sol_vector = P * (J * Cvect)
+        else:
+            Jinv = J.subs(t, -t)
+            sol_vector = P * J * ((Jinv * P.inv() * b).applyfunc(intx_wrtt) + Cvect)
+    else:
+        if B is None:
+            B, _ = _is_commutative_anti_derivative(A, t)
+
+        if type == "type3":
+            sol_vector = B.exp() * Cvect
+        else:
+            sol_vector = B.exp() * (((-B).exp() * b).applyfunc(intx_wrtt) + Cvect)
+
+    if is_transformed:
+        sol_vector = sol_vector.subs(t, tau)
+
+    gens = sol_vector.atoms(exp)
+
+    if type != "type1":
+        sol_vector = [expand_mul(s) for s in sol_vector]
+
+    sol_vector = [collect(s, ordered(gens), exact=True) for s in sol_vector]
+
+    if doit:
+        sol_vector = [s.doit() for s in sol_vector]
+
+    return sol_vector
+
+
+def _matrix_is_constant(M, t):
+    """Checks if the matrix M is independent of t or not."""
+    return all(coef.as_independent(t, as_Add=True)[1] == 0 for coef in M)
+
+
+def canonical_odes(eqs, funcs, t):
+    r"""
+    Function that solves for highest order derivatives in a system
+
+    Explanation
+    ===========
+
+    This function inputs a system of ODEs and based on the system,
+    the dependent variables and their highest order, returns the system
+    in the following form:
+
+    .. math::
+        X'(t) = A(t) X(t) + b(t)
+
+    Here, $X(t)$ is the vector of dependent variables of lower order, $A(t)$ is
+    the coefficient matrix, $b(t)$ is the non-homogeneous term and $X'(t)$ is the
+    vector of dependent variables in their respective highest order. We use the term
+    canonical form to imply the system of ODEs which is of the above form.
+
+    If the system passed has a non-linear term with multiple solutions, then a list of
+    systems is returned in its canonical form.
+
+    Parameters
+    ==========
+
+    eqs : List
+        List of the ODEs
+    funcs : List
+        List of dependent variables
+    t : Symbol
+        Independent variable
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Function, Eq, Derivative
+    >>> from sympy.solvers.ode.systems import canonical_odes
+    >>> f, g = symbols("f g", cls=Function)
+    >>> x, y = symbols("x y")
+    >>> funcs = [f(x), g(x)]
+    >>> eqs = [Eq(f(x).diff(x) - 7*f(x), 12*g(x)), Eq(g(x).diff(x) + g(x), 20*f(x))]
+
+    >>> canonical_eqs = canonical_odes(eqs, funcs, x)
+    >>> canonical_eqs
+    [[Eq(Derivative(f(x), x), 7*f(x) + 12*g(x)), Eq(Derivative(g(x), x), 20*f(x) - g(x))]]
+
+    >>> system = [Eq(Derivative(f(x), x)**2 - 2*Derivative(f(x), x) + 1, 4), Eq(-y*f(x) + Derivative(g(x), x), 0)]
+
+    >>> canonical_system = canonical_odes(system, funcs, x)
+    >>> canonical_system
+    [[Eq(Derivative(f(x), x), -1), Eq(Derivative(g(x), x), y*f(x))], [Eq(Derivative(f(x), x), 3), Eq(Derivative(g(x), x), y*f(x))]]
+
+    Returns
+    =======
+
+    List
+
+    """
+    from sympy.solvers.solvers import solve
+
+    order = _get_func_order(eqs, funcs)
+
+    canon_eqs = solve(eqs, *[func.diff(t, order[func]) for func in funcs], dict=True)
+
+    systems = []
+    for eq in canon_eqs:
+        system = [Eq(func.diff(t, order[func]), eq[func.diff(t, order[func])]) for func in funcs]
+        systems.append(system)
+
+    return systems
+
+
+def _is_commutative_anti_derivative(A, t):
+    r"""
+    Helper function for determining if the Matrix passed is commutative with its antiderivative
+
+    Explanation
+    ===========
+
+    This function checks if the Matrix $A$ passed is commutative with its antiderivative with respect
+    to the independent variable $t$.
+
+    .. math::
+        B(t) = \int A(t) dt
+
+    The function outputs two values, first one being the antiderivative $B(t)$, second one being a
+    boolean value, if True, then the matrix $A(t)$ passed is commutative with $B(t)$, else the matrix
+    passed isn't commutative with $B(t)$.
+
+    Parameters
+    ==========
+
+    A : Matrix
+        The matrix which has to be checked
+    t : Symbol
+        Independent variable
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Matrix
+    >>> from sympy.solvers.ode.systems import _is_commutative_anti_derivative
+    >>> t = symbols("t")
+    >>> A = Matrix([[1, t], [-t, 1]])
+
+    >>> B, is_commuting = _is_commutative_anti_derivative(A, t)
+    >>> is_commuting
+    True
+
+    Returns
+    =======
+
+    Matrix, Boolean
+
+    """
+    B = integrate(A, t)
+    is_commuting = (B*A - A*B).applyfunc(expand).applyfunc(factor_terms).is_zero_matrix
+
+    is_commuting = False if is_commuting is None else is_commuting
+
+    return B, is_commuting
+
+
+def _factor_matrix(A, t):
+    term = None
+    for element in A:
+        temp_term = element.as_independent(t)[1]
+        if temp_term.has(t):
+            term = temp_term
+            break
+
+    if term is not None:
+        A_factored = (A/term).applyfunc(ratsimp)
+        can_factor = _matrix_is_constant(A_factored, t)
+        term = (term, A_factored) if can_factor else None
+
+    return term
+
+
+def _is_second_order_type2(A, t):
+    term = _factor_matrix(A, t)
+    is_type2 = False
+
+    if term is not None:
+        term = 1/term[0]
+        is_type2 = term.is_polynomial()
+
+    if is_type2:
+        poly = Poly(term.expand(), t)
+        monoms = poly.monoms()
+
+        if monoms[0][0] in (2, 4):
+            cs = _get_poly_coeffs(poly, 4)
+            a, b, c, d, e = cs
+
+            a1 = powdenest(sqrt(a), force=True)
+            c1 = powdenest(sqrt(e), force=True)
+            b1 = powdenest(sqrt(c - 2*a1*c1), force=True)
+
+            is_type2 = (b == 2*a1*b1) and (d == 2*b1*c1)
+            term = a1*t**2 + b1*t + c1
+
+        else:
+            is_type2 = False
+
+    return is_type2, term
+
+
+def _get_poly_coeffs(poly, order):
+    cs = [0 for _ in range(order+1)]
+    for c, m in zip(poly.coeffs(), poly.monoms()):
+        cs[-1-m[0]] = c
+    return cs
+
+
+def _match_second_order_type(A1, A0, t, b=None):
+    r"""
+    Works only for second order system in its canonical form.
+
+    Type 0: Constant coefficient matrix, can be simply solved by
+            introducing dummy variables.
+    Type 1: When the substitution: $U = t*X' - X$ works for reducing
+            the second order system to first order system.
+    Type 2: When the system is of the form: $poly * X'' = A*X$ where
+            $poly$ is square of a quadratic polynomial with respect to
+            *t* and $A$ is a constant coefficient matrix.
+
+    """
+    match = {"type_of_equation": "type0"}
+    n = A1.shape[0]
+
+    if _matrix_is_constant(A1, t) and _matrix_is_constant(A0, t):
+        return match
+
+    if (A1 + A0*t).applyfunc(expand_mul).is_zero_matrix:
+        match.update({"type_of_equation": "type1", "A1": A1})
+
+    elif A1.is_zero_matrix and (b is None or b.is_zero_matrix):
+        is_type2, term = _is_second_order_type2(A0, t)
+        if is_type2:
+            a, b, c = _get_poly_coeffs(Poly(term, t), 2)
+            A = (A0*(term**2).expand()).applyfunc(ratsimp) + (b**2/4 - a*c)*eye(n, n)
+            tau = integrate(1/term, t)
+            t_ = Symbol("{}_".format(t))
+            match.update({"type_of_equation": "type2", "A0": A,
+                          "g(t)": sqrt(term), "tau": tau, "is_transformed": True,
+                          "t_": t_})
+
+    return match
+
+
+def _second_order_subs_type1(A, b, funcs, t):
+    r"""
+    For a linear, second order system of ODEs, a particular substitution.
+
+    A system of the below form can be reduced to a linear first order system of
+    ODEs:
+    .. math::
+        X'' = A(t) * (t*X' - X) + b(t)
+
+    By substituting:
+    .. math::  U = t*X' - X
+
+    To get the system:
+    .. math::  U' = t*(A(t)*U + b(t))
+
+    Where $U$ is the vector of dependent variables, $X$ is the vector of dependent
+    variables in `funcs` and $X'$ is the first order derivative of $X$ with respect to
+    $t$. It may or may not reduce the system into linear first order system of ODEs.
+
+    Then a check is made to determine if the system passed can be reduced or not, if
+    this substitution works, then the system is reduced and its solved for the new
+    substitution. After we get the solution for $U$:
+
+    .. math::  U = a(t)
+
+    We substitute and return the reduced system:
+
+    .. math::
+        a(t) = t*X' - X
+
+    Parameters
+    ==========
+
+    A: Matrix
+        Coefficient matrix($A(t)*t$) of the second order system of this form.
+    b: Matrix
+        Non-homogeneous term($b(t)$) of the system of ODEs.
+    funcs: List
+        List of dependent variables
+    t: Symbol
+        Independent variable of the system of ODEs.
+
+    Returns
+    =======
+
+    List
+
+    """
+
+    U = Matrix([t*func.diff(t) - func for func in funcs])
+
+    sol = linodesolve(A, t, t*b)
+    reduced_eqs = [Eq(u, s) for s, u in zip(sol, U)]
+    reduced_eqs = canonical_odes(reduced_eqs, funcs, t)[0]
+
+    return reduced_eqs
+
+
+def _second_order_subs_type2(A, funcs, t_):
+    r"""
+    Returns a second order system based on the coefficient matrix passed.
+
+    Explanation
+    ===========
+
+    This function returns a system of second order ODE of the following form:
+
+    .. math::
+        X'' = A * X
+
+    Here, $X$ is the vector of dependent variables, but a bit modified, $A$ is the
+    coefficient matrix passed.
+
+    Along with returning the second order system, this function also returns the new
+    dependent variables with the new independent variable `t_` passed.
+
+    Parameters
+    ==========
+
+    A: Matrix
+        Coefficient matrix of the system
+    funcs: List
+        List of old dependent variables
+    t_: Symbol
+        New independent variable
+
+    Returns
+    =======
+
+    List, List
+
+    """
+    func_names = [func.func.__name__ for func in funcs]
+    new_funcs = [Function(Dummy("{}_".format(name)))(t_) for name in func_names]
+    rhss = A * Matrix(new_funcs)
+    new_eqs = [Eq(func.diff(t_, 2), rhs) for func, rhs in zip(new_funcs, rhss)]
+
+    return new_eqs, new_funcs
+
+
+def _is_euler_system(As, t):
+    return all(_matrix_is_constant((A*t**i).applyfunc(ratsimp), t) for i, A in enumerate(As))
+
+
+def _classify_linear_system(eqs, funcs, t, is_canon=False):
+    r"""
+    Returns a dictionary with details of the eqs if the system passed is linear
+    and can be classified by this function else returns None
+
+    Explanation
+    ===========
+
+    This function takes the eqs, converts it into a form Ax = b where x is a vector of terms
+    containing dependent variables and their derivatives till their maximum order. If it is
+    possible to convert eqs into Ax = b, then all the equations in eqs are linear otherwise
+    they are non-linear.
+
+    To check if the equations are constant coefficient, we need to check if all the terms in
+    A obtained above are constant or not.
+
+    To check if the equations are homogeneous or not, we need to check if b is a zero matrix
+    or not.
+
+    Parameters
+    ==========
+
+    eqs: List
+        List of ODEs
+    funcs: List
+        List of dependent variables
+    t: Symbol
+        Independent variable of the equations in eqs
+    is_canon: Boolean
+        If True, then this function will not try to get the
+        system in canonical form. Default value is False
+
+    Returns
+    =======
+
+    match = {
+        'no_of_equation': len(eqs),
+        'eq': eqs,
+        'func': funcs,
+        'order': order,
+        'is_linear': is_linear,
+        'is_constant': is_constant,
+        'is_homogeneous': is_homogeneous,
+    }
+
+    Dict or list of Dicts or None
+        Dict with values for keys:
+            1. no_of_equation: Number of equations
+            2. eq: The set of equations
+            3. func: List of dependent variables
+            4. order: A dictionary that gives the order of the
+                      dependent variable in eqs
+            5. is_linear: Boolean value indicating if the set of
+                          equations are linear or not.
+            6. is_constant: Boolean value indicating if the set of
+                          equations have constant coefficients or not.
+            7. is_homogeneous: Boolean value indicating if the set of
+                          equations are homogeneous or not.
+            8. commutative_antiderivative: Antiderivative of the coefficient
+                          matrix if the coefficient matrix is non-constant
+                          and commutative with its antiderivative. This key
+                          may or may not exist.
+            9. is_general: Boolean value indicating if the system of ODEs is
+                           solvable using one of the general case solvers or not.
+            10. rhs: rhs of the non-homogeneous system of ODEs in Matrix form. This
+                     key may or may not exist.
+            11. is_higher_order: True if the system passed has an order greater than 1.
+                                 This key may or may not exist.
+            12. is_second_order: True if the system passed is a second order ODE. This
+                                 key may or may not exist.
+        This Dict is the answer returned if the eqs are linear and constant
+        coefficient. Otherwise, None is returned.
+
+    """
+
+    # Error for i == 0 can be added but isn't for now
+
+    # Check for len(funcs) == len(eqs)
+    if len(funcs) != len(eqs):
+        raise ValueError("Number of functions given is not equal to the number of equations %s" % funcs)
+
+    # ValueError when functions have more than one arguments
+    for func in funcs:
+        if len(func.args) != 1:
+            raise ValueError("dsolve() and classify_sysode() work with "
+            "functions of one variable only, not %s" % func)
+
+    # Getting the func_dict and order using the helper
+    # function
+    order = _get_func_order(eqs, funcs)
+    system_order = max(order[func] for func in funcs)
+    is_higher_order = system_order > 1
+    is_second_order = system_order == 2 and all(order[func] == 2 for func in funcs)
+
+    # Not adding the check if the len(func.args) for
+    # every func in funcs is 1
+
+    # Linearity check
+    try:
+
+        canon_eqs = canonical_odes(eqs, funcs, t) if not is_canon else [eqs]
+        if len(canon_eqs) == 1:
+            As, b = linear_ode_to_matrix(canon_eqs[0], funcs, t, system_order)
+        else:
+
+            match = {
+                'is_implicit': True,
+                'canon_eqs': canon_eqs
+            }
+
+            return match
+
+    # When the system of ODEs is non-linear, an ODENonlinearError is raised.
+    # This function catches the error and None is returned.
+    except ODENonlinearError:
+        return None
+
+    is_linear = True
+
+    # Homogeneous check
+    is_homogeneous = True if b.is_zero_matrix else False
+
+    # Is general key is used to identify if the system of ODEs can be solved by
+    # one of the general case solvers or not.
+    match = {
+        'no_of_equation': len(eqs),
+        'eq': eqs,
+        'func': funcs,
+        'order': order,
+        'is_linear': is_linear,
+        'is_homogeneous': is_homogeneous,
+        'is_general': True
+    }
+
+    if not is_homogeneous:
+        match['rhs'] = b
+
+    is_constant = all(_matrix_is_constant(A_, t) for A_ in As)
+
+    # The match['is_linear'] check will be added in the future when this
+    # function becomes ready to deal with non-linear systems of ODEs
+
+    if not is_higher_order:
+        A = As[1]
+        match['func_coeff'] = A
+
+        # Constant coefficient check
+        is_constant = _matrix_is_constant(A, t)
+        match['is_constant'] = is_constant
+
+        try:
+            system_info = linodesolve_type(A, t, b=b)
+        except NotImplementedError:
+            return None
+
+        match.update(system_info)
+        antiderivative = match.pop("antiderivative")
+
+        if not is_constant:
+            match['commutative_antiderivative'] = antiderivative
+
+        return match
+    else:
+        match['type_of_equation'] = "type0"
+
+        if is_second_order:
+            A1, A0 = As[1:]
+
+            match_second_order = _match_second_order_type(A1, A0, t)
+            match.update(match_second_order)
+
+            match['is_second_order'] = True
+
+        # If system is constant, then no need to check if its in euler
+        # form or not. It will be easier and faster to directly proceed
+        # to solve it.
+        if match['type_of_equation'] == "type0" and not is_constant:
+            is_euler = _is_euler_system(As, t)
+            if is_euler:
+                t_ = Symbol('{}_'.format(t))
+                match.update({'is_transformed': True, 'type_of_equation': 'type1',
+                              't_': t_})
+            else:
+                is_jordan = lambda M: M == Matrix.jordan_block(M.shape[0], M[0, 0])
+                terms = _factor_matrix(As[-1], t)
+                if all(A.is_zero_matrix for A in As[1:-1]) and terms is not None and not is_jordan(terms[1]):
+                    P, J = terms[1].jordan_form()
+                    match.update({'type_of_equation': 'type2', 'J': J,
+                                  'f(t)': terms[0], 'P': P, 'is_transformed': True})
+
+            if match['type_of_equation'] != 'type0' and is_second_order:
+                match.pop('is_second_order', None)
+
+        match['is_higher_order'] = is_higher_order
+
+        return match
+
+def _preprocess_eqs(eqs):
+    processed_eqs = []
+    for eq in eqs:
+        processed_eqs.append(eq if isinstance(eq, Equality) else Eq(eq, 0))
+
+    return processed_eqs
+
+
+def _eqs2dict(eqs, funcs):
+    eqsorig = {}
+    eqsmap = {}
+    funcset = set(funcs)
+    for eq in eqs:
+        f1, = eq.lhs.atoms(AppliedUndef)
+        f2s = (eq.rhs.atoms(AppliedUndef) - {f1}) & funcset
+        eqsmap[f1] = f2s
+        eqsorig[f1] = eq
+    return eqsmap, eqsorig
+
+
+def _dict2graph(d):
+    nodes = list(d)
+    edges = [(f1, f2) for f1, f2s in d.items() for f2 in f2s]
+    G = (nodes, edges)
+    return G
+
+
+def _is_type1(scc, t):
+    eqs, funcs = scc
+
+    try:
+        (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, 1)
+    except (ODENonlinearError, ODEOrderError):
+        return False
+
+    if _matrix_is_constant(A0, t) and b.is_zero_matrix:
+        return True
+
+    return False
+
+
+def _combine_type1_subsystems(subsystem, funcs, t):
+    indices = [i for i, sys in enumerate(zip(subsystem, funcs)) if _is_type1(sys, t)]
+    remove = set()
+    for ip, i in enumerate(indices):
+        for j in indices[ip+1:]:
+            if any(eq2.has(funcs[i]) for eq2 in subsystem[j]):
+                subsystem[j] = subsystem[i] + subsystem[j]
+                remove.add(i)
+    subsystem = [sys for i, sys in enumerate(subsystem) if i not in remove]
+    return subsystem
+
+
+def _component_division(eqs, funcs, t):
+
+    # Assuming that each eq in eqs is in canonical form,
+    # that is, [f(x).diff(x) = .., g(x).diff(x) = .., etc]
+    # and that the system passed is in its first order
+    eqsmap, eqsorig = _eqs2dict(eqs, funcs)
+
+    subsystems = []
+    for cc in connected_components(_dict2graph(eqsmap)):
+        eqsmap_c = {f: eqsmap[f] for f in cc}
+        sccs = strongly_connected_components(_dict2graph(eqsmap_c))
+        subsystem = [[eqsorig[f] for f in scc] for scc in sccs]
+        subsystem = _combine_type1_subsystems(subsystem, sccs, t)
+        subsystems.append(subsystem)
+
+    return subsystems
+
+
+# Returns: List of equations
+def _linear_ode_solver(match):
+    t = match['t']
+    funcs = match['func']
+
+    rhs = match.get('rhs', None)
+    tau = match.get('tau', None)
+    t = match['t_'] if 't_' in match else t
+    A = match['func_coeff']
+
+    # Note: To make B None when the matrix has constant
+    # coefficient
+    B = match.get('commutative_antiderivative', None)
+    type = match['type_of_equation']
+
+    sol_vector = linodesolve(A, t, b=rhs, B=B,
+                             type=type, tau=tau)
+
+    sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+
+    return sol
+
+
+def _select_equations(eqs, funcs, key=lambda x: x):
+    eq_dict = {e.lhs: e.rhs for e in eqs}
+    return [Eq(f, eq_dict[key(f)]) for f in funcs]
+
+
+def _higher_order_ode_solver(match):
+    eqs = match["eq"]
+    funcs = match["func"]
+    t = match["t"]
+    sysorder = match['order']
+    type = match.get('type_of_equation', "type0")
+
+    is_second_order = match.get('is_second_order', False)
+    is_transformed = match.get('is_transformed', False)
+    is_euler = is_transformed and type == "type1"
+    is_higher_order_type2 = is_transformed and type == "type2" and 'P' in match
+
+    if is_second_order:
+        new_eqs, new_funcs = _second_order_to_first_order(eqs, funcs, t,
+                                                          A1=match.get("A1", None), A0=match.get("A0", None),
+                                                          b=match.get("rhs", None), type=type,
+                                                          t_=match.get("t_", None))
+    else:
+        new_eqs, new_funcs = _higher_order_to_first_order(eqs, sysorder, t, funcs=funcs,
+                                                          type=type, J=match.get('J', None),
+                                                          f_t=match.get('f(t)', None),
+                                                          P=match.get('P', None), b=match.get('rhs', None))
+
+    if is_transformed:
+        t = match.get('t_', t)
+
+    if not is_higher_order_type2:
+        new_eqs = _select_equations(new_eqs, [f.diff(t) for f in new_funcs])
+
+    sol = None
+
+    # NotImplementedError may be raised when the system may be actually
+    # solvable if it can be just divided into sub-systems
+    try:
+        if not is_higher_order_type2:
+            sol = _strong_component_solver(new_eqs, new_funcs, t)
+    except NotImplementedError:
+        sol = None
+
+    # Dividing the system only when it becomes essential
+    if sol is None:
+        try:
+            sol = _component_solver(new_eqs, new_funcs, t)
+        except NotImplementedError:
+            sol = None
+
+    if sol is None:
+        return sol
+
+    is_second_order_type2 = is_second_order and type == "type2"
+
+    underscores = '__' if is_transformed else '_'
+
+    sol = _select_equations(sol, funcs,
+                            key=lambda x: Function(Dummy('{}{}0'.format(x.func.__name__, underscores)))(t))
+
+    if match.get("is_transformed", False):
+        if is_second_order_type2:
+            g_t = match["g(t)"]
+            tau = match["tau"]
+            sol = [Eq(s.lhs, s.rhs.subs(t, tau) * g_t) for s in sol]
+        elif is_euler:
+            t = match['t']
+            tau = match['t_']
+            sol = [s.subs(tau, log(t)) for s in sol]
+        elif is_higher_order_type2:
+            P = match['P']
+            sol_vector = P * Matrix([s.rhs for s in sol])
+            sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+
+    return sol
+
+
+# Returns: List of equations or None
+# If None is returned by this solver, then the system
+# of ODEs cannot be solved directly by dsolve_system.
+def _strong_component_solver(eqs, funcs, t):
+    from sympy.solvers.ode.ode import dsolve, constant_renumber
+
+    match = _classify_linear_system(eqs, funcs, t, is_canon=True)
+    sol = None
+
+    # Assuming that we can't get an implicit system
+    # since we are already canonical equations from
+    # dsolve_system
+    if match:
+        match['t'] = t
+
+        if match.get('is_higher_order', False):
+            sol = _higher_order_ode_solver(match)
+
+        elif match.get('is_linear', False):
+            sol = _linear_ode_solver(match)
+
+        # Note: For now, only linear systems are handled by this function
+        # hence, the match condition is added. This can be removed later.
+        if sol is None and len(eqs) == 1:
+            sol = dsolve(eqs[0], func=funcs[0])
+            variables = Tuple(eqs[0]).free_symbols
+            new_constants = [Dummy() for _ in range(ode_order(eqs[0], funcs[0]))]
+            sol = constant_renumber(sol, variables=variables, newconstants=new_constants)
+            sol = [sol]
+
+        # To add non-linear case here in future
+
+    return sol
+
+
+def _get_funcs_from_canon(eqs):
+    return [eq.lhs.args[0] for eq in eqs]
+
+
+# Returns: List of Equations(a solution)
+def _weak_component_solver(wcc, t):
+
+    # We will divide the systems into sccs
+    # only when the wcc cannot be solved as
+    # a whole
+    eqs = []
+    for scc in wcc:
+        eqs += scc
+    funcs = _get_funcs_from_canon(eqs)
+
+    sol = _strong_component_solver(eqs, funcs, t)
+    if sol:
+        return sol
+
+    sol = []
+
+    for scc in wcc:
+        eqs = scc
+        funcs = _get_funcs_from_canon(eqs)
+
+        # Substituting solutions for the dependent
+        # variables solved in previous SCC, if any solved.
+        comp_eqs = [eq.subs({s.lhs: s.rhs for s in sol}) for eq in eqs]
+        scc_sol = _strong_component_solver(comp_eqs, funcs, t)
+
+        if scc_sol is None:
+            raise NotImplementedError(filldedent('''
+                The system of ODEs passed cannot be solved by dsolve_system.
+            '''))
+
+        # scc_sol: List of equations
+        # scc_sol is a solution
+        sol += scc_sol
+
+    return sol
+
+
+# Returns: List of Equations(a solution)
+def _component_solver(eqs, funcs, t):
+    components = _component_division(eqs, funcs, t)
+    sol = []
+
+    for wcc in components:
+
+        # wcc_sol: List of Equations
+        sol += _weak_component_solver(wcc, t)
+
+    # sol: List of Equations
+    return sol
+
+
+def _second_order_to_first_order(eqs, funcs, t, type="auto", A1=None,
+                                 A0=None, b=None, t_=None):
+    r"""
+    Expects the system to be in second order and in canonical form
+
+    Explanation
+    ===========
+
+    Reduces a second order system into a first order one depending on the type of second
+    order system.
+    1. "type0": If this is passed, then the system will be reduced to first order by
+                introducing dummy variables.
+    2. "type1": If this is passed, then a particular substitution will be used to reduce the
+                the system into first order.
+    3. "type2": If this is passed, then the system will be transformed with new dependent
+                variables and independent variables. This transformation is a part of solving
+                the corresponding system of ODEs.
+
+    `A1` and `A0` are the coefficient matrices from the system and it is assumed that the
+    second order system has the form given below:
+
+    .. math::
+        A2 * X'' = A1 * X' + A0 * X + b
+
+    Here, $A2$ is the coefficient matrix for the vector $X''$ and $b$ is the non-homogeneous
+    term.
+
+    Default value for `b` is None but if `A1` and `A0` are passed and `b` is not passed, then the
+    system will be assumed homogeneous.
+
+    """
+    is_a1 = A1 is None
+    is_a0 = A0 is None
+
+    if (type == "type1" and is_a1) or (type == "type2" and is_a0)\
+        or (type == "auto" and (is_a1 or is_a0)):
+        (A2, A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, 2)
+
+        if not A2.is_Identity:
+            raise ValueError(filldedent('''
+                The system must be in its canonical form.
+            '''))
+
+    if type == "auto":
+        match = _match_second_order_type(A1, A0, t)
+        type = match["type_of_equation"]
+        A1 = match.get("A1", None)
+        A0 = match.get("A0", None)
+
+    sys_order = dict.fromkeys(funcs, 2)
+
+    if type == "type1":
+        if b is None:
+            b = zeros(len(eqs))
+        eqs = _second_order_subs_type1(A1, b, funcs, t)
+        sys_order = dict.fromkeys(funcs, 1)
+
+    if type == "type2":
+        if t_ is None:
+            t_ = Symbol("{}_".format(t))
+        t = t_
+        eqs, funcs = _second_order_subs_type2(A0, funcs, t_)
+        sys_order = dict.fromkeys(funcs, 2)
+
+    return _higher_order_to_first_order(eqs, sys_order, t, funcs=funcs)
+
+
+def _higher_order_type2_to_sub_systems(J, f_t, funcs, t, max_order, b=None, P=None):
+
+    # Note: To add a test for this ValueError
+    if J is None or f_t is None or not _matrix_is_constant(J, t):
+        raise ValueError(filldedent('''
+            Correctly input for args 'A' and 'f_t' for Linear, Higher Order,
+            Type 2
+        '''))
+
+    if P is None and b is not None and not b.is_zero_matrix:
+        raise ValueError(filldedent('''
+            Provide the keyword 'P' for matrix P in A = P * J * P-1.
+        '''))
+
+    new_funcs = Matrix([Function(Dummy('{}__0'.format(f.func.__name__)))(t) for f in funcs])
+    new_eqs = new_funcs.diff(t, max_order) - f_t * J * new_funcs
+
+    if b is not None and not b.is_zero_matrix:
+        new_eqs -= P.inv() * b
+
+    new_eqs = canonical_odes(new_eqs, new_funcs, t)[0]
+
+    return new_eqs, new_funcs
+
+
+def _higher_order_to_first_order(eqs, sys_order, t, funcs=None, type="type0", **kwargs):
+    if funcs is None:
+        funcs = sys_order.keys()
+
+    # Standard Cauchy Euler system
+    if type == "type1":
+        t_ = Symbol('{}_'.format(t))
+        new_funcs = [Function(Dummy('{}_'.format(f.func.__name__)))(t_) for f in funcs]
+        max_order = max(sys_order[func] for func in funcs)
+        subs_dict = dict(zip(funcs, new_funcs))
+        subs_dict[t] = exp(t_)
+
+        free_function = Function(Dummy())
+
+        def _get_coeffs_from_subs_expression(expr):
+            if isinstance(expr, Subs):
+                free_symbol = expr.args[1][0]
+                term = expr.args[0]
+                return {ode_order(term, free_symbol): 1}
+
+            if isinstance(expr, Mul):
+                coeff = expr.args[0]
+                order = list(_get_coeffs_from_subs_expression(expr.args[1]).keys())[0]
+                return {order: coeff}
+
+            if isinstance(expr, Add):
+                coeffs = {}
+                for arg in expr.args:
+
+                    if isinstance(arg, Mul):
+                        coeffs.update(_get_coeffs_from_subs_expression(arg))
+
+                    else:
+                        order = list(_get_coeffs_from_subs_expression(arg).keys())[0]
+                        coeffs[order] = 1
+
+                return coeffs
+
+        for o in range(1, max_order + 1):
+            expr = free_function(log(t_)).diff(t_, o)*t_**o
+            coeff_dict = _get_coeffs_from_subs_expression(expr)
+            coeffs = [coeff_dict[order] if order in coeff_dict else 0 for order in range(o + 1)]
+            expr_to_subs = sum(free_function(t_).diff(t_, i) * c for i, c in
+                        enumerate(coeffs)) / t**o
+            subs_dict.update({f.diff(t, o): expr_to_subs.subs(free_function(t_), nf)
+                              for f, nf in zip(funcs, new_funcs)})
+
+        new_eqs = [eq.subs(subs_dict) for eq in eqs]
+        new_sys_order = {nf: sys_order[f] for f, nf in zip(funcs, new_funcs)}
+
+        new_eqs = canonical_odes(new_eqs, new_funcs, t_)[0]
+
+        return _higher_order_to_first_order(new_eqs, new_sys_order, t_, funcs=new_funcs)
+
+    # Systems of the form: X(n)(t) = f(t)*A*X + b
+    # where X(n)(t) is the nth derivative of the vector of dependent variables
+    # with respect to the independent variable and A is a constant matrix.
+    if type == "type2":
+        J = kwargs.get('J', None)
+        f_t = kwargs.get('f_t', None)
+        b = kwargs.get('b', None)
+        P = kwargs.get('P', None)
+        max_order = max(sys_order[func] for func in funcs)
+
+        return _higher_order_type2_to_sub_systems(J, f_t, funcs, t, max_order, P=P, b=b)
+
+        # Note: To be changed to this after doit option is disabled for default cases
+        # new_sysorder = _get_func_order(new_eqs, new_funcs)
+        #
+        # return _higher_order_to_first_order(new_eqs, new_sysorder, t, funcs=new_funcs)
+
+    new_funcs = []
+
+    for prev_func in funcs:
+        func_name = prev_func.func.__name__
+        func = Function(Dummy('{}_0'.format(func_name)))(t)
+        new_funcs.append(func)
+        subs_dict = {prev_func: func}
+        new_eqs = []
+
+        for i in range(1, sys_order[prev_func]):
+            new_func = Function(Dummy('{}_{}'.format(func_name, i)))(t)
+            subs_dict[prev_func.diff(t, i)] = new_func
+            new_funcs.append(new_func)
+
+            prev_f = subs_dict[prev_func.diff(t, i-1)]
+            new_eq = Eq(prev_f.diff(t), new_func)
+            new_eqs.append(new_eq)
+
+        eqs = [eq.subs(subs_dict) for eq in eqs] + new_eqs
+
+    return eqs, new_funcs
+
+
+def dsolve_system(eqs, funcs=None, t=None, ics=None, doit=False, simplify=True):
+    r"""
+    Solves any(supported) system of Ordinary Differential Equations
+
+    Explanation
+    ===========
+
+    This function takes a system of ODEs as an input, determines if the
+    it is solvable by this function, and returns the solution if found any.
+
+    This function can handle:
+    1. Linear, First Order, Constant coefficient homogeneous system of ODEs
+    2. Linear, First Order, Constant coefficient non-homogeneous system of ODEs
+    3. Linear, First Order, non-constant coefficient homogeneous system of ODEs
+    4. Linear, First Order, non-constant coefficient non-homogeneous system of ODEs
+    5. Any implicit system which can be divided into system of ODEs which is of the above 4 forms
+    6. Any higher order linear system of ODEs that can be reduced to one of the 5 forms of systems described above.
+
+    The types of systems described above are not limited by the number of equations, i.e. this
+    function can solve the above types irrespective of the number of equations in the system passed.
+    But, the bigger the system, the more time it will take to solve the system.
+
+    This function returns a list of solutions. Each solution is a list of equations where LHS is
+    the dependent variable and RHS is an expression in terms of the independent variable.
+
+    Among the non constant coefficient types, not all the systems are solvable by this function. Only
+    those which have either a coefficient matrix with a commutative antiderivative or those systems which
+    may be divided further so that the divided systems may have coefficient matrix with commutative antiderivative.
+
+    Parameters
+    ==========
+
+    eqs : List
+        system of ODEs to be solved
+    funcs : List or None
+        List of dependent variables that make up the system of ODEs
+    t : Symbol or None
+        Independent variable in the system of ODEs
+    ics : Dict or None
+        Set of initial boundary/conditions for the system of ODEs
+    doit : Boolean
+        Evaluate the solutions if True. Default value is True. Can be
+        set to false if the integral evaluation takes too much time and/or
+        is not required.
+    simplify: Boolean
+        Simplify the solutions for the systems. Default value is True.
+        Can be set to false if simplification takes too much time and/or
+        is not required.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Eq, Function
+    >>> from sympy.solvers.ode.systems import dsolve_system
+    >>> f, g = symbols("f g", cls=Function)
+    >>> x = symbols("x")
+
+    >>> eqs = [Eq(f(x).diff(x), g(x)), Eq(g(x).diff(x), f(x))]
+    >>> dsolve_system(eqs)
+    [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]]
+
+    You can also pass the initial conditions for the system of ODEs:
+
+    >>> dsolve_system(eqs, ics={f(0): 1, g(0): 0})
+    [[Eq(f(x), exp(x)/2 + exp(-x)/2), Eq(g(x), exp(x)/2 - exp(-x)/2)]]
+
+    Optionally, you can pass the dependent variables and the independent
+    variable for which the system is to be solved:
+
+    >>> funcs = [f(x), g(x)]
+    >>> dsolve_system(eqs, funcs=funcs, t=x)
+    [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]]
+
+    Lets look at an implicit system of ODEs:
+
+    >>> eqs = [Eq(f(x).diff(x)**2, g(x)**2), Eq(g(x).diff(x), g(x))]
+    >>> dsolve_system(eqs)
+    [[Eq(f(x), C1 - C2*exp(x)), Eq(g(x), C2*exp(x))], [Eq(f(x), C1 + C2*exp(x)), Eq(g(x), C2*exp(x))]]
+
+    Returns
+    =======
+
+    List of List of Equations
+
+    Raises
+    ======
+
+    NotImplementedError
+        When the system of ODEs is not solvable by this function.
+    ValueError
+        When the parameters passed are not in the required form.
+
+    """
+    from sympy.solvers.ode.ode import solve_ics, _extract_funcs, constant_renumber
+
+    if not iterable(eqs):
+        raise ValueError(filldedent('''
+            List of equations should be passed. The input is not valid.
+        '''))
+
+    eqs = _preprocess_eqs(eqs)
+
+    if funcs is not None and not isinstance(funcs, list):
+        raise ValueError(filldedent('''
+            Input to the funcs should be a list of functions.
+        '''))
+
+    if funcs is None:
+        funcs = _extract_funcs(eqs)
+
+    if any(len(func.args) != 1 for func in funcs):
+        raise ValueError(filldedent('''
+            dsolve_system can solve a system of ODEs with only one independent
+            variable.
+        '''))
+
+    if len(eqs) != len(funcs):
+        raise ValueError(filldedent('''
+            Number of equations and number of functions do not match
+        '''))
+
+    if t is not None and not isinstance(t, Symbol):
+        raise ValueError(filldedent('''
+            The independent variable must be of type Symbol
+        '''))
+
+    if t is None:
+        t = list(list(eqs[0].atoms(Derivative))[0].atoms(Symbol))[0]
+
+    sols = []
+    canon_eqs = canonical_odes(eqs, funcs, t)
+
+    for canon_eq in canon_eqs:
+        try:
+            sol = _strong_component_solver(canon_eq, funcs, t)
+        except NotImplementedError:
+            sol = None
+
+        if sol is None:
+            sol = _component_solver(canon_eq, funcs, t)
+
+        sols.append(sol)
+
+    if sols:
+        final_sols = []
+        variables = Tuple(*eqs).free_symbols
+
+        for sol in sols:
+
+            sol = _select_equations(sol, funcs)
+            sol = constant_renumber(sol, variables=variables)
+
+            if ics:
+                constants = Tuple(*sol).free_symbols - variables
+                solved_constants = solve_ics(sol, funcs, constants, ics)
+                sol = [s.subs(solved_constants) for s in sol]
+
+            if simplify:
+                constants = Tuple(*sol).free_symbols - variables
+                sol = simpsol(sol, [t], constants, doit=doit)
+
+            final_sols.append(sol)
+
+        sols = final_sols
+
+    return sols

pllava/lib/python3.10/site-packages/sympy/solvers/pde.py

@@ -0,0 +1,971 @@
+"""
+This module contains pdsolve() and different helper functions that it
+uses. It is heavily inspired by the ode module and hence the basic
+infrastructure remains the same.
+
+**Functions in this module**
+
+    These are the user functions in this module:
+
+    - pdsolve()     - Solves PDE's
+    - classify_pde() - Classifies PDEs into possible hints for dsolve().
+    - pde_separate() - Separate variables in partial differential equation either by
+                       additive or multiplicative separation approach.
+
+    These are the helper functions in this module:
+
+    - pde_separate_add() - Helper function for searching additive separable solutions.
+    - pde_separate_mul() - Helper function for searching multiplicative
+                           separable solutions.
+
+**Currently implemented solver methods**
+
+The following methods are implemented for solving partial differential
+equations.  See the docstrings of the various pde_hint() functions for
+more information on each (run help(pde)):
+
+  - 1st order linear homogeneous partial differential equations
+    with constant coefficients.
+  - 1st order linear general partial differential equations
+    with constant coefficients.
+  - 1st order linear partial differential equations with
+    variable coefficients.
+
+"""
+from functools import reduce
+
+from itertools import combinations_with_replacement
+from sympy.simplify import simplify  # type: ignore
+from sympy.core import Add, S
+from sympy.core.function import Function, expand, AppliedUndef, Subs
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Symbol, Wild, symbols
+from sympy.functions import exp
+from sympy.integrals.integrals import Integral, integrate
+from sympy.utilities.iterables import has_dups, is_sequence
+from sympy.utilities.misc import filldedent
+
+from sympy.solvers.deutils import _preprocess, ode_order, _desolve
+from sympy.solvers.solvers import solve
+from sympy.simplify.radsimp import collect
+
+import operator
+
+
+allhints = (
+    "1st_linear_constant_coeff_homogeneous",
+    "1st_linear_constant_coeff",
+    "1st_linear_constant_coeff_Integral",
+    "1st_linear_variable_coeff"
+    )
+
+
+def pdsolve(eq, func=None, hint='default', dict=False, solvefun=None, **kwargs):
+    """
+    Solves any (supported) kind of partial differential equation.
+
+    **Usage**
+
+        pdsolve(eq, f(x,y), hint) -> Solve partial differential equation
+        eq for function f(x,y), using method hint.
+
+    **Details**
+
+        ``eq`` can be any supported partial differential equation (see
+            the pde docstring for supported methods).  This can either
+            be an Equality, or an expression, which is assumed to be
+            equal to 0.
+
+        ``f(x,y)`` is a function of two variables whose derivatives in that
+            variable make up the partial differential equation. In many
+            cases it is not necessary to provide this; it will be autodetected
+            (and an error raised if it could not be detected).
+
+        ``hint`` is the solving method that you want pdsolve to use.  Use
+            classify_pde(eq, f(x,y)) to get all of the possible hints for
+            a PDE.  The default hint, 'default', will use whatever hint
+            is returned first by classify_pde().  See Hints below for
+            more options that you can use for hint.
+
+        ``solvefun`` is the convention used for arbitrary functions returned
+            by the PDE solver. If not set by the user, it is set by default
+            to be F.
+
+    **Hints**
+
+        Aside from the various solving methods, there are also some
+        meta-hints that you can pass to pdsolve():
+
+        "default":
+                This uses whatever hint is returned first by
+                classify_pde(). This is the default argument to
+                pdsolve().
+
+        "all":
+                To make pdsolve apply all relevant classification hints,
+                use pdsolve(PDE, func, hint="all").  This will return a
+                dictionary of hint:solution terms.  If a hint causes
+                pdsolve to raise the NotImplementedError, value of that
+                hint's key will be the exception object raised.  The
+                dictionary will also include some special keys:
+
+                - order: The order of the PDE.  See also ode_order() in
+                  deutils.py
+                - default: The solution that would be returned by
+                  default.  This is the one produced by the hint that
+                  appears first in the tuple returned by classify_pde().
+
+        "all_Integral":
+                This is the same as "all", except if a hint also has a
+                corresponding "_Integral" hint, it only returns the
+                "_Integral" hint.  This is useful if "all" causes
+                pdsolve() to hang because of a difficult or impossible
+                integral.  This meta-hint will also be much faster than
+                "all", because integrate() is an expensive routine.
+
+        See also the classify_pde() docstring for more info on hints,
+        and the pde docstring for a list of all supported hints.
+
+    **Tips**
+        - You can declare the derivative of an unknown function this way:
+
+            >>> from sympy import Function, Derivative
+            >>> from sympy.abc import x, y # x and y are the independent variables
+            >>> f = Function("f")(x, y) # f is a function of x and y
+            >>> # fx will be the partial derivative of f with respect to x
+            >>> fx = Derivative(f, x)
+            >>> # fy will be the partial derivative of f with respect to y
+            >>> fy = Derivative(f, y)
+
+        - See test_pde.py for many tests, which serves also as a set of
+          examples for how to use pdsolve().
+        - pdsolve always returns an Equality class (except for the case
+          when the hint is "all" or "all_Integral"). Note that it is not possible
+          to get an explicit solution for f(x, y) as in the case of ODE's
+        - Do help(pde.pde_hintname) to get help more information on a
+          specific hint
+
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.pde import pdsolve
+    >>> from sympy import Function, Eq
+    >>> from sympy.abc import x, y
+    >>> f = Function('f')
+    >>> u = f(x, y)
+    >>> ux = u.diff(x)
+    >>> uy = u.diff(y)
+    >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0)
+    >>> pdsolve(eq)
+    Eq(f(x, y), F(3*x - 2*y)*exp(-2*x/13 - 3*y/13))
+
+    """
+
+    if not solvefun:
+        solvefun = Function('F')
+
+    # See the docstring of _desolve for more details.
+    hints = _desolve(eq, func=func, hint=hint, simplify=True,
+                     type='pde', **kwargs)
+    eq = hints.pop('eq', False)
+    all_ = hints.pop('all', False)
+
+    if all_:
+        # TODO : 'best' hint should be implemented when adequate
+        # number of hints are added.
+        pdedict = {}
+        failed_hints = {}
+        gethints = classify_pde(eq, dict=True)
+        pdedict.update({'order': gethints['order'],
+                        'default': gethints['default']})
+        for hint in hints:
+            try:
+                rv = _helper_simplify(eq, hint, hints[hint]['func'],
+                    hints[hint]['order'], hints[hint][hint], solvefun)
+            except NotImplementedError as detail:
+                failed_hints[hint] = detail
+            else:
+                pdedict[hint] = rv
+        pdedict.update(failed_hints)
+        return pdedict
+
+    else:
+        return _helper_simplify(eq, hints['hint'], hints['func'],
+                                hints['order'], hints[hints['hint']], solvefun)
+
+
+def _helper_simplify(eq, hint, func, order, match, solvefun):
+    """Helper function of pdsolve that calls the respective
+    pde functions to solve for the partial differential
+    equations. This minimizes the computation in
+    calling _desolve multiple times.
+    """
+
+    if hint.endswith("_Integral"):
+        solvefunc = globals()[
+            "pde_" + hint[:-len("_Integral")]]
+    else:
+        solvefunc = globals()["pde_" + hint]
+    return _handle_Integral(solvefunc(eq, func, order,
+        match, solvefun), func, order, hint)
+
+
+def _handle_Integral(expr, func, order, hint):
+    r"""
+    Converts a solution with integrals in it into an actual solution.
+
+    Simplifies the integral mainly using doit()
+    """
+    if hint.endswith("_Integral"):
+        return expr
+
+    elif hint == "1st_linear_constant_coeff":
+        return simplify(expr.doit())
+
+    else:
+        return expr
+
+
+def classify_pde(eq, func=None, dict=False, *, prep=True, **kwargs):
+    """
+    Returns a tuple of possible pdsolve() classifications for a PDE.
+
+    The tuple is ordered so that first item is the classification that
+    pdsolve() uses to solve the PDE by default.  In general,
+    classifications near the beginning of the list will produce
+    better solutions faster than those near the end, though there are
+    always exceptions.  To make pdsolve use a different classification,
+    use pdsolve(PDE, func, hint=<classification>).  See also the pdsolve()
+    docstring for different meta-hints you can use.
+
+    If ``dict`` is true, classify_pde() will return a dictionary of
+    hint:match expression terms. This is intended for internal use by
+    pdsolve().  Note that because dictionaries are ordered arbitrarily,
+    this will most likely not be in the same order as the tuple.
+
+    You can get help on different hints by doing help(pde.pde_hintname),
+    where hintname is the name of the hint without "_Integral".
+
+    See sympy.pde.allhints or the sympy.pde docstring for a list of all
+    supported hints that can be returned from classify_pde.
+
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.pde import classify_pde
+    >>> from sympy import Function, Eq
+    >>> from sympy.abc import x, y
+    >>> f = Function('f')
+    >>> u = f(x, y)
+    >>> ux = u.diff(x)
+    >>> uy = u.diff(y)
+    >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0)
+    >>> classify_pde(eq)
+    ('1st_linear_constant_coeff_homogeneous',)
+    """
+
+    if func and len(func.args) != 2:
+        raise NotImplementedError("Right now only partial "
+            "differential equations of two variables are supported")
+
+    if prep or func is None:
+        prep, func_ = _preprocess(eq, func)
+        if func is None:
+            func = func_
+
+    if isinstance(eq, Equality):
+        if eq.rhs != 0:
+            return classify_pde(eq.lhs - eq.rhs, func)
+        eq = eq.lhs
+
+    f = func.func
+    x = func.args[0]
+    y = func.args[1]
+    fx = f(x,y).diff(x)
+    fy = f(x,y).diff(y)
+
+    # TODO : For now pde.py uses support offered by the ode_order function
+    # to find the order with respect to a multi-variable function. An
+    # improvement could be to classify the order of the PDE on the basis of
+    # individual variables.
+    order = ode_order(eq, f(x,y))
+
+    # hint:matchdict or hint:(tuple of matchdicts)
+    # Also will contain "default":<default hint> and "order":order items.
+    matching_hints = {'order': order}
+
+    if not order:
+        if dict:
+            matching_hints["default"] = None
+            return matching_hints
+        return ()
+
+    eq = expand(eq)
+
+    a = Wild('a', exclude = [f(x,y)])
+    b = Wild('b', exclude = [f(x,y), fx, fy, x, y])
+    c = Wild('c', exclude = [f(x,y), fx, fy, x, y])
+    d = Wild('d', exclude = [f(x,y), fx, fy, x, y])
+    e = Wild('e', exclude = [f(x,y), fx, fy])
+    n = Wild('n', exclude = [x, y])
+    # Try removing the smallest power of f(x,y)
+    # from the highest partial derivatives of f(x,y)
+    reduced_eq = eq
+    if eq.is_Add:
+        power = None
+        for i in set(combinations_with_replacement((x,y), order)):
+            coeff = eq.coeff(f(x,y).diff(*i))
+            if coeff == 1:
+                continue
+            match = coeff.match(a*f(x,y)**n)
+            if match and match[a]:
+                if power is None or match[n] < power:
+                    power = match[n]
+        if power:
+            den = f(x,y)**power
+            reduced_eq = Add(*[arg/den for arg in eq.args])
+
+    if order == 1:
+        reduced_eq = collect(reduced_eq, f(x, y))
+        r = reduced_eq.match(b*fx + c*fy + d*f(x,y) + e)
+        if r:
+            if not r[e]:
+                ## Linear first-order homogeneous partial-differential
+                ## equation with constant coefficients
+                r.update({'b': b, 'c': c, 'd': d})
+                matching_hints["1st_linear_constant_coeff_homogeneous"] = r
+            elif r[b]**2 + r[c]**2 != 0:
+                ## Linear first-order general partial-differential
+                ## equation with constant coefficients
+                r.update({'b': b, 'c': c, 'd': d, 'e': e})
+                matching_hints["1st_linear_constant_coeff"] = r
+                matching_hints["1st_linear_constant_coeff_Integral"] = r
+
+        else:
+            b = Wild('b', exclude=[f(x, y), fx, fy])
+            c = Wild('c', exclude=[f(x, y), fx, fy])
+            d = Wild('d', exclude=[f(x, y), fx, fy])
+            r = reduced_eq.match(b*fx + c*fy + d*f(x,y) + e)
+            if r:
+                r.update({'b': b, 'c': c, 'd': d, 'e': e})
+                matching_hints["1st_linear_variable_coeff"] = r
+
+    # Order keys based on allhints.
+    rettuple = tuple(i for i in allhints if i in matching_hints)
+
+    if dict:
+        # Dictionaries are ordered arbitrarily, so make note of which
+        # hint would come first for pdsolve().  Use an ordered dict in Py 3.
+        matching_hints["default"] = None
+        matching_hints["ordered_hints"] = rettuple
+        for i in allhints:
+            if i in matching_hints:
+                matching_hints["default"] = i
+                break
+        return matching_hints
+    return rettuple
+
+
+def checkpdesol(pde, sol, func=None, solve_for_func=True):
+    """
+    Checks if the given solution satisfies the partial differential
+    equation.
+
+    pde is the partial differential equation which can be given in the
+    form of an equation or an expression. sol is the solution for which
+    the pde is to be checked. This can also be given in an equation or
+    an expression form. If the function is not provided, the helper
+    function _preprocess from deutils is used to identify the function.
+
+    If a sequence of solutions is passed, the same sort of container will be
+    used to return the result for each solution.
+
+    The following methods are currently being implemented to check if the
+    solution satisfies the PDE:
+
+        1. Directly substitute the solution in the PDE and check. If the
+           solution has not been solved for f, then it will solve for f
+           provided solve_for_func has not been set to False.
+
+    If the solution satisfies the PDE, then a tuple (True, 0) is returned.
+    Otherwise a tuple (False, expr) where expr is the value obtained
+    after substituting the solution in the PDE. However if a known solution
+    returns False, it may be due to the inability of doit() to simplify it to zero.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, symbols
+    >>> from sympy.solvers.pde import checkpdesol, pdsolve
+    >>> x, y = symbols('x y')
+    >>> f = Function('f')
+    >>> eq = 2*f(x,y) + 3*f(x,y).diff(x) + 4*f(x,y).diff(y)
+    >>> sol = pdsolve(eq)
+    >>> assert checkpdesol(eq, sol)[0]
+    >>> eq = x*f(x,y) + f(x,y).diff(x)
+    >>> checkpdesol(eq, sol)
+    (False, (x*F(4*x - 3*y) - 6*F(4*x - 3*y)/25 + 4*Subs(Derivative(F(_xi_1), _xi_1), _xi_1, 4*x - 3*y))*exp(-6*x/25 - 8*y/25))
+    """
+
+    # Converting the pde into an equation
+    if not isinstance(pde, Equality):
+        pde = Eq(pde, 0)
+
+    # If no function is given, try finding the function present.
+    if func is None:
+        try:
+            _, func = _preprocess(pde.lhs)
+        except ValueError:
+            funcs = [s.atoms(AppliedUndef) for s in (
+                sol if is_sequence(sol, set) else [sol])]
+            funcs = set().union(funcs)
+            if len(funcs) != 1:
+                raise ValueError(
+                    'must pass func arg to checkpdesol for this case.')
+            func = funcs.pop()
+
+    # If the given solution is in the form of a list or a set
+    # then return a list or set of tuples.
+    if is_sequence(sol, set):
+        return type(sol)([checkpdesol(
+            pde, i, func=func,
+            solve_for_func=solve_for_func) for i in sol])
+
+    # Convert solution into an equation
+    if not isinstance(sol, Equality):
+        sol = Eq(func, sol)
+    elif sol.rhs == func:
+        sol = sol.reversed
+
+    # Try solving for the function
+    solved = sol.lhs == func and not sol.rhs.has(func)
+    if solve_for_func and not solved:
+        solved = solve(sol, func)
+        if solved:
+            if len(solved) == 1:
+                return checkpdesol(pde, Eq(func, solved[0]),
+                    func=func, solve_for_func=False)
+            else:
+                return checkpdesol(pde, [Eq(func, t) for t in solved],
+                    func=func, solve_for_func=False)
+
+    # try direct substitution of the solution into the PDE and simplify
+    if sol.lhs == func:
+        pde = pde.lhs - pde.rhs
+        s = simplify(pde.subs(func, sol.rhs).doit())
+        return s is S.Zero, s
+
+    raise NotImplementedError(filldedent('''
+        Unable to test if %s is a solution to %s.''' % (sol, pde)))
+
+
+
+def pde_1st_linear_constant_coeff_homogeneous(eq, func, order, match, solvefun):
+    r"""
+    Solves a first order linear homogeneous
+    partial differential equation with constant coefficients.
+
+    The general form of this partial differential equation is
+
+    .. math:: a \frac{\partial f(x,y)}{\partial x}
+              + b \frac{\partial f(x,y)}{\partial y} + c f(x,y) = 0
+
+    where `a`, `b` and `c` are constants.
+
+    The general solution is of the form:
+
+    .. math::
+        f(x, y) = F(- a y + b x ) e^{- \frac{c (a x + b y)}{a^2 + b^2}}
+
+    and can be found in SymPy with ``pdsolve``::
+
+        >>> from sympy.solvers import pdsolve
+        >>> from sympy.abc import x, y, a, b, c
+        >>> from sympy import Function, pprint
+        >>> f = Function('f')
+        >>> u = f(x,y)
+        >>> ux = u.diff(x)
+        >>> uy = u.diff(y)
+        >>> genform = a*ux + b*uy + c*u
+        >>> pprint(genform)
+          d               d
+        a*--(f(x, y)) + b*--(f(x, y)) + c*f(x, y)
+          dx              dy
+
+        >>> pprint(pdsolve(genform))
+                                 -c*(a*x + b*y)
+                                 ---------------
+                                      2    2
+                                     a  + b
+        f(x, y) = F(-a*y + b*x)*e
+
+    Examples
+    ========
+
+    >>> from sympy import pdsolve
+    >>> from sympy import Function, pprint
+    >>> from sympy.abc import x,y
+    >>> f = Function('f')
+    >>> pdsolve(f(x,y) + f(x,y).diff(x) + f(x,y).diff(y))
+    Eq(f(x, y), F(x - y)*exp(-x/2 - y/2))
+    >>> pprint(pdsolve(f(x,y) + f(x,y).diff(x) + f(x,y).diff(y)))
+                          x   y
+                        - - - -
+                          2   2
+    f(x, y) = F(x - y)*e
+
+    References
+    ==========
+
+    - Viktor Grigoryan, "Partial Differential Equations"
+      Math 124A - Fall 2010, pp.7
+
+    """
+    # TODO : For now homogeneous first order linear PDE's having
+    # two variables are implemented. Once there is support for
+    # solving systems of ODE's, this can be extended to n variables.
+
+    f = func.func
+    x = func.args[0]
+    y = func.args[1]
+    b = match[match['b']]
+    c = match[match['c']]
+    d = match[match['d']]
+    return Eq(f(x,y), exp(-S(d)/(b**2 + c**2)*(b*x + c*y))*solvefun(c*x - b*y))
+
+
+def pde_1st_linear_constant_coeff(eq, func, order, match, solvefun):
+    r"""
+    Solves a first order linear partial differential equation
+    with constant coefficients.
+
+    The general form of this partial differential equation is
+
+    .. math:: a \frac{\partial f(x,y)}{\partial x}
+              + b \frac{\partial f(x,y)}{\partial y}
+              + c f(x,y) = G(x,y)
+
+    where `a`, `b` and `c` are constants and `G(x, y)` can be an arbitrary
+    function in `x` and `y`.
+
+    The general solution of the PDE is:
+
+    .. math::
+        f(x, y) = \left. \left[F(\eta) + \frac{1}{a^2 + b^2}
+        \int\limits^{a x + b y} G\left(\frac{a \xi + b \eta}{a^2 + b^2},
+        \frac{- a \eta + b \xi}{a^2 + b^2} \right)
+        e^{\frac{c \xi}{a^2 + b^2}}\, d\xi\right]
+        e^{- \frac{c \xi}{a^2 + b^2}}
+        \right|_{\substack{\eta=- a y + b x\\ \xi=a x + b y }}\, ,
+
+    where `F(\eta)` is an arbitrary single-valued function. The solution
+    can be found in SymPy with ``pdsolve``::
+
+        >>> from sympy.solvers import pdsolve
+        >>> from sympy.abc import x, y, a, b, c
+        >>> from sympy import Function, pprint
+        >>> f = Function('f')
+        >>> G = Function('G')
+        >>> u = f(x, y)
+        >>> ux = u.diff(x)
+        >>> uy = u.diff(y)
+        >>> genform = a*ux + b*uy + c*u - G(x,y)
+        >>> pprint(genform)
+          d               d
+        a*--(f(x, y)) + b*--(f(x, y)) + c*f(x, y) - G(x, y)
+          dx              dy
+        >>> pprint(pdsolve(genform, hint='1st_linear_constant_coeff_Integral'))
+                  //          a*x + b*y                                             \         \|
+                  ||              /                                                 |         ||
+                  ||             |                                                  |         ||
+                  ||             |                                      c*xi        |         ||
+                  ||             |                                     -------      |         ||
+                  ||             |                                      2    2      |         ||
+                  ||             |      /a*xi + b*eta  -a*eta + b*xi\  a  + b       |         ||
+                  ||             |     G|------------, -------------|*e        d(xi)|         ||
+                  ||             |      |   2    2         2    2   |               |         ||
+                  ||             |      \  a  + b         a  + b    /               |  -c*xi  ||
+                  ||             |                                                  |  -------||
+                  ||            /                                                   |   2    2||
+                  ||                                                                |  a  + b ||
+        f(x, y) = ||F(eta) + -------------------------------------------------------|*e       ||
+                  ||                                  2    2                        |         ||
+                  \\                                 a  + b                         /         /|eta=-a*y + b*x, xi=a*x + b*y
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.pde import pdsolve
+    >>> from sympy import Function, pprint, exp
+    >>> from sympy.abc import x,y
+    >>> f = Function('f')
+    >>> eq = -2*f(x,y).diff(x) + 4*f(x,y).diff(y) + 5*f(x,y) - exp(x + 3*y)
+    >>> pdsolve(eq)
+    Eq(f(x, y), (F(4*x + 2*y)*exp(x/2) + exp(x + 4*y)/15)*exp(-y))
+
+    References
+    ==========
+
+    - Viktor Grigoryan, "Partial Differential Equations"
+      Math 124A - Fall 2010, pp.7
+
+    """
+
+    # TODO : For now homogeneous first order linear PDE's having
+    # two variables are implemented. Once there is support for
+    # solving systems of ODE's, this can be extended to n variables.
+    xi, eta = symbols("xi eta")
+    f = func.func
+    x = func.args[0]
+    y = func.args[1]
+    b = match[match['b']]
+    c = match[match['c']]
+    d = match[match['d']]
+    e = -match[match['e']]
+    expterm = exp(-S(d)/(b**2 + c**2)*xi)
+    functerm = solvefun(eta)
+    solvedict = solve((b*x + c*y - xi, c*x - b*y - eta), x, y)
+    # Integral should remain as it is in terms of xi,
+    # doit() should be done in _handle_Integral.
+    genterm = (1/S(b**2 + c**2))*Integral(
+        (1/expterm*e).subs(solvedict), (xi, b*x + c*y))
+    return Eq(f(x,y), Subs(expterm*(functerm + genterm),
+        (eta, xi), (c*x - b*y, b*x + c*y)))
+
+
+def pde_1st_linear_variable_coeff(eq, func, order, match, solvefun):
+    r"""
+    Solves a first order linear partial differential equation
+    with variable coefficients. The general form of this partial
+    differential equation is
+
+    .. math:: a(x, y) \frac{\partial f(x, y)}{\partial x}
+                + b(x, y) \frac{\partial f(x, y)}{\partial y}
+                + c(x, y) f(x, y) = G(x, y)
+
+    where `a(x, y)`, `b(x, y)`, `c(x, y)` and `G(x, y)` are arbitrary
+    functions in `x` and `y`. This PDE is converted into an ODE by
+    making the following transformation:
+
+    1. `\xi` as `x`
+
+    2. `\eta` as the constant in the solution to the differential
+       equation `\frac{dy}{dx} = -\frac{b}{a}`
+
+    Making the previous substitutions reduces it to the linear ODE
+
+    .. math:: a(\xi, \eta)\frac{du}{d\xi} + c(\xi, \eta)u - G(\xi, \eta) = 0
+
+    which can be solved using ``dsolve``.
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import Function, pprint
+    >>> a, b, c, G, f= [Function(i) for i in ['a', 'b', 'c', 'G', 'f']]
+    >>> u = f(x,y)
+    >>> ux = u.diff(x)
+    >>> uy = u.diff(y)
+    >>> genform = a(x, y)*u + b(x, y)*ux + c(x, y)*uy - G(x,y)
+    >>> pprint(genform)
+                                         d                     d
+    -G(x, y) + a(x, y)*f(x, y) + b(x, y)*--(f(x, y)) + c(x, y)*--(f(x, y))
+                                         dx                    dy
+
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.pde import pdsolve
+    >>> from sympy import Function, pprint
+    >>> from sympy.abc import x,y
+    >>> f = Function('f')
+    >>> eq =  x*(u.diff(x)) - y*(u.diff(y)) + y**2*u - y**2
+    >>> pdsolve(eq)
+    Eq(f(x, y), F(x*y)*exp(y**2/2) + 1)
+
+    References
+    ==========
+
+    - Viktor Grigoryan, "Partial Differential Equations"
+      Math 124A - Fall 2010, pp.7
+
+    """
+    from sympy.solvers.ode import dsolve
+
+    xi, eta = symbols("xi eta")
+    f = func.func
+    x = func.args[0]
+    y = func.args[1]
+    b = match[match['b']]
+    c = match[match['c']]
+    d = match[match['d']]
+    e = -match[match['e']]
+
+
+    if not d:
+         # To deal with cases like b*ux = e or c*uy = e
+         if not (b and c):
+            if c:
+                try:
+                    tsol = integrate(e/c, y)
+                except NotImplementedError:
+                    raise NotImplementedError("Unable to find a solution"
+                        " due to inability of integrate")
+                else:
+                    return Eq(f(x,y), solvefun(x) + tsol)
+            if b:
+                try:
+                    tsol = integrate(e/b, x)
+                except NotImplementedError:
+                    raise NotImplementedError("Unable to find a solution"
+                        " due to inability of integrate")
+                else:
+                    return Eq(f(x,y), solvefun(y) + tsol)
+
+    if not c:
+        # To deal with cases when c is 0, a simpler method is used.
+        # The PDE reduces to b*(u.diff(x)) + d*u = e, which is a linear ODE in x
+        plode = f(x).diff(x)*b + d*f(x) - e
+        sol = dsolve(plode, f(x))
+        syms = sol.free_symbols - plode.free_symbols - {x, y}
+        rhs = _simplify_variable_coeff(sol.rhs, syms, solvefun, y)
+        return Eq(f(x, y), rhs)
+
+    if not b:
+        # To deal with cases when b is 0, a simpler method is used.
+        # The PDE reduces to c*(u.diff(y)) + d*u = e, which is a linear ODE in y
+        plode = f(y).diff(y)*c + d*f(y) - e
+        sol = dsolve(plode, f(y))
+        syms = sol.free_symbols - plode.free_symbols - {x, y}
+        rhs = _simplify_variable_coeff(sol.rhs, syms, solvefun, x)
+        return Eq(f(x, y), rhs)
+
+    dummy = Function('d')
+    h = (c/b).subs(y, dummy(x))
+    sol = dsolve(dummy(x).diff(x) - h, dummy(x))
+    if isinstance(sol, list):
+        sol = sol[0]
+    solsym = sol.free_symbols - h.free_symbols - {x, y}
+    if len(solsym) == 1:
+        solsym = solsym.pop()
+        etat = (solve(sol, solsym)[0]).subs(dummy(x), y)
+        ysub = solve(eta - etat, y)[0]
+        deq = (b*(f(x).diff(x)) + d*f(x) - e).subs(y, ysub)
+        final = (dsolve(deq, f(x), hint='1st_linear')).rhs
+        if isinstance(final, list):
+            final = final[0]
+        finsyms = final.free_symbols - deq.free_symbols - {x, y}
+        rhs = _simplify_variable_coeff(final, finsyms, solvefun, etat)
+        return Eq(f(x, y), rhs)
+
+    else:
+        raise NotImplementedError("Cannot solve the partial differential equation due"
+            " to inability of constantsimp")
+
+
+def _simplify_variable_coeff(sol, syms, func, funcarg):
+    r"""
+    Helper function to replace constants by functions in 1st_linear_variable_coeff
+    """
+    eta = Symbol("eta")
+    if len(syms) == 1:
+        sym = syms.pop()
+        final = sol.subs(sym, func(funcarg))
+
+    else:
+        for sym in syms:
+            final = sol.subs(sym, func(funcarg))
+
+    return simplify(final.subs(eta, funcarg))
+
+
+def pde_separate(eq, fun, sep, strategy='mul'):
+    """Separate variables in partial differential equation either by additive
+    or multiplicative separation approach. It tries to rewrite an equation so
+    that one of the specified variables occurs on a different side of the
+    equation than the others.
+
+    :param eq: Partial differential equation
+
+    :param fun: Original function F(x, y, z)
+
+    :param sep: List of separated functions [X(x), u(y, z)]
+
+    :param strategy: Separation strategy. You can choose between additive
+        separation ('add') and multiplicative separation ('mul') which is
+        default.
+
+    Examples
+    ========
+
+    >>> from sympy import E, Eq, Function, pde_separate, Derivative as D
+    >>> from sympy.abc import x, t
+    >>> u, X, T = map(Function, 'uXT')
+
+    >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t))
+    >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='add')
+    [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)]
+
+    >>> eq = Eq(D(u(x, t), x, 2), D(u(x, t), t, 2))
+    >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='mul')
+    [Derivative(X(x), (x, 2))/X(x), Derivative(T(t), (t, 2))/T(t)]
+
+    See Also
+    ========
+    pde_separate_add, pde_separate_mul
+    """
+
+    do_add = False
+    if strategy == 'add':
+        do_add = True
+    elif strategy == 'mul':
+        do_add = False
+    else:
+        raise ValueError('Unknown strategy: %s' % strategy)
+
+    if isinstance(eq, Equality):
+        if eq.rhs != 0:
+            return pde_separate(Eq(eq.lhs - eq.rhs, 0), fun, sep, strategy)
+    else:
+        return pde_separate(Eq(eq, 0), fun, sep, strategy)
+
+    if eq.rhs != 0:
+        raise ValueError("Value should be 0")
+
+    # Handle arguments
+    orig_args = list(fun.args)
+    subs_args = [arg for s in sep for arg in s.args]
+
+    if do_add:
+        functions = reduce(operator.add, sep)
+    else:
+        functions = reduce(operator.mul, sep)
+
+    # Check whether variables match
+    if len(subs_args) != len(orig_args):
+        raise ValueError("Variable counts do not match")
+    # Check for duplicate arguments like  [X(x), u(x, y)]
+    if has_dups(subs_args):
+        raise ValueError("Duplicate substitution arguments detected")
+    # Check whether the variables match
+    if set(orig_args) != set(subs_args):
+        raise ValueError("Arguments do not match")
+
+    # Substitute original function with separated...
+    result = eq.lhs.subs(fun, functions).doit()
+
+    # Divide by terms when doing multiplicative separation
+    if not do_add:
+        eq = 0
+        for i in result.args:
+            eq += i/functions
+        result = eq
+
+    svar = subs_args[0]
+    dvar = subs_args[1:]
+    return _separate(result, svar, dvar)
+
+
+def pde_separate_add(eq, fun, sep):
+    """
+    Helper function for searching additive separable solutions.
+
+    Consider an equation of two independent variables x, y and a dependent
+    variable w, we look for the product of two functions depending on different
+    arguments:
+
+    `w(x, y, z) = X(x) + y(y, z)`
+
+    Examples
+    ========
+
+    >>> from sympy import E, Eq, Function, pde_separate_add, Derivative as D
+    >>> from sympy.abc import x, t
+    >>> u, X, T = map(Function, 'uXT')
+
+    >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t))
+    >>> pde_separate_add(eq, u(x, t), [X(x), T(t)])
+    [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)]
+
+    """
+    return pde_separate(eq, fun, sep, strategy='add')
+
+
+def pde_separate_mul(eq, fun, sep):
+    """
+    Helper function for searching multiplicative separable solutions.
+
+    Consider an equation of two independent variables x, y and a dependent
+    variable w, we look for the product of two functions depending on different
+    arguments:
+
+    `w(x, y, z) = X(x)*u(y, z)`
+
+    Examples
+    ========
+
+    >>> from sympy import Function, Eq, pde_separate_mul, Derivative as D
+    >>> from sympy.abc import x, y
+    >>> u, X, Y = map(Function, 'uXY')
+
+    >>> eq = Eq(D(u(x, y), x, 2), D(u(x, y), y, 2))
+    >>> pde_separate_mul(eq, u(x, y), [X(x), Y(y)])
+    [Derivative(X(x), (x, 2))/X(x), Derivative(Y(y), (y, 2))/Y(y)]
+
+    """
+    return pde_separate(eq, fun, sep, strategy='mul')
+
+
+def _separate(eq, dep, others):
+    """Separate expression into two parts based on dependencies of variables."""
+
+    # FIRST PASS
+    # Extract derivatives depending our separable variable...
+    terms = set()
+    for term in eq.args:
+        if term.is_Mul:
+            for i in term.args:
+                if i.is_Derivative and not i.has(*others):
+                    terms.add(term)
+                    continue
+        elif term.is_Derivative and not term.has(*others):
+            terms.add(term)
+    # Find the factor that we need to divide by
+    div = set()
+    for term in terms:
+        ext, sep = term.expand().as_independent(dep)
+        # Failed?
+        if sep.has(*others):
+            return None
+        div.add(ext)
+    # FIXME: Find lcm() of all the divisors and divide with it, instead of
+    # current hack :(
+    # https://github.com/sympy/sympy/issues/4597
+    if len(div) > 0:
+        # double sum required or some tests will fail
+        eq = Add(*[simplify(Add(*[term/i for i in div])) for term in eq.args])
+    # SECOND PASS - separate the derivatives
+    div = set()
+    lhs = rhs = 0
+    for term in eq.args:
+        # Check, whether we have already term with independent variable...
+        if not term.has(*others):
+            lhs += term
+            continue
+        # ...otherwise, try to separate
+        temp, sep = term.expand().as_independent(dep)
+        # Failed?
+        if sep.has(*others):
+            return None
+        # Extract the divisors
+        div.add(sep)
+        rhs -= term.expand()
+    # Do the division
+    fulldiv = reduce(operator.add, div)
+    lhs = simplify(lhs/fulldiv).expand()
+    rhs = simplify(rhs/fulldiv).expand()
+    # ...and check whether we were successful :)
+    if lhs.has(*others) or rhs.has(dep):
+        return None
+    return [lhs, rhs]

pllava/lib/python3.10/site-packages/sympy/solvers/polysys.py

@@ -0,0 +1,437 @@
+"""Solvers of systems of polynomial equations. """
+import itertools
+
+from sympy.core import S
+from sympy.core.sorting import default_sort_key
+from sympy.polys import Poly, groebner, roots
+from sympy.polys.polytools import parallel_poly_from_expr
+from sympy.polys.polyerrors import (ComputationFailed,
+    PolificationFailed, CoercionFailed)
+from sympy.simplify import rcollect
+from sympy.utilities import postfixes
+from sympy.utilities.misc import filldedent
+
+
+class SolveFailed(Exception):
+    """Raised when solver's conditions were not met. """
+
+
+def solve_poly_system(seq, *gens, strict=False, **args):
+    """
+    Return a list of solutions for the system of polynomial equations
+    or else None.
+
+    Parameters
+    ==========
+
+    seq: a list/tuple/set
+        Listing all the equations that are needed to be solved
+    gens: generators
+        generators of the equations in seq for which we want the
+        solutions
+    strict: a boolean (default is False)
+        if strict is True, NotImplementedError will be raised if
+        the solution is known to be incomplete (which can occur if
+        not all solutions are expressible in radicals)
+    args: Keyword arguments
+        Special options for solving the equations.
+
+
+    Returns
+    =======
+
+    List[Tuple]
+        a list of tuples with elements being solutions for the
+        symbols in the order they were passed as gens
+    None
+        None is returned when the computed basis contains only the ground.
+
+    Examples
+    ========
+
+    >>> from sympy import solve_poly_system
+    >>> from sympy.abc import x, y
+
+    >>> solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y)
+    [(0, 0), (2, -sqrt(2)), (2, sqrt(2))]
+
+    >>> solve_poly_system([x**5 - x + y**3, y**2 - 1], x, y, strict=True)
+    Traceback (most recent call last):
+    ...
+    UnsolvableFactorError
+
+    """
+    try:
+        polys, opt = parallel_poly_from_expr(seq, *gens, **args)
+    except PolificationFailed as exc:
+        raise ComputationFailed('solve_poly_system', len(seq), exc)
+
+    if len(polys) == len(opt.gens) == 2:
+        f, g = polys
+
+        if all(i <= 2 for i in f.degree_list() + g.degree_list()):
+            try:
+                return solve_biquadratic(f, g, opt)
+            except SolveFailed:
+                pass
+
+    return solve_generic(polys, opt, strict=strict)
+
+
+def solve_biquadratic(f, g, opt):
+    """Solve a system of two bivariate quadratic polynomial equations.
+
+    Parameters
+    ==========
+
+    f: a single Expr or Poly
+        First equation
+    g: a single Expr or Poly
+        Second Equation
+    opt: an Options object
+        For specifying keyword arguments and generators
+
+    Returns
+    =======
+
+    List[Tuple]
+        a list of tuples with elements being solutions for the
+        symbols in the order they were passed as gens
+    None
+        None is returned when the computed basis contains only the ground.
+
+    Examples
+    ========
+
+    >>> from sympy import Options, Poly
+    >>> from sympy.abc import x, y
+    >>> from sympy.solvers.polysys import solve_biquadratic
+    >>> NewOption = Options((x, y), {'domain': 'ZZ'})
+
+    >>> a = Poly(y**2 - 4 + x, y, x, domain='ZZ')
+    >>> b = Poly(y*2 + 3*x - 7, y, x, domain='ZZ')
+    >>> solve_biquadratic(a, b, NewOption)
+    [(1/3, 3), (41/27, 11/9)]
+
+    >>> a = Poly(y + x**2 - 3, y, x, domain='ZZ')
+    >>> b = Poly(-y + x - 4, y, x, domain='ZZ')
+    >>> solve_biquadratic(a, b, NewOption)
+    [(7/2 - sqrt(29)/2, -sqrt(29)/2 - 1/2), (sqrt(29)/2 + 7/2, -1/2 + \
+      sqrt(29)/2)]
+    """
+    G = groebner([f, g])
+
+    if len(G) == 1 and G[0].is_ground:
+        return None
+
+    if len(G) != 2:
+        raise SolveFailed
+
+    x, y = opt.gens
+    p, q = G
+    if not p.gcd(q).is_ground:
+        # not 0-dimensional
+        raise SolveFailed
+
+    p = Poly(p, x, expand=False)
+    p_roots = [rcollect(expr, y) for expr in roots(p).keys()]
+
+    q = q.ltrim(-1)
+    q_roots = list(roots(q).keys())
+
+    solutions = [(p_root.subs(y, q_root), q_root) for q_root, p_root in
+                 itertools.product(q_roots, p_roots)]
+
+    return sorted(solutions, key=default_sort_key)
+
+
+def solve_generic(polys, opt, strict=False):
+    """
+    Solve a generic system of polynomial equations.
+
+    Returns all possible solutions over C[x_1, x_2, ..., x_m] of a
+    set F = { f_1, f_2, ..., f_n } of polynomial equations, using
+    Groebner basis approach. For now only zero-dimensional systems
+    are supported, which means F can have at most a finite number
+    of solutions. If the basis contains only the ground, None is
+    returned.
+
+    The algorithm works by the fact that, supposing G is the basis
+    of F with respect to an elimination order (here lexicographic
+    order is used), G and F generate the same ideal, they have the
+    same set of solutions. By the elimination property, if G is a
+    reduced, zero-dimensional Groebner basis, then there exists an
+    univariate polynomial in G (in its last variable). This can be
+    solved by computing its roots. Substituting all computed roots
+    for the last (eliminated) variable in other elements of G, new
+    polynomial system is generated. Applying the above procedure
+    recursively, a finite number of solutions can be found.
+
+    The ability of finding all solutions by this procedure depends
+    on the root finding algorithms. If no solutions were found, it
+    means only that roots() failed, but the system is solvable. To
+    overcome this difficulty use numerical algorithms instead.
+
+    Parameters
+    ==========
+
+    polys: a list/tuple/set
+        Listing all the polynomial equations that are needed to be solved
+    opt: an Options object
+        For specifying keyword arguments and generators
+    strict: a boolean
+        If strict is True, NotImplementedError will be raised if the solution
+        is known to be incomplete
+
+    Returns
+    =======
+
+    List[Tuple]
+        a list of tuples with elements being solutions for the
+        symbols in the order they were passed as gens
+    None
+        None is returned when the computed basis contains only the ground.
+
+    References
+    ==========
+
+    .. [Buchberger01] B. Buchberger, Groebner Bases: A Short
+    Introduction for Systems Theorists, In: R. Moreno-Diaz,
+    B. Buchberger, J.L. Freire, Proceedings of EUROCAST'01,
+    February, 2001
+
+    .. [Cox97] D. Cox, J. Little, D. O'Shea, Ideals, Varieties
+    and Algorithms, Springer, Second Edition, 1997, pp. 112
+
+    Raises
+    ========
+
+    NotImplementedError
+        If the system is not zero-dimensional (does not have a finite
+        number of solutions)
+
+    UnsolvableFactorError
+        If ``strict`` is True and not all solution components are
+        expressible in radicals
+
+    Examples
+    ========
+
+    >>> from sympy import Poly, Options
+    >>> from sympy.solvers.polysys import solve_generic
+    >>> from sympy.abc import x, y
+    >>> NewOption = Options((x, y), {'domain': 'ZZ'})
+
+    >>> a = Poly(x - y + 5, x, y, domain='ZZ')
+    >>> b = Poly(x + y - 3, x, y, domain='ZZ')
+    >>> solve_generic([a, b], NewOption)
+    [(-1, 4)]
+
+    >>> a = Poly(x - 2*y + 5, x, y, domain='ZZ')
+    >>> b = Poly(2*x - y - 3, x, y, domain='ZZ')
+    >>> solve_generic([a, b], NewOption)
+    [(11/3, 13/3)]
+
+    >>> a = Poly(x**2 + y, x, y, domain='ZZ')
+    >>> b = Poly(x + y*4, x, y, domain='ZZ')
+    >>> solve_generic([a, b], NewOption)
+    [(0, 0), (1/4, -1/16)]
+
+    >>> a = Poly(x**5 - x + y**3, x, y, domain='ZZ')
+    >>> b = Poly(y**2 - 1, x, y, domain='ZZ')
+    >>> solve_generic([a, b], NewOption, strict=True)
+    Traceback (most recent call last):
+    ...
+    UnsolvableFactorError
+
+    """
+    def _is_univariate(f):
+        """Returns True if 'f' is univariate in its last variable. """
+        for monom in f.monoms():
+            if any(monom[:-1]):
+                return False
+
+        return True
+
+    def _subs_root(f, gen, zero):
+        """Replace generator with a root so that the result is nice. """
+        p = f.as_expr({gen: zero})
+
+        if f.degree(gen) >= 2:
+            p = p.expand(deep=False)
+
+        return p
+
+    def _solve_reduced_system(system, gens, entry=False):
+        """Recursively solves reduced polynomial systems. """
+        if len(system) == len(gens) == 1:
+            # the below line will produce UnsolvableFactorError if
+            # strict=True and the solution from `roots` is incomplete
+            zeros = list(roots(system[0], gens[-1], strict=strict).keys())
+            return [(zero,) for zero in zeros]
+
+        basis = groebner(system, gens, polys=True)
+
+        if len(basis) == 1 and basis[0].is_ground:
+            if not entry:
+                return []
+            else:
+                return None
+
+        univariate = list(filter(_is_univariate, basis))
+
+        if len(basis) < len(gens):
+            raise NotImplementedError(filldedent('''
+                only zero-dimensional systems supported
+                (finite number of solutions)
+                '''))
+
+        if len(univariate) == 1:
+            f = univariate.pop()
+        else:
+            raise NotImplementedError(filldedent('''
+                only zero-dimensional systems supported
+                (finite number of solutions)
+                '''))
+
+        gens = f.gens
+        gen = gens[-1]
+
+        # the below line will produce UnsolvableFactorError if
+        # strict=True and the solution from `roots` is incomplete
+        zeros = list(roots(f.ltrim(gen), strict=strict).keys())
+
+        if not zeros:
+            return []
+
+        if len(basis) == 1:
+            return [(zero,) for zero in zeros]
+
+        solutions = []
+
+        for zero in zeros:
+            new_system = []
+            new_gens = gens[:-1]
+
+            for b in basis[:-1]:
+                eq = _subs_root(b, gen, zero)
+
+                if eq is not S.Zero:
+                    new_system.append(eq)
+
+            for solution in _solve_reduced_system(new_system, new_gens):
+                solutions.append(solution + (zero,))
+
+        if solutions and len(solutions[0]) != len(gens):
+            raise NotImplementedError(filldedent('''
+                only zero-dimensional systems supported
+                (finite number of solutions)
+                '''))
+        return solutions
+
+    try:
+        result = _solve_reduced_system(polys, opt.gens, entry=True)
+    except CoercionFailed:
+        raise NotImplementedError
+
+    if result is not None:
+        return sorted(result, key=default_sort_key)
+
+
+def solve_triangulated(polys, *gens, **args):
+    """
+    Solve a polynomial system using Gianni-Kalkbrenner algorithm.
+
+    The algorithm proceeds by computing one Groebner basis in the ground
+    domain and then by iteratively computing polynomial factorizations in
+    appropriately constructed algebraic extensions of the ground domain.
+
+    Parameters
+    ==========
+
+    polys: a list/tuple/set
+        Listing all the equations that are needed to be solved
+    gens: generators
+        generators of the equations in polys for which we want the
+        solutions
+    args: Keyword arguments
+        Special options for solving the equations
+
+    Returns
+    =======
+
+    List[Tuple]
+        A List of tuples. Solutions for symbols that satisfy the
+        equations listed in polys
+
+    Examples
+    ========
+
+    >>> from sympy import solve_triangulated
+    >>> from sympy.abc import x, y, z
+
+    >>> F = [x**2 + y + z - 1, x + y**2 + z - 1, x + y + z**2 - 1]
+
+    >>> solve_triangulated(F, x, y, z)
+    [(0, 0, 1), (0, 1, 0), (1, 0, 0)]
+
+    References
+    ==========
+
+    1. Patrizia Gianni, Teo Mora, Algebraic Solution of System of
+    Polynomial Equations using Groebner Bases, AAECC-5 on Applied Algebra,
+    Algebraic Algorithms and Error-Correcting Codes, LNCS 356 247--257, 1989
+
+    """
+    G = groebner(polys, gens, polys=True)
+    G = list(reversed(G))
+
+    domain = args.get('domain')
+
+    if domain is not None:
+        for i, g in enumerate(G):
+            G[i] = g.set_domain(domain)
+
+    f, G = G[0].ltrim(-1), G[1:]
+    dom = f.get_domain()
+
+    zeros = f.ground_roots()
+    solutions = {((zero,), dom) for zero in zeros}
+
+    var_seq = reversed(gens[:-1])
+    vars_seq = postfixes(gens[1:])
+
+    for var, vars in zip(var_seq, vars_seq):
+        _solutions = set()
+
+        for values, dom in solutions:
+            H, mapping = [], list(zip(vars, values))
+
+            for g in G:
+                _vars = (var,) + vars
+
+                if g.has_only_gens(*_vars) and g.degree(var) != 0:
+                    h = g.ltrim(var).eval(dict(mapping))
+
+                    if g.degree(var) == h.degree():
+                        H.append(h)
+
+            p = min(H, key=lambda h: h.degree())
+            zeros = p.ground_roots()
+
+            for zero in zeros:
+                if not zero.is_Rational:
+                    dom_zero = dom.algebraic_field(zero)
+                else:
+                    dom_zero = dom
+
+                _solutions.add(((zero,) + values, dom_zero))
+
+        solutions = _solutions
+
+    solutions = list(solutions)
+
+    for i, (solution, _) in enumerate(solutions):
+        solutions[i] = solution
+
+    return sorted(solutions, key=default_sort_key)

pllava/lib/python3.10/site-packages/sympy/solvers/simplex.py

@@ -0,0 +1,1141 @@
+"""Tools for optimizing a linear function for a given simplex.
+
+For the linear objective function ``f`` with linear constraints
+expressed using `Le`, `Ge` or `Eq` can be found with ``lpmin`` or
+``lpmax``. The symbols are **unbounded** unless specifically
+constrained.
+
+As an alternative, the matrices describing the objective and the
+constraints, and an optional list of bounds can be passed to
+``linprog`` which will solve for the minimization of ``C*x``
+under constraints ``A*x <= b`` and/or ``Aeq*x = beq``, and
+individual bounds for variables given as ``(lo, hi)``. The values
+returned are **nonnegative** unless bounds are provided that
+indicate otherwise.
+
+Errors that might be raised are UnboundedLPError when there is no
+finite solution for the system or InfeasibleLPError when the
+constraints represent impossible conditions (i.e. a non-existant
+ simplex).
+
+Here is a simple 1-D system: minimize `x` given that ``x >= 1``.
+
+    >>> from sympy.solvers.simplex import lpmin, linprog
+    >>> from sympy.abc import x
+
+    The function and a list with the constraint is passed directly
+    to `lpmin`:
+
+    >>> lpmin(x, [x >= 1])
+    (1, {x: 1})
+
+    For `linprog` the matrix for the objective is `[1]` and the
+    uivariate constraint can be passed as a bound with None acting
+    as infinity:
+
+    >>> linprog([1], bounds=(1, None))
+    (1, [1])
+
+    Or the matrices, corresponding to ``x >= 1`` expressed as
+    ``-x <= -1`` as required by the routine, can be passed:
+
+    >>> linprog([1], [-1], [-1])
+    (1, [1])
+
+    If there is no limit for the objective, an error is raised.
+    In this case there is a valid region of interest (simplex)
+    but no limit to how small ``x`` can be:
+
+    >>> lpmin(x, [])
+    Traceback (most recent call last):
+    ...
+    sympy.solvers.simplex.UnboundedLPError:
+    Objective function can assume arbitrarily large values!
+
+    An error is raised if there is no possible solution:
+
+    >>> lpmin(x,[x<=1,x>=2])
+    Traceback (most recent call last):
+    ...
+    sympy.solvers.simplex.InfeasibleLPError:
+    Inconsistent/False constraint
+"""
+
+from sympy.core import sympify
+from sympy.core.exprtools import factor_terms
+from sympy.core.relational import Le, Ge, Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.complexes import sign
+from sympy.matrices.dense import Matrix, zeros
+from sympy.solvers.solveset import linear_eq_to_matrix
+from sympy.utilities.iterables import numbered_symbols
+from sympy.utilities.misc import filldedent
+
+
+class UnboundedLPError(Exception):
+    """
+    A linear programing problem is said to be unbounded if its objective
+    function can assume arbitrarily large values.
+
+    Example
+    =======
+
+    Suppose you want to maximize
+        2x
+    subject to
+        x >= 0
+
+    There's no upper limit that 2x can take.
+    """
+
+    pass
+
+
+class InfeasibleLPError(Exception):
+    """
+    A linear programing problem is considered infeasible if its
+    constraint set is empty. That is, if the set of all vectors
+    satisfying the contraints is empty, then the problem is infeasible.
+
+    Example
+    =======
+
+    Suppose you want to maximize
+        x
+    subject to
+        x >= 10
+        x <= 9
+
+    No x can satisfy those constraints.
+    """
+
+    pass
+
+
+def _pivot(M, i, j):
+    """
+    The pivot element `M[i, j]` is inverted and the rest of the matrix
+    modified and returned as a new matrix; original is left unmodified.
+
+    Example
+    =======
+
+    >>> from sympy.matrices.dense import Matrix
+    >>> from sympy.solvers.simplex import _pivot
+    >>> from sympy import var
+    >>> Matrix(3, 3, var('a:i'))
+    Matrix([
+    [a, b, c],
+    [d, e, f],
+    [g, h, i]])
+    >>> _pivot(_, 1, 0)
+    Matrix([
+    [-a/d, -a*e/d + b, -a*f/d + c],
+    [ 1/d,        e/d,        f/d],
+    [-g/d,  h - e*g/d,  i - f*g/d]])
+    """
+    Mi, Mj, Mij = M[i, :], M[:, j], M[i, j]
+    if Mij == 0:
+        raise ZeroDivisionError(
+            "Tried to pivot about zero-valued entry.")
+    A = M - Mj * (Mi / Mij)
+    A[i, :] = Mi / Mij
+    A[:, j] = -Mj / Mij
+    A[i, j] = 1 / Mij
+    return A
+
+
+def _choose_pivot_row(A, B, candidate_rows, pivot_col, Y):
+    # Choose row with smallest ratio
+    # If there are ties, pick using Bland's rule
+    return min(candidate_rows, key=lambda i: (B[i] / A[i, pivot_col], Y[i]))
+
+
+def _simplex(A, B, C, D=None, dual=False):
+    """Return ``(o, x, y)`` obtained from the two-phase simplex method
+    using Bland's rule: ``o`` is the minimum value of primal,
+    ``Cx - D``, under constraints ``Ax <= B`` (with ``x >= 0``) and
+    the maximum of the dual, ``y^{T}B - D``, under constraints
+    ``A^{T}*y >= C^{T}`` (with ``y >= 0``). To compute the dual of
+    the system, pass `dual=True` and ``(o, y, x)`` will be returned.
+
+    Note: the nonnegative constraints for ``x`` and ``y`` supercede
+    any values of ``A`` and ``B`` that are inconsistent with that
+    assumption, so if a constraint of ``x >= -1`` is represented
+    in ``A`` and ``B``, no value will be obtained that is negative; if
+    a constraint of ``x <= -1`` is represented, an error will be
+    raised since no solution is possible.
+
+    This routine relies on the ability of determining whether an
+    expression is 0 or not. This is guaranteed if the input contains
+    only Float or Rational entries. It will raise a TypeError if
+    a relationship does not evaluate to True or False.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import _simplex
+    >>> from sympy import Matrix
+
+    Consider the simple minimization of ``f = x + y + 1`` under the
+    constraint that ``y + 2*x >= 4``. This is the "standard form" of
+    a minimization.
+
+    In the nonnegative quadrant, this inequality describes a area above
+    a triangle with vertices at (0, 4), (0, 0) and (2, 0). The minimum
+    of ``f`` occurs at (2, 0). Define A, B, C, D for the standard
+    minimization:
+
+    >>> A = Matrix([[2, 1]])
+    >>> B = Matrix([4])
+    >>> C = Matrix([[1, 1]])
+    >>> D = Matrix([-1])
+
+    Confirm that this is the system of interest:
+
+    >>> from sympy.abc import x, y
+    >>> X = Matrix([x, y])
+    >>> (C*X - D)[0]
+    x + y + 1
+    >>> [i >= j for i, j in zip(A*X, B)]
+    [2*x + y >= 4]
+
+    Since `_simplex` will do a minimization for constraints given as
+    ``A*x <= B``, the signs of ``A`` and ``B`` must be negated since
+    the currently correspond to a greater-than inequality:
+
+    >>> _simplex(-A, -B, C, D)
+    (3, [2, 0], [1/2])
+
+    The dual of minimizing ``f`` is maximizing ``F = c*y - d`` for
+    ``a*y <= b`` where ``a``, ``b``, ``c``, ``d`` are derived from the
+    transpose of the matrix representation of the standard minimization:
+
+    >>> tr = lambda a, b, c, d: [i.T for i in (a, c, b, d)]
+    >>> a, b, c, d = tr(A, B, C, D)
+
+    This time ``a*x <= b`` is the expected inequality for the `_simplex`
+    method, but to maximize ``F``, the sign of ``c`` and ``d`` must be
+    changed (so that minimizing the negative will give the negative of
+    the maximum of ``F``):
+
+    >>> _simplex(a, b, -c, -d)
+    (-3, [1/2], [2, 0])
+
+    The negative of ``F`` and the min of ``f`` are the same. The dual
+    point `[1/2]` is the value of ``y`` that minimized ``F = c*y - d``
+    under constraints a*x <= b``:
+
+    >>> y = Matrix(['y'])
+    >>> (c*y - d)[0]
+    4*y + 1
+    >>> [i <= j for i, j in zip(a*y,b)]
+    [2*y <= 1, y <= 1]
+
+    In this 1-dimensional dual system, the more restrictive contraint is
+    the first which limits ``y`` between 0 and 1/2 and the maximum of
+    ``F`` is attained at the nonzero value, hence is ``4*(1/2) + 1 = 3``.
+
+    In this case the values for ``x`` and ``y`` were the same when the
+    dual representation was solved. This is not always the case (though
+    the value of the function will be the same).
+
+    >>> l = [[1, 1], [-1, 1], [0, 1], [-1, 0]], [5, 1, 2, -1], [[1, 1]], [-1]
+    >>> A, B, C, D = [Matrix(i) for i in l]
+    >>> _simplex(A, B, -C, -D)
+    (-6, [3, 2], [1, 0, 0, 0])
+    >>> _simplex(A, B, -C, -D, dual=True)  # [5, 0] != [3, 2]
+    (-6, [1, 0, 0, 0], [5, 0])
+
+    In both cases the function has the same value:
+
+    >>> Matrix(C)*Matrix([3, 2]) == Matrix(C)*Matrix([5, 0])
+    True
+
+    See Also
+    ========
+    _lp - poses min/max problem in form compatible with _simplex
+    lpmin - minimization which calls _lp
+    lpmax - maximimzation which calls _lp
+
+    References
+    ==========
+
+    .. [1] Thomas S. Ferguson, LINEAR PROGRAMMING: A Concise Introduction
+           web.tecnico.ulisboa.pt/mcasquilho/acad/or/ftp/FergusonUCLA_lp.pdf
+
+    """
+    A, B, C, D = [Matrix(i) for i in (A, B, C, D or [0])]
+    if dual:
+        _o, d, p = _simplex(-A.T, C.T, B.T, -D)
+        return -_o, d, p
+
+    if A and B:
+        M = Matrix([[A, B], [C, D]])
+    else:
+        if A or B:
+            raise ValueError("must give A and B")
+        # no constraints given
+        M = Matrix([[C, D]])
+    n = M.cols - 1
+    m = M.rows - 1
+
+    if not all(i.is_Float or i.is_Rational for i in M):
+        # with literal Float and Rational we are guaranteed the
+        # ability of determining whether an expression is 0 or not
+        raise TypeError(filldedent("""
+            Only rationals and floats are allowed.
+            """
+            )
+        )
+
+    # x variables have priority over y variables during Bland's rule
+    # since False < True
+    X = [(False, j) for j in range(n)]
+    Y = [(True, i) for i in range(m)]
+
+    # Phase 1: find a feasible solution or determine none exist
+
+    ## keep track of last pivot row and column
+    last = None
+
+    while True:
+        B = M[:-1, -1]
+        A = M[:-1, :-1]
+        if all(B[i] >= 0 for i in range(B.rows)):
+            # We have found a feasible solution
+            break
+
+        # Find k: first row with a negative rightmost entry
+        for k in range(B.rows):
+            if B[k] < 0:
+                break  # use current value of k below
+        else:
+            pass  # error will raise below
+
+        # Choose pivot column, c
+        piv_cols = [_ for _ in range(A.cols) if A[k, _] < 0]
+        if not piv_cols:
+            raise InfeasibleLPError(filldedent("""
+                The constraint set is empty!"""))
+        _, c = min((X[i], i) for i in piv_cols) # Bland's rule
+
+        # Choose pivot row, r
+        piv_rows = [_ for _ in range(A.rows) if A[_, c] > 0 and B[_] > 0]
+        piv_rows.append(k)
+        r = _choose_pivot_row(A, B, piv_rows, c, Y)
+
+        # check for oscillation
+        if (r, c) == last:
+            # Not sure what to do here; it looks like there will be
+            # oscillations; see o1 test added at this commit to
+            # see a system with no solution and the o2 for one
+            # with a solution. In the case of o2, the solution
+            # from linprog is the same as the one from lpmin, but
+            # the matrices created in the lpmin case are different
+            # than those created without replacements in linprog and
+            # the matrices in the linprog case lead to oscillations.
+            # If the matrices could be re-written in linprog like
+            # lpmin does, this behavior could be avoided and then
+            # perhaps the oscillating case would only occur when
+            # there is no solution. For now, the output is checked
+            # before exit if oscillations were detected and an
+            # error is raised there if the solution was invalid.
+            #
+            # cf section 6 of Ferguson for a non-cycling modification
+            last = True
+            break
+        last = r, c
+
+        M = _pivot(M, r, c)
+        X[c], Y[r] = Y[r], X[c]
+
+    # Phase 2: from a feasible solution, pivot to optimal
+    while True:
+        B = M[:-1, -1]
+        A = M[:-1, :-1]
+        C = M[-1, :-1]
+
+        # Choose a pivot column, c
+        piv_cols = []
+        piv_cols = [_ for _ in range(n) if C[_] < 0]
+        if not piv_cols:
+            break
+        _, c = min((X[i], i) for i in piv_cols)  # Bland's rule
+
+        # Choose a pivot row, r
+        piv_rows = [_ for _ in range(m) if A[_, c] > 0]
+        if not piv_rows:
+            raise UnboundedLPError(filldedent("""
+                Objective function can assume
+                arbitrarily large values!"""))
+        r = _choose_pivot_row(A, B, piv_rows, c, Y)
+
+        M = _pivot(M, r, c)
+        X[c], Y[r] = Y[r], X[c]
+
+    argmax = [None] * n
+    argmin_dual = [None] * m
+
+    for i, (v, n) in enumerate(X):
+        if v == False:
+            argmax[n] = 0
+        else:
+            argmin_dual[n] = M[-1, i]
+
+    for i, (v, n) in enumerate(Y):
+        if v == True:
+            argmin_dual[n] = 0
+        else:
+            argmax[n] = M[i, -1]
+
+    if last and not all(i >= 0 for i in argmax + argmin_dual):
+        raise InfeasibleLPError(filldedent("""
+            Oscillating system led to invalid solution.
+            If you believe there was a valid solution, please
+            report this as a bug."""))
+    return -M[-1, -1], argmax, argmin_dual
+
+
+## routines that use _simplex or support those that do
+
+
+def _abcd(M, list=False):
+    """return parts of M as matrices or lists
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.solvers.simplex import _abcd
+
+    >>> m = Matrix(3, 3, range(9)); m
+    Matrix([
+    [0, 1, 2],
+    [3, 4, 5],
+    [6, 7, 8]])
+    >>> a, b, c, d = _abcd(m)
+    >>> a
+    Matrix([
+    [0, 1],
+    [3, 4]])
+    >>> b
+    Matrix([
+    [2],
+    [5]])
+    >>> c
+    Matrix([[6, 7]])
+    >>> d
+    Matrix([[8]])
+
+    The matrices can be returned as compact lists, too:
+
+    >>> L = a, b, c, d = _abcd(m, list=True); L
+    ([[0, 1], [3, 4]], [2, 5], [[6, 7]], [8])
+    """
+
+    def aslist(i):
+        l = i.tolist()
+        if len(l[0]) == 1:  # col vector
+            return [i[0] for i in l]
+        return l
+
+    m = M[:-1, :-1], M[:-1, -1], M[-1, :-1], M[-1:, -1:]
+    if not list:
+        return m
+    return tuple([aslist(i) for i in m])
+
+
+def _m(a, b, c, d=None):
+    """return Matrix([[a, b], [c, d]]) from matrices
+    in Matrix or list form.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.solvers.simplex import _abcd, _m
+    >>> m = Matrix(3, 3, range(9))
+    >>> L = _abcd(m, list=True); L
+    ([[0, 1], [3, 4]], [2, 5], [[6, 7]], [8])
+    >>> _abcd(m)
+    (Matrix([
+    [0, 1],
+    [3, 4]]), Matrix([
+    [2],
+    [5]]), Matrix([[6, 7]]), Matrix([[8]]))
+    >>> assert m == _m(*L) == _m(*_)
+    """
+    a, b, c, d = [Matrix(i) for i in (a, b, c, d or [0])]
+    return Matrix([[a, b], [c, d]])
+
+
+def _primal_dual(M, factor=True):
+    """return primal and dual function and constraints
+    assuming that ``M = Matrix([[A, b], [c, d]])`` and the
+    function ``c*x - d`` is being minimized with ``Ax >= b``
+    for nonnegative values of ``x``. The dual and its
+    constraints will be for maximizing `b.T*y - d` subject
+    to ``A.T*y <= c.T``.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import _primal_dual, lpmin, lpmax
+    >>> from sympy import Matrix
+
+    The following matrix represents the primal task of
+    minimizing x + y + 7 for y >= x + 1 and y >= -2*x + 3.
+    The dual task seeks to maximize x + 3*y + 7 with
+    2*y - x <= 1 and and x + y <= 1:
+
+    >>> M = Matrix([
+    ...     [-1, 1,  1],
+    ...     [ 2, 1,  3],
+    ...     [ 1, 1, -7]])
+    >>> p, d = _primal_dual(M)
+
+    The minimum of the primal and maximum of the dual are the same
+    (though they occur at different points):
+
+    >>> lpmin(*p)
+    (28/3, {x1: 2/3, x2: 5/3})
+    >>> lpmax(*d)
+    (28/3, {y1: 1/3, y2: 2/3})
+
+    If the equivalent (but canonical) inequalities are
+    desired, leave `factor=True`, otherwise the unmodified
+    inequalities for M will be returned.
+
+    >>> m = Matrix([
+    ... [-3, -2,  4, -2],
+    ... [ 2,  0,  0, -2],
+    ... [ 0,  1, -3,  0]])
+
+    >>> _primal_dual(m, False)  # last condition is 2*x1 >= -2
+    ((x2 - 3*x3,
+        [-3*x1 - 2*x2 + 4*x3 >= -2, 2*x1 >= -2]),
+    (-2*y1 - 2*y2,
+        [-3*y1 + 2*y2 <= 0, -2*y1 <= 1, 4*y1 <= -3]))
+
+    >>> _primal_dual(m)  # condition now x1 >= -1
+    ((x2 - 3*x3,
+        [-3*x1 - 2*x2 + 4*x3 >= -2, x1 >= -1]),
+    (-2*y1 - 2*y2,
+        [-3*y1 + 2*y2 <= 0, -2*y1 <= 1, 4*y1 <= -3]))
+
+    If you pass the transpose of the matrix, the primal will be
+    identified as the standard minimization problem and the
+    dual as the standard maximization:
+
+    >>> _primal_dual(m.T)
+    ((-2*x1 - 2*x2,
+        [-3*x1 + 2*x2 >= 0, -2*x1 >= 1, 4*x1 >= -3]),
+    (y2 - 3*y3,
+        [-3*y1 - 2*y2 + 4*y3 <= -2, y1 <= -1]))
+
+    A matrix must have some size or else None will be returned for
+    the functions:
+
+    >>> _primal_dual(Matrix([[1, 2]]))
+    ((x1 - 2, []), (-2, []))
+
+    >>> _primal_dual(Matrix([]))
+    ((None, []), (None, []))
+
+    References
+    ==========
+
+    .. [1] David Galvin, Relations between Primal and Dual
+           www3.nd.edu/~dgalvin1/30210/30210_F07/presentations/dual_opt.pdf
+    """
+    if not M:
+        return (None, []), (None, [])
+    if not hasattr(M, "shape"):
+        if len(M) not in (3, 4):
+            raise ValueError("expecting Matrix or 3 or 4 lists")
+        M = _m(*M)
+    m, n = [i - 1 for i in M.shape]
+    A, b, c, d = _abcd(M)
+    d = d[0]
+    _ = lambda x: numbered_symbols(x, start=1)
+    x = Matrix([i for i, j in zip(_("x"), range(n))])
+    yT = Matrix([i for i, j in zip(_("y"), range(m))]).T
+
+    def ineq(L, r, op):
+        rv = []
+        for r in (op(i, j) for i, j in zip(L, r)):
+            if r == True:
+                continue
+            elif r == False:
+                return [False]
+            if factor:
+                f = factor_terms(r)
+                if f.lhs.is_Mul and f.rhs % f.lhs.args[0] == 0:
+                    assert len(f.lhs.args) == 2, f.lhs
+                    k = f.lhs.args[0]
+                    r = r.func(sign(k) * f.lhs.args[1], f.rhs // abs(k))
+            rv.append(r)
+        return rv
+
+    eq = lambda x, d: x[0] - d if x else -d
+    F = eq(c * x, d)
+    f = eq(yT * b, d)
+    return (F, ineq(A * x, b, Ge)), (f, ineq(yT * A, c, Le))
+
+
+def _rel_as_nonpos(constr, syms):
+    """return `(np, d, aux)` where `np` is a list of nonpositive
+    expressions that represent the given constraints (possibly
+    rewritten in terms of auxilliary variables) expressible with
+    nonnegative symbols, and `d` is a dictionary mapping a given
+    symbols to an expression with an auxilliary variable. In some
+    cases a symbol will be used as part of the change of variables,
+    e.g. x: x - z1 instead of x: z1 - z2.
+
+    If any constraint is False/empty, return None. All variables in
+    ``constr`` are assumed to be unbounded unless explicitly indicated
+    otherwise with a univariate constraint, e.g. ``x >= 0`` will
+    restrict ``x`` to nonnegative values.
+
+    The ``syms`` must be included so all symbols can be given an
+    unbounded assumption if they are not otherwise bound with
+    univariate conditions like ``x <= 3``.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import _rel_as_nonpos
+    >>> from sympy.abc import x, y
+    >>> _rel_as_nonpos([x >= y, x >= 0, y >= 0], (x, y))
+    ([-x + y], {}, [])
+    >>> _rel_as_nonpos([x >= 3, x <= 5], [x])
+    ([_z1 - 2], {x: _z1 + 3}, [_z1])
+    >>> _rel_as_nonpos([x <= 5], [x])
+    ([], {x: 5 - _z1}, [_z1])
+    >>> _rel_as_nonpos([x >= 1], [x])
+    ([], {x: _z1 + 1}, [_z1])
+    """
+    r = {}  # replacements to handle change of variables
+    np = []  # nonpositive expressions
+    aux = []  # auxilliary symbols added
+    ui = numbered_symbols("z", start=1, cls=Dummy)  # auxilliary symbols
+    univariate = {}  # {x: interval} for univariate constraints
+    unbound = []  # symbols designated as unbound
+    syms = set(syms)  # the expected syms of the system
+
+    # separate out univariates
+    for i in constr:
+        if i == True:
+            continue  # ignore
+        if i == False:
+            return  # no solution
+        if i.has(S.Infinity, S.NegativeInfinity):
+            raise ValueError("only finite bounds are permitted")
+        if isinstance(i, (Le, Ge)):
+            i = i.lts - i.gts
+            freei = i.free_symbols
+            if freei - syms:
+                raise ValueError(
+                    "unexpected symbol(s) in constraint: %s" % (freei - syms)
+                )
+            if len(freei) > 1:
+                np.append(i)
+            elif freei:
+                x = freei.pop()
+                if x in unbound:
+                    continue  # will handle later
+                ivl = Le(i, 0, evaluate=False).as_set()
+                if x not in univariate:
+                    univariate[x] = ivl
+                else:
+                    univariate[x] &= ivl
+            elif i:
+                return False
+        else:
+            raise TypeError(filldedent("""
+                only equalities like Eq(x, y) or non-strict
+                inequalities like x >= y are allowed in lp, not %s""" % i))
+
+    # introduce auxilliary variables as needed for univariate
+    # inequalities
+    for x in syms:
+        i = univariate.get(x, True)
+        if not i:
+            return None  # no solution possible
+        if i == True:
+            unbound.append(x)
+            continue
+        a, b = i.inf, i.sup
+        if a.is_infinite:
+            u = next(ui)
+            r[x] = b - u
+            aux.append(u)
+        elif b.is_infinite:
+            if a:
+                u = next(ui)
+                r[x] = a + u
+                aux.append(u)
+            else:
+                # standard nonnegative relationship
+                pass
+        else:
+            u = next(ui)
+            aux.append(u)
+            # shift so u = x - a => x = u + a
+            r[x] = u + a
+            # add constraint for u <= b - a
+            # since when u = b-a then x = u + a = b - a + a = b:
+            # the upper limit for x
+            np.append(u - (b - a))
+
+    # make change of variables for unbound variables
+    for x in unbound:
+        u = next(ui)
+        r[x] = u - x  # reusing x
+        aux.append(u)
+
+    return np, r, aux
+
+
+def _lp_matrices(objective, constraints):
+    """return A, B, C, D, r, x+X, X for maximizing
+    objective = Cx - D with constraints Ax <= B, introducing
+    introducing auxilliary variables, X, as necessary to make
+    replacements of symbols as given in r, {xi: expression with Xj},
+    so all variables in x+X will take on nonnegative values.
+
+    Every univariate condition creates a semi-infinite
+    condition, e.g. a single ``x <= 3`` creates the
+    interval ``[-oo, 3]`` while ``x <= 3`` and ``x >= 2``
+    create an interval ``[2, 3]``. Variables not in a univariate
+    expression will take on nonnegative values.
+    """
+
+    # sympify input and collect free symbols
+    F = sympify(objective)
+    np = [sympify(i) for i in constraints]
+    syms = set.union(*[i.free_symbols for i in [F] + np], set())
+
+    # change Eq(x, y) to x - y <= 0 and y - x <= 0
+    for i in range(len(np)):
+        if isinstance(np[i], Eq):
+            np[i] = np[i].lhs - np[i].rhs <= 0
+            np.append(-np[i].lhs <= 0)
+
+    # convert constraints to nonpositive expressions
+    _ = _rel_as_nonpos(np, syms)
+    if _ is None:
+        raise InfeasibleLPError(filldedent("""
+            Inconsistent/False constraint"""))
+    np, r, aux = _
+
+    # do change of variables
+    F = F.xreplace(r)
+    np = [i.xreplace(r) for i in np]
+
+    # convert to matrices
+    xx = list(ordered(syms)) + aux
+    A, B = linear_eq_to_matrix(np, xx)
+    C, D = linear_eq_to_matrix([F], xx)
+    return A, B, C, D, r, xx, aux
+
+
+def _lp(min_max, f, constr):
+    """Return the optimization (min or max) of ``f`` with the given
+    constraints. All variables are unbounded unless constrained.
+
+    If `min_max` is 'max' then the results corresponding to the
+    maximization of ``f`` will be returned, else the minimization.
+    The constraints can be given as Le, Ge or Eq expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import _lp as lp
+    >>> from sympy import Eq
+    >>> from sympy.abc import x, y, z
+    >>> f = x + y - 2*z
+    >>> c = [7*x + 4*y - 7*z <= 3, 3*x - y + 10*z <= 6]
+    >>> c += [i >= 0 for i in (x, y, z)]
+    >>> lp(min, f, c)
+    (-6/5, {x: 0, y: 0, z: 3/5})
+
+    By passing max, the maximum value for f under the constraints
+    is returned (if possible):
+
+    >>> lp(max, f, c)
+    (3/4, {x: 0, y: 3/4, z: 0})
+
+    Constraints that are equalities will require that the solution
+    also satisfy them:
+
+    >>> lp(max, f, c + [Eq(y - 9*x, 1)])
+    (5/7, {x: 0, y: 1, z: 1/7})
+
+    All symbols are reported, even if they are not in the objective
+    function:
+
+    >>> lp(min, x, [y + x >= 3, x >= 0])
+    (0, {x: 0, y: 3})
+    """
+    # get the matrix components for the system expressed
+    # in terms of only nonnegative variables
+    A, B, C, D, r, xx, aux = _lp_matrices(f, constr)
+
+    how = str(min_max).lower()
+    if "max" in how:
+        # _simplex minimizes for Ax <= B so we
+        # have to change the sign of the function
+        # and negate the optimal value returned
+        _o, p, d = _simplex(A, B, -C, -D)
+        o = -_o
+    elif "min" in how:
+        o, p, d = _simplex(A, B, C, D)
+    else:
+        raise ValueError("expecting min or max")
+
+    # restore original variables and remove aux from p
+    p = dict(zip(xx, p))
+    if r:  # p has original symbols and auxilliary symbols
+        # if r has x: x - z1 use values from p to update
+        r = {k: v.xreplace(p) for k, v in r.items()}
+        # then use the actual value of x (= x - z1) in p
+        p.update(r)
+        # don't show aux
+        p = {k: p[k] for k in ordered(p) if k not in aux}
+
+    # not returning dual since there may be extra constraints
+    # when a variable has finite bounds
+    return o, p
+
+
+def lpmin(f, constr):
+    """return minimum of linear equation ``f`` under
+    linear constraints expressed using Ge, Le or Eq.
+
+    All variables are unbounded unless constrained.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import lpmin
+    >>> from sympy import Eq
+    >>> from sympy.abc import x, y
+    >>> lpmin(x, [2*x - 3*y >= -1, Eq(x + 3*y, 2), x <= 2*y])
+    (1/3, {x: 1/3, y: 5/9})
+
+    Negative values for variables are permitted unless explicitly
+    exluding, so minimizing ``x`` for ``x <= 3`` is an
+    unbounded problem while the following has a bounded solution:
+
+    >>> lpmin(x, [x >= 0, x <= 3])
+    (0, {x: 0})
+
+    Without indicating that ``x`` is nonnegative, there
+    is no minimum for this objective:
+
+    >>> lpmin(x, [x <= 3])
+    Traceback (most recent call last):
+    ...
+    sympy.solvers.simplex.UnboundedLPError:
+    Objective function can assume arbitrarily large values!
+
+    See Also
+    ========
+    linprog, lpmax
+    """
+    return _lp(min, f, constr)
+
+
+def lpmax(f, constr):
+    """return maximum of linear equation ``f`` under
+    linear constraints expressed using Ge, Le or Eq.
+
+    All variables are unbounded unless constrained.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import lpmax
+    >>> from sympy import Eq
+    >>> from sympy.abc import x, y
+    >>> lpmax(x, [2*x - 3*y >= -1, Eq(x+ 3*y,2), x <= 2*y])
+    (4/5, {x: 4/5, y: 2/5})
+
+    Negative values for variables are permitted unless explicitly
+    exluding:
+
+    >>> lpmax(x, [x <= -1])
+    (-1, {x: -1})
+
+    If a non-negative constraint is added for x, there is no
+    possible solution:
+
+    >>> lpmax(x, [x <= -1, x >= 0])
+    Traceback (most recent call last):
+    ...
+    sympy.solvers.simplex.InfeasibleLPError: inconsistent/False constraint
+
+    See Also
+    ========
+    linprog, lpmin
+    """
+    return _lp(max, f, constr)
+
+
+def _handle_bounds(bounds):
+    # introduce auxilliary variables as needed for univariate
+    # inequalities
+
+    unbound = []
+    R = [0] * len(bounds)  # a (growing) row of zeros
+
+    def n():
+        return len(R) - 1
+
+    def Arow(inc=1):
+        R.extend([0] * inc)
+        return R[:]
+
+    row = []
+    for x, (a, b) in enumerate(bounds):
+        if a is None and b is None:
+            unbound.append(x)
+        elif a is None:
+            # r[x] = b - u
+            A = Arow()
+            A[x] = 1
+            A[n()] = 1
+            B = [b]
+            row.append((A, B))
+            A = [0] * len(A)
+            A[x] = -1
+            A[n()] = -1
+            B = [-b]
+            row.append((A, B))
+        elif b is None:
+            if a:
+                # r[x] = a + u
+                A = Arow()
+                A[x] = 1
+                A[n()] = -1
+                B = [a]
+                row.append((A, B))
+                A = [0] * len(A)
+                A[x] = -1
+                A[n()] = 1
+                B = [-a]
+                row.append((A, B))
+            else:
+                # standard nonnegative relationship
+                pass
+        else:
+            # r[x] = u + a
+            A = Arow()
+            A[x] = 1
+            A[n()] = -1
+            B = [a]
+            row.append((A, B))
+            A = [0] * len(A)
+            A[x] = -1
+            A[n()] = 1
+            B = [-a]
+            row.append((A, B))
+            # u <= b - a
+            A = [0] * len(A)
+            A[x] = 0
+            A[n()] = 1
+            B = [b - a]
+            row.append((A, B))
+
+    # make change of variables for unbound variables
+    for x in unbound:
+        # r[x] = u - v
+        A = Arow(2)
+        B = [0]
+        A[x] = 1
+        A[n()] = 1
+        A[n() - 1] = -1
+        row.append((A, B))
+        A = [0] * len(A)
+        A[x] = -1
+        A[n()] = -1
+        A[n() - 1] = 1
+        row.append((A, B))
+
+    return Matrix([r+[0]*(len(R) - len(r)) for r,_ in row]
+        ), Matrix([i[1] for i in row])
+
+
+def linprog(c, A=None, b=None, A_eq=None, b_eq=None, bounds=None):
+    """Return the minimization of ``c*x`` with the given
+    constraints ``A*x <= b`` and ``A_eq*x = b_eq``. Unless bounds
+    are given, variables will have nonnegative values in the solution.
+
+    If ``A`` is not given, then the dimension of the system will
+    be determined by the length of ``C``.
+
+    By default, all variables will be nonnegative. If ``bounds``
+    is given as a single tuple, ``(lo, hi)``, then all variables
+    will be constrained to be between ``lo`` and ``hi``. Use
+    None for a ``lo`` or ``hi`` if it is unconstrained in the
+    negative or positive direction, respectively, e.g.
+    ``(None, 0)`` indicates nonpositive values. To set
+    individual ranges, pass a list with length equal to the
+    number of columns in ``A``, each element being a tuple; if
+    only a few variables take on non-default values they can be
+    passed as a dictionary with keys giving the corresponding
+    column to which the variable is assigned, e.g. ``bounds={2:
+    (1, 4)}`` would limit the 3rd variable to have a value in
+    range ``[1, 4]``.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.simplex import linprog
+    >>> from sympy import symbols, Eq, linear_eq_to_matrix as M, Matrix
+    >>> x = x1, x2, x3, x4 = symbols('x1:5')
+    >>> X = Matrix(x)
+    >>> c, d = M(5*x2 + x3 + 4*x4 - x1, x)
+    >>> a, b = M([5*x2 + 2*x3 + 5*x4 - (x1 + 5)], x)
+    >>> aeq, beq = M([Eq(3*x2 + x4, 2), Eq(-x1 + x3 + 2*x4, 1)], x)
+    >>> constr = [i <= j for i,j in zip(a*X, b)]
+    >>> constr += [Eq(i, j) for i,j in zip(aeq*X, beq)]
+    >>> linprog(c, a, b, aeq, beq)
+    (9/2, [0, 1/2, 0, 1/2])
+    >>> assert all(i.subs(dict(zip(x, _[1]))) for i in constr)
+
+    See Also
+    ========
+    lpmin, lpmax
+    """
+
+    ## the objective
+    C = Matrix(c)
+    if C.rows != 1 and C.cols == 1:
+        C = C.T
+    if C.rows != 1:
+        raise ValueError("C must be a single row.")
+
+    ## the inequalities
+    if not A:
+        if b:
+            raise ValueError("A and b must both be given")
+        # the governing equations will be simple constraints
+        # on variables
+        A, b = zeros(0, C.cols), zeros(C.cols, 1)
+    else:
+        A, b = [Matrix(i) for i in (A, b)]
+
+    if A.cols != C.cols:
+        raise ValueError("number of columns in A and C must match")
+
+    ## the equalities
+    if A_eq is None:
+        if not b_eq is None:
+            raise ValueError("A_eq and b_eq must both be given")
+    else:
+        A_eq, b_eq = [Matrix(i) for i in (A_eq, b_eq)]
+        # if x == y then x <= y and x >= y (-x <= -y)
+        A = A.col_join(A_eq)
+        A = A.col_join(-A_eq)
+        b = b.col_join(b_eq)
+        b = b.col_join(-b_eq)
+
+    if not (bounds is None or bounds == {} or bounds == (0, None)):
+        ## the bounds are interpreted
+        if type(bounds) is tuple and len(bounds) == 2:
+            bounds = [bounds] * A.cols
+        elif len(bounds) == A.cols and all(
+                type(i) is tuple and len(i) == 2 for i in bounds):
+            pass # individual bounds
+        elif type(bounds) is dict and all(
+                type(i) is tuple and len(i) == 2
+                for i in bounds.values()):
+            # sparse bounds
+            db = bounds
+            bounds = [(0, None)] * A.cols
+            while db:
+                i, j = db.popitem()
+                bounds[i] = j  # IndexError if out-of-bounds indices
+        else:
+            raise ValueError("unexpected bounds %s" % bounds)
+        A_, b_ = _handle_bounds(bounds)
+        aux = A_.cols - A.cols
+        if A:
+            A = Matrix([[A, zeros(A.rows, aux)], [A_]])
+            b = b.col_join(b_)
+        else:
+            A = A_
+            b = b_
+        C = C.row_join(zeros(1, aux))
+    else:
+        aux = -A.cols  # set so -aux will give all cols below
+
+    o, p, d = _simplex(A, b, C)
+    return o, p[:-aux]  # don't include aux values
+
+def show_linprog(c, A=None, b=None, A_eq=None, b_eq=None, bounds=None):
+    from sympy import symbols
+    ## the objective
+    C = Matrix(c)
+    if C.rows != 1 and C.cols == 1:
+        C = C.T
+    if C.rows != 1:
+        raise ValueError("C must be a single row.")
+
+    ## the inequalities
+    if not A:
+        if b:
+            raise ValueError("A and b must both be given")
+        # the governing equations will be simple constraints
+        # on variables
+        A, b = zeros(0, C.cols), zeros(C.cols, 1)
+    else:
+        A, b = [Matrix(i) for i in (A, b)]
+
+    if A.cols != C.cols:
+        raise ValueError("number of columns in A and C must match")
+
+    ## the equalities
+    if A_eq is None:
+        if not b_eq is None:
+            raise ValueError("A_eq and b_eq must both be given")
+    else:
+        A_eq, b_eq = [Matrix(i) for i in (A_eq, b_eq)]
+
+    if not (bounds is None or bounds == {} or bounds == (0, None)):
+        ## the bounds are interpreted
+        if type(bounds) is tuple and len(bounds) == 2:
+            bounds = [bounds] * A.cols
+        elif len(bounds) == A.cols and all(
+                type(i) is tuple and len(i) == 2 for i in bounds):
+            pass # individual bounds
+        elif type(bounds) is dict and all(
+                type(i) is tuple and len(i) == 2
+                for i in bounds.values()):
+            # sparse bounds
+            db = bounds
+            bounds = [(0, None)] * A.cols
+            while db:
+                i, j = db.popitem()
+                bounds[i] = j  # IndexError if out-of-bounds indices
+        else:
+            raise ValueError("unexpected bounds %s" % bounds)
+
+    x = Matrix(symbols('x1:%s' % (A.cols+1)))
+    f,c = (C*x)[0], [i<=j for i,j in zip(A*x, b)] + [Eq(i,j) for i,j in zip(A_eq*x,b_eq)]
+    for i, (lo, hi) in enumerate(bounds):
+        if lo is None and hi is None:
+            continue
+        if lo is None:
+            c.append(x[i]<=hi)
+        elif hi is None:
+            c.append(x[i]>=lo)
+        else:
+            c.append(x[i]>=lo)
+            c.append(x[i]<=hi)
+    return f,c

pllava/lib/python3.10/site-packages/sympy/solvers/tests/test_constantsimp.py

@@ -0,0 +1,179 @@
+"""
+If the arbitrary constant class from issue 4435 is ever implemented, this
+should serve as a set of test cases.
+"""
+
+from sympy.core.function import Function
+from sympy.core.numbers import I
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.solvers.ode.ode import constantsimp, constant_renumber
+from sympy.testing.pytest import XFAIL
+
+
+x = Symbol('x')
+y = Symbol('y')
+z = Symbol('z')
+u2 = Symbol('u2')
+_a = Symbol('_a')
+C1 = Symbol('C1')
+C2 = Symbol('C2')
+C3 = Symbol('C3')
+f = Function('f')
+
+
+def test_constant_mul():
+    # We want C1 (Constant) below to absorb the y's, but not the x's
+    assert constant_renumber(constantsimp(y*C1, [C1])) == C1*y
+    assert constant_renumber(constantsimp(C1*y, [C1])) == C1*y
+    assert constant_renumber(constantsimp(x*C1, [C1])) == x*C1
+    assert constant_renumber(constantsimp(C1*x, [C1])) == x*C1
+    assert constant_renumber(constantsimp(2*C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1*2, [C1])) == C1
+    assert constant_renumber(constantsimp(y*C1*x, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(x*y*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(y*x*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*x*y, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(x*C1*y, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*y*(y + 1), [C1])) == C1*y*(y+1)
+    assert constant_renumber(constantsimp(y*C1*(y + 1), [C1])) == C1*y*(y+1)
+    assert constant_renumber(constantsimp(x*(y*C1), [C1])) == x*y*C1
+    assert constant_renumber(constantsimp(x*(C1*y), [C1])) == x*y*C1
+    assert constant_renumber(constantsimp(C1*(x*y), [C1, y])) == C1*x
+    assert constant_renumber(constantsimp((x*y)*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp((y*x)*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(y*(y + 1)*C1, [C1, y])) == C1
+    assert constant_renumber(constantsimp((C1*x)*y, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(y*(x*C1), [C1, y])) == x*C1
+    assert constant_renumber(constantsimp((x*C1)*y, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*x*y*x*y*2, [C1, y])) == C1*x**2
+    assert constant_renumber(constantsimp(C1*x*y*z, [C1, y, z])) == C1*x
+    assert constant_renumber(constantsimp(C1*x*y**2*sin(z), [C1, y, z])) == C1*x
+    assert constant_renumber(constantsimp(C1*C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1*C1*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1*x*2**x, [C1])) == C1*x*2**x
+
+def test_constant_add():
+    assert constant_renumber(constantsimp(C1 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + 2, [C1])) == C1
+    assert constant_renumber(constantsimp(2 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + y, [C1, y])) == C1
+    assert constant_renumber(constantsimp(C1 + x, [C1])) == C1 + x
+    assert constant_renumber(constantsimp(C1 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2 + C1, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1 + C2 + C1, [C1, C2])) == C1
+
+
+def test_constant_power_as_base():
+    assert constant_renumber(constantsimp(C1**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(Pow(C1, C1), [C1])) == C1
+    assert constant_renumber(constantsimp(C1**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1**C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2**C1, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2**C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1**y, [C1, y])) == C1
+    assert constant_renumber(constantsimp(C1**x, [C1])) == C1**x
+    assert constant_renumber(constantsimp(C1**2, [C1])) == C1
+    assert constant_renumber(
+        constantsimp(C1**(x*y), [C1])) == C1**(x*y)
+
+
+def test_constant_power_as_exp():
+    assert constant_renumber(constantsimp(x**C1, [C1])) == x**C1
+    assert constant_renumber(constantsimp(y**C1, [C1, y])) == C1
+    assert constant_renumber(constantsimp(x**y**C1, [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp((x**y)**C1, [C1])) == (x**y)**C1
+    assert constant_renumber(
+        constantsimp(x**(y**C1), [C1, y])) == x**C1
+    assert constant_renumber(constantsimp(x**C1**y, [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp(x**(C1**y), [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp((x**C1)**y, [C1])) == (x**C1)**y
+    assert constant_renumber(constantsimp(2**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(S(2)**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(exp(C1), [C1])) == C1
+    assert constant_renumber(
+        constantsimp(exp(C1 + x), [C1])) == C1*exp(x)
+    assert constant_renumber(constantsimp(Pow(2, C1), [C1])) == C1
+
+
+def test_constant_function():
+    assert constant_renumber(constantsimp(sin(C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1, C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1, C2), [C1, C2])) == C1
+    assert constant_renumber(constantsimp(f(C2, C1), [C1, C2])) == C1
+    assert constant_renumber(constantsimp(f(C2, C2), [C1, C2])) == C1
+    assert constant_renumber(
+        constantsimp(f(C1, x), [C1])) == f(C1, x)
+    assert constant_renumber(constantsimp(f(C1, y), [C1, y])) == C1
+    assert constant_renumber(constantsimp(f(y, C1), [C1, y])) == C1
+    assert constant_renumber(constantsimp(f(C1, y, C2), [C1, C2, y])) == C1
+
+
+def test_constant_function_multiple():
+    # The rules to not renumber in this case would be too complicated, and
+    # dsolve is not likely to ever encounter anything remotely like this.
+    assert constant_renumber(
+        constantsimp(f(C1, C1, x), [C1])) == f(C1, C1, x)
+
+
+def test_constant_multiple():
+    assert constant_renumber(constantsimp(C1*2 + 2, [C1])) == C1
+    assert constant_renumber(constantsimp(x*2/C1, [C1])) == C1*x
+    assert constant_renumber(constantsimp(C1**2*2 + 2, [C1])) == C1
+    assert constant_renumber(
+        constantsimp(sin(2*C1) + x + sqrt(2), [C1])) == C1 + x
+    assert constant_renumber(constantsimp(2*C1 + C2, [C1, C2])) == C1
+
+def test_constant_repeated():
+    assert C1 + C1*x == constant_renumber( C1 + C1*x)
+
+def test_ode_solutions():
+    # only a few examples here, the rest will be tested in the actual dsolve tests
+    assert constant_renumber(constantsimp(C1*exp(2*x) + exp(x)*(C2 + C3), [C1, C2, C3])) == \
+        constant_renumber(C1*exp(x) + C2*exp(2*x))
+    assert constant_renumber(
+        constantsimp(Eq(f(x), I*C1*sinh(x/3) + C2*cosh(x/3)), [C1, C2])
+        ) == constant_renumber(Eq(f(x), C1*sinh(x/3) + C2*cosh(x/3)))
+    assert constant_renumber(constantsimp(Eq(f(x), acos((-C1)/cos(x))), [C1])) == \
+        Eq(f(x), acos(C1/cos(x)))
+    assert constant_renumber(
+        constantsimp(Eq(log(f(x)/C1) + 2*exp(x/f(x)), 0), [C1])
+        ) == Eq(log(C1*f(x)) + 2*exp(x/f(x)), 0)
+    assert constant_renumber(constantsimp(Eq(log(x*sqrt(2)*sqrt(1/x)*sqrt(f(x))
+        /C1) + x**2/(2*f(x)**2), 0), [C1])) == \
+        Eq(log(C1*sqrt(x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
+    assert constant_renumber(constantsimp(Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(x/C1) -
+        cos(f(x)/x)*exp(-f(x)/x)/2, 0), [C1])) == \
+        Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(C1*x) - cos(f(x)/x)*
+           exp(-f(x)/x)/2, 0)
+    assert constant_renumber(constantsimp(Eq(-Integral(-1/(sqrt(1 - u2**2)*u2),
+        (u2, _a, x/f(x))) + log(f(x)/C1), 0), [C1])) == \
+        Eq(-Integral(-1/(u2*sqrt(1 - u2**2)), (u2, _a, x/f(x))) +
+        log(C1*f(x)), 0)
+    assert [constantsimp(i, [C1]) for i in [Eq(f(x), sqrt(-C1*x + x**2)), Eq(f(x), -sqrt(-C1*x + x**2))]] == \
+        [Eq(f(x), sqrt(x*(C1 + x))), Eq(f(x), -sqrt(x*(C1 + x)))]
+
+
+@XFAIL
+def test_nonlocal_simplification():
+    assert constantsimp(C1 + C2+x*C2, [C1, C2]) == C1 + C2*x
+
+
+def test_constant_Eq():
+    # C1 on the rhs is well-tested, but the lhs is only tested here
+    assert constantsimp(Eq(C1, 3 + f(x)*x), [C1]) == Eq(x*f(x), C1)
+    assert constantsimp(Eq(C1, 3 * f(x)*x), [C1]) == Eq(f(x)*x, C1)