Add files using upload-large-folder tool

.gitattributes

@@ -127,3 +127,4 @@ env-llmeval/lib/python3.10/site-packages/lxml/objectify.cpython-310-x86_64-linux
 env-llmeval/lib/python3.10/site-packages/triton/third_party/cuda/bin/ptxas filter=lfs diff=lfs merge=lfs -text
 env-llmeval/lib/python3.10/site-packages/lxml/etree.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 env-llmeval/lib/python3.10/site-packages/scipy.libs/libopenblasp-r0-24bff013.3.26.dev.so filter=lfs diff=lfs merge=lfs -text
+env-llmeval/lib/python3.10/site-packages/scipy.libs/libgfortran-040039e1.so.5.0.0 filter=lfs diff=lfs merge=lfs -text

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py33_np18.pkl_01.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0efbd7d9ce7eec3a6e0a0db41e795e0396cca3d6b037dad6c61b464843d28809
+size 120

env-llmeval/lib/python3.10/site-packages/scipy.libs/libgfortran-040039e1.so.5.0.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14afb3129b1a8b50bc40a3b0820c7f1152ea9bc10121aab152943f7057472886
+size 2686065

env-llmeval/lib/python3.10/site-packages/sympy/solvers/__init__.py

@@ -0,0 +1,71 @@
+"""A module for solving all kinds of equations.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers import solve
+    >>> from sympy.abc import x
+    >>> solve(x**5+5*x**4+10*x**3+10*x**2+5*x+1,x)
+    [-1]
+"""
+from sympy.core.assumptions import check_assumptions, failing_assumptions
+
+from .solvers import solve, solve_linear_system, solve_linear_system_LU, \
+    solve_undetermined_coeffs, nsolve, solve_linear, checksol, \
+    det_quick, inv_quick
+
+from .diophantine import diophantine
+
+from .recurr import rsolve, rsolve_poly, rsolve_ratio, rsolve_hyper
+
+from .ode import checkodesol, classify_ode, dsolve, \
+    homogeneous_order
+
+from .polysys import solve_poly_system, solve_triangulated
+
+from .pde import pde_separate, pde_separate_add, pde_separate_mul, \
+    pdsolve, classify_pde, checkpdesol
+
+from .deutils import ode_order
+
+from .inequalities import reduce_inequalities, reduce_abs_inequality, \
+    reduce_abs_inequalities, solve_poly_inequality, solve_rational_inequalities, solve_univariate_inequality
+
+from .decompogen import decompogen
+
+from .solveset import solveset, linsolve, linear_eq_to_matrix, nonlinsolve, substitution
+
+# This is here instead of sympy/sets/__init__.py to avoid circular import issues
+from ..core.singleton import S
+Complexes = S.Complexes
+
+__all__ = [
+    'solve', 'solve_linear_system', 'solve_linear_system_LU',
+    'solve_undetermined_coeffs', 'nsolve', 'solve_linear', 'checksol',
+    'det_quick', 'inv_quick', 'check_assumptions', 'failing_assumptions',
+
+    'diophantine',
+
+    'rsolve', 'rsolve_poly', 'rsolve_ratio', 'rsolve_hyper',
+
+    'checkodesol', 'classify_ode', 'dsolve', 'homogeneous_order',
+
+    'solve_poly_system', 'solve_triangulated',
+
+    'pde_separate', 'pde_separate_add', 'pde_separate_mul', 'pdsolve',
+    'classify_pde', 'checkpdesol',
+
+    'ode_order',
+
+    'reduce_inequalities', 'reduce_abs_inequality', 'reduce_abs_inequalities',
+    'solve_poly_inequality', 'solve_rational_inequalities',
+    'solve_univariate_inequality',
+
+    'decompogen',
+
+    'solveset', 'linsolve', 'linear_eq_to_matrix', 'nonlinsolve',
+    'substitution',
+
+    # This is here instead of sympy/sets/__init__.py to avoid circular import issues
+    'Complexes',
+]

env-llmeval/lib/python3.10/site-packages/sympy/solvers/bivariate.py

@@ -0,0 +1,509 @@
+from sympy.core.add import Add
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import expand_log, _mexpand
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.miscellaneous import root
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import Poly, factor
+from sympy.simplify.simplify import separatevars
+from sympy.simplify.radsimp import collect
+from sympy.simplify.simplify import powsimp
+from sympy.solvers.solvers import solve, _invert
+from sympy.utilities.iterables import uniq
+
+
+def _filtered_gens(poly, symbol):
+    """process the generators of ``poly``, returning the set of generators that
+    have ``symbol``.  If there are two generators that are inverses of each other,
+    prefer the one that has no denominator.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.bivariate import _filtered_gens
+    >>> from sympy import Poly, exp
+    >>> from sympy.abc import x
+    >>> _filtered_gens(Poly(x + 1/x + exp(x)), x)
+    {x, exp(x)}
+
+    """
+    # TODO it would be good to pick the smallest divisible power
+    # instead of the base for something like x**4 + x**2 -->
+    # return x**2 not x
+    gens = {g for g in poly.gens if symbol in g.free_symbols}
+    for g in list(gens):
+        ag = 1/g
+        if g in gens and ag in gens:
+            if ag.as_numer_denom()[1] is not S.One:
+                g = ag
+            gens.remove(g)
+    return gens
+
+
+def _mostfunc(lhs, func, X=None):
+    """Returns the term in lhs which contains the most of the
+    func-type things e.g. log(log(x)) wins over log(x) if both terms appear.
+
+    ``func`` can be a function (exp, log, etc...) or any other SymPy object,
+    like Pow.
+
+    If ``X`` is not ``None``, then the function returns the term composed with the
+    most ``func`` having the specified variable.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.bivariate import _mostfunc
+    >>> from sympy import exp
+    >>> from sympy.abc import x, y
+    >>> _mostfunc(exp(x) + exp(exp(x) + 2), exp)
+    exp(exp(x) + 2)
+    >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp)
+    exp(exp(y) + 2)
+    >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp, x)
+    exp(x)
+    >>> _mostfunc(x, exp, x) is None
+    True
+    >>> _mostfunc(exp(x) + exp(x*y), exp, x)
+    exp(x)
+    """
+    fterms = [tmp for tmp in lhs.atoms(func) if (not X or
+        X.is_Symbol and X in tmp.free_symbols or
+        not X.is_Symbol and tmp.has(X))]
+    if len(fterms) == 1:
+        return fterms[0]
+    elif fterms:
+        return max(list(ordered(fterms)), key=lambda x: x.count(func))
+    return None
+
+
+def _linab(arg, symbol):
+    """Return ``a, b, X`` assuming ``arg`` can be written as ``a*X + b``
+    where ``X`` is a symbol-dependent factor and ``a`` and ``b`` are
+    independent of ``symbol``.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.bivariate import _linab
+    >>> from sympy.abc import x, y
+    >>> from sympy import exp, S
+    >>> _linab(S(2), x)
+    (2, 0, 1)
+    >>> _linab(2*x, x)
+    (2, 0, x)
+    >>> _linab(y + y*x + 2*x, x)
+    (y + 2, y, x)
+    >>> _linab(3 + 2*exp(x), x)
+    (2, 3, exp(x))
+    """
+    arg = factor_terms(arg.expand())
+    ind, dep = arg.as_independent(symbol)
+    if arg.is_Mul and dep.is_Add:
+        a, b, x = _linab(dep, symbol)
+        return ind*a, ind*b, x
+    if not arg.is_Add:
+        b = 0
+        a, x = ind, dep
+    else:
+        b = ind
+        a, x = separatevars(dep).as_independent(symbol, as_Add=False)
+    if x.could_extract_minus_sign():
+        a = -a
+        x = -x
+    return a, b, x
+
+
+def _lambert(eq, x):
+    """
+    Given an expression assumed to be in the form
+        ``F(X, a..f) = a*log(b*X + c) + d*X + f = 0``
+    where X = g(x) and x = g^-1(X), return the Lambert solution,
+        ``x = g^-1(-c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(-f/a)))``.
+    """
+    eq = _mexpand(expand_log(eq))
+    mainlog = _mostfunc(eq, log, x)
+    if not mainlog:
+        return []  # violated assumptions
+    other = eq.subs(mainlog, 0)
+    if isinstance(-other, log):
+        eq = (eq - other).subs(mainlog, mainlog.args[0])
+        mainlog = mainlog.args[0]
+        if not isinstance(mainlog, log):
+            return []  # violated assumptions
+        other = -(-other).args[0]
+        eq += other
+    if x not in other.free_symbols:
+        return [] # violated assumptions
+    d, f, X2 = _linab(other, x)
+    logterm = collect(eq - other, mainlog)
+    a = logterm.as_coefficient(mainlog)
+    if a is None or x in a.free_symbols:
+        return []  # violated assumptions
+    logarg = mainlog.args[0]
+    b, c, X1 = _linab(logarg, x)
+    if X1 != X2:
+        return []  # violated assumptions
+
+    # invert the generator X1 so we have x(u)
+    u = Dummy('rhs')
+    xusolns = solve(X1 - u, x)
+
+    # There are infinitely many branches for LambertW
+    # but only branches for k = -1 and 0 might be real. The k = 0
+    # branch is real and the k = -1 branch is real if the LambertW argumen
+    # in in range [-1/e, 0]. Since `solve` does not return infinite
+    # solutions we will only include the -1 branch if it tests as real.
+    # Otherwise, inclusion of any LambertW in the solution indicates to
+    #  the user that there are imaginary solutions corresponding to
+    # different k values.
+    lambert_real_branches = [-1, 0]
+    sol = []
+
+    # solution of the given Lambert equation is like
+    # sol = -c/b + (a/d)*LambertW(arg, k),
+    # where arg = d/(a*b)*exp((c*d-b*f)/a/b) and k in lambert_real_branches.
+    # Instead of considering the single arg, `d/(a*b)*exp((c*d-b*f)/a/b)`,
+    # the individual `p` roots obtained when writing `exp((c*d-b*f)/a/b)`
+    # as `exp(A/p) = exp(A)**(1/p)`, where `p` is an Integer, are used.
+
+    # calculating args for LambertW
+    num, den = ((c*d-b*f)/a/b).as_numer_denom()
+    p, den = den.as_coeff_Mul()
+    e = exp(num/den)
+    t = Dummy('t')
+    args = [d/(a*b)*t for t in roots(t**p - e, t).keys()]
+
+    # calculating solutions from args
+    for arg in args:
+        for k in lambert_real_branches:
+            w = LambertW(arg, k)
+            if k and not w.is_real:
+                continue
+            rhs = -c/b + (a/d)*w
+
+            sol.extend(xu.subs(u, rhs) for xu in xusolns)
+    return sol
+
+
+def _solve_lambert(f, symbol, gens):
+    """Return solution to ``f`` if it is a Lambert-type expression
+    else raise NotImplementedError.
+
+    For ``f(X, a..f) = a*log(b*X + c) + d*X - f = 0`` the solution
+    for ``X`` is ``X = -c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(f/a))``.
+    There are a variety of forms for `f(X, a..f)` as enumerated below:
+
+    1a1)
+      if B**B = R for R not in [0, 1] (since those cases would already
+      be solved before getting here) then log of both sides gives
+      log(B) + log(log(B)) = log(log(R)) and
+      X = log(B), a = 1, b = 1, c = 0, d = 1, f = log(log(R))
+    1a2)
+      if B*(b*log(B) + c)**a = R then log of both sides gives
+      log(B) + a*log(b*log(B) + c) = log(R) and
+      X = log(B), d=1, f=log(R)
+    1b)
+      if a*log(b*B + c) + d*B = R and
+      X = B, f = R
+    2a)
+      if (b*B + c)*exp(d*B + g) = R then log of both sides gives
+      log(b*B + c) + d*B + g = log(R) and
+      X = B, a = 1, f = log(R) - g
+    2b)
+      if g*exp(d*B + h) - b*B = c then the log form is
+      log(g) + d*B + h - log(b*B + c) = 0 and
+      X = B, a = -1, f = -h - log(g)
+    3)
+      if d*p**(a*B + g) - b*B = c then the log form is
+      log(d) + (a*B + g)*log(p) - log(b*B + c) = 0 and
+      X = B, a = -1, d = a*log(p), f = -log(d) - g*log(p)
+    """
+
+    def _solve_even_degree_expr(expr, t, symbol):
+        """Return the unique solutions of equations derived from
+        ``expr`` by replacing ``t`` with ``+/- symbol``.
+
+        Parameters
+        ==========
+
+        expr : Expr
+            The expression which includes a dummy variable t to be
+            replaced with +symbol and -symbol.
+
+        symbol : Symbol
+            The symbol for which a solution is being sought.
+
+        Returns
+        =======
+
+        List of unique solution of the two equations generated by
+        replacing ``t`` with positive and negative ``symbol``.
+
+        Notes
+        =====
+
+        If ``expr = 2*log(t) + x/2` then solutions for
+        ``2*log(x) + x/2 = 0`` and ``2*log(-x) + x/2 = 0`` are
+        returned by this function. Though this may seem
+        counter-intuitive, one must note that the ``expr`` being
+        solved here has been derived from a different expression. For
+        an expression like ``eq = x**2*g(x) = 1``, if we take the
+        log of both sides we obtain ``log(x**2) + log(g(x)) = 0``. If
+        x is positive then this simplifies to
+        ``2*log(x) + log(g(x)) = 0``; the Lambert-solving routines will
+        return solutions for this, but we must also consider the
+        solutions for  ``2*log(-x) + log(g(x))`` since those must also
+        be a solution of ``eq`` which has the same value when the ``x``
+        in ``x**2`` is negated. If `g(x)` does not have even powers of
+        symbol then we do not want to replace the ``x`` there with
+        ``-x``. So the role of the ``t`` in the expression received by
+        this function is to mark where ``+/-x`` should be inserted
+        before obtaining the Lambert solutions.
+
+        """
+        nlhs, plhs = [
+            expr.xreplace({t: sgn*symbol}) for sgn in (-1, 1)]
+        sols = _solve_lambert(nlhs, symbol, gens)
+        if plhs != nlhs:
+            sols.extend(_solve_lambert(plhs, symbol, gens))
+        # uniq is needed for a case like
+        # 2*log(t) - log(-z**2) + log(z + log(x) + log(z))
+        # where substituting t with +/-x gives all the same solution;
+        # uniq, rather than list(set()), is used to maintain canonical
+        # order
+        return list(uniq(sols))
+
+    nrhs, lhs = f.as_independent(symbol, as_Add=True)
+    rhs = -nrhs
+
+    lamcheck = [tmp for tmp in gens
+                if (tmp.func in [exp, log] or
+                (tmp.is_Pow and symbol in tmp.exp.free_symbols))]
+    if not lamcheck:
+        raise NotImplementedError()
+
+    if lhs.is_Add or lhs.is_Mul:
+        # replacing all even_degrees of symbol with dummy variable t
+        # since these will need special handling; non-Add/Mul do not
+        # need this handling
+        t = Dummy('t', **symbol.assumptions0)
+        lhs = lhs.replace(
+            lambda i:  # find symbol**even
+                i.is_Pow and i.base == symbol and i.exp.is_even,
+            lambda i:  # replace t**even
+                t**i.exp)
+
+        if lhs.is_Add and lhs.has(t):
+            t_indep = lhs.subs(t, 0)
+            t_term = lhs - t_indep
+            _rhs = rhs - t_indep
+            if not t_term.is_Add and _rhs and not (
+                    t_term.has(S.ComplexInfinity, S.NaN)):
+                eq = expand_log(log(t_term) - log(_rhs))
+                return _solve_even_degree_expr(eq, t, symbol)
+        elif lhs.is_Mul and rhs:
+            # this needs to happen whether t is present or not
+            lhs = expand_log(log(lhs), force=True)
+            rhs = log(rhs)
+            if lhs.has(t) and lhs.is_Add:
+                # it expanded from Mul to Add
+                eq = lhs - rhs
+                return _solve_even_degree_expr(eq, t, symbol)
+
+        # restore symbol in lhs
+        lhs = lhs.xreplace({t: symbol})
+
+    lhs = powsimp(factor(lhs, deep=True))
+
+    # make sure we have inverted as completely as possible
+    r = Dummy()
+    i, lhs = _invert(lhs - r, symbol)
+    rhs = i.xreplace({r: rhs})
+
+    # For the first forms:
+    #
+    # 1a1) B**B = R will arrive here as B*log(B) = log(R)
+    #      lhs is Mul so take log of both sides:
+    #        log(B) + log(log(B)) = log(log(R))
+    # 1a2) B*(b*log(B) + c)**a = R will arrive unchanged so
+    #      lhs is Mul, so take log of both sides:
+    #        log(B) + a*log(b*log(B) + c) = log(R)
+    # 1b) d*log(a*B + b) + c*B = R will arrive unchanged so
+    #      lhs is Add, so isolate c*B and expand log of both sides:
+    #        log(c) + log(B) = log(R - d*log(a*B + b))
+
+    soln = []
+    if not soln:
+        mainlog = _mostfunc(lhs, log, symbol)
+        if mainlog:
+            if lhs.is_Mul and rhs != 0:
+                soln = _lambert(log(lhs) - log(rhs), symbol)
+            elif lhs.is_Add:
+                other = lhs.subs(mainlog, 0)
+                if other and not other.is_Add and [
+                        tmp for tmp in other.atoms(Pow)
+                        if symbol in tmp.free_symbols]:
+                    if not rhs:
+                        diff = log(other) - log(other - lhs)
+                    else:
+                        diff = log(lhs - other) - log(rhs - other)
+                    soln = _lambert(expand_log(diff), symbol)
+                else:
+                    #it's ready to go
+                    soln = _lambert(lhs - rhs, symbol)
+
+    # For the next forms,
+    #
+    #     collect on main exp
+    #     2a) (b*B + c)*exp(d*B + g) = R
+    #         lhs is mul, so take log of both sides:
+    #           log(b*B + c) + d*B = log(R) - g
+    #     2b) g*exp(d*B + h) - b*B = R
+    #         lhs is add, so add b*B to both sides,
+    #         take the log of both sides and rearrange to give
+    #           log(R + b*B) - d*B = log(g) + h
+
+    if not soln:
+        mainexp = _mostfunc(lhs, exp, symbol)
+        if mainexp:
+            lhs = collect(lhs, mainexp)
+            if lhs.is_Mul and rhs != 0:
+                soln = _lambert(expand_log(log(lhs) - log(rhs)), symbol)
+            elif lhs.is_Add:
+                # move all but mainexp-containing term to rhs
+                other = lhs.subs(mainexp, 0)
+                mainterm = lhs - other
+                rhs = rhs - other
+                if (mainterm.could_extract_minus_sign() and
+                    rhs.could_extract_minus_sign()):
+                    mainterm *= -1
+                    rhs *= -1
+                diff = log(mainterm) - log(rhs)
+                soln = _lambert(expand_log(diff), symbol)
+
+    # For the last form:
+    #
+    #  3) d*p**(a*B + g) - b*B = c
+    #     collect on main pow, add b*B to both sides,
+    #     take log of both sides and rearrange to give
+    #       a*B*log(p) - log(b*B + c) = -log(d) - g*log(p)
+    if not soln:
+        mainpow = _mostfunc(lhs, Pow, symbol)
+        if mainpow and symbol in mainpow.exp.free_symbols:
+            lhs = collect(lhs, mainpow)
+            if lhs.is_Mul and rhs != 0:
+                # b*B = 0
+                soln = _lambert(expand_log(log(lhs) - log(rhs)), symbol)
+            elif lhs.is_Add:
+                # move all but mainpow-containing term to rhs
+                other = lhs.subs(mainpow, 0)
+                mainterm = lhs - other
+                rhs = rhs - other
+                diff = log(mainterm) - log(rhs)
+                soln = _lambert(expand_log(diff), symbol)
+
+    if not soln:
+        raise NotImplementedError('%s does not appear to have a solution in '
+            'terms of LambertW' % f)
+
+    return list(ordered(soln))
+
+
+def bivariate_type(f, x, y, *, first=True):
+    """Given an expression, f, 3 tests will be done to see what type
+    of composite bivariate it might be, options for u(x, y) are::
+
+        x*y
+        x+y
+        x*y+x
+        x*y+y
+
+    If it matches one of these types, ``u(x, y)``, ``P(u)`` and dummy
+    variable ``u`` will be returned. Solving ``P(u)`` for ``u`` and
+    equating the solutions to ``u(x, y)`` and then solving for ``x`` or
+    ``y`` is equivalent to solving the original expression for ``x`` or
+    ``y``. If ``x`` and ``y`` represent two functions in the same
+    variable, e.g. ``x = g(t)`` and ``y = h(t)``, then if ``u(x, y) - p``
+    can be solved for ``t`` then these represent the solutions to
+    ``P(u) = 0`` when ``p`` are the solutions of ``P(u) = 0``.
+
+    Only positive values of ``u`` are considered.
+
+    Examples
+    ========
+
+    >>> from sympy import solve
+    >>> from sympy.solvers.bivariate import bivariate_type
+    >>> from sympy.abc import x, y
+    >>> eq = (x**2 - 3).subs(x, x + y)
+    >>> bivariate_type(eq, x, y)
+    (x + y, _u**2 - 3, _u)
+    >>> uxy, pu, u = _
+    >>> usol = solve(pu, u); usol
+    [sqrt(3)]
+    >>> [solve(uxy - s) for s in solve(pu, u)]
+    [[{x: -y + sqrt(3)}]]
+    >>> all(eq.subs(s).equals(0) for sol in _ for s in sol)
+    True
+
+    """
+
+    u = Dummy('u', positive=True)
+
+    if first:
+        p = Poly(f, x, y)
+        f = p.as_expr()
+        _x = Dummy()
+        _y = Dummy()
+        rv = bivariate_type(Poly(f.subs({x: _x, y: _y}), _x, _y), _x, _y, first=False)
+        if rv:
+            reps = {_x: x, _y: y}
+            return rv[0].xreplace(reps), rv[1].xreplace(reps), rv[2]
+        return
+
+    p = f
+    f = p.as_expr()
+
+    # f(x*y)
+    args = Add.make_args(p.as_expr())
+    new = []
+    for a in args:
+        a = _mexpand(a.subs(x, u/y))
+        free = a.free_symbols
+        if x in free or y in free:
+            break
+        new.append(a)
+    else:
+        return x*y, Add(*new), u
+
+    def ok(f, v, c):
+        new = _mexpand(f.subs(v, c))
+        free = new.free_symbols
+        return None if (x in free or y in free) else new
+
+    # f(a*x + b*y)
+    new = []
+    d = p.degree(x)
+    if p.degree(y) == d:
+        a = root(p.coeff_monomial(x**d), d)
+        b = root(p.coeff_monomial(y**d), d)
+        new = ok(f, x, (u - b*y)/a)
+        if new is not None:
+            return a*x + b*y, new, u
+
+    # f(a*x*y + b*y)
+    new = []
+    d = p.degree(x)
+    if p.degree(y) == d:
+        for itry in range(2):
+            a = root(p.coeff_monomial(x**d*y**d), d)
+            b = root(p.coeff_monomial(y**d), d)
+            new = ok(f, x, (u - b*y)/a/y)
+            if new is not None:
+                return a*x*y + b*y, new, u
+            x, y = y, x

env-llmeval/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)

env-llmeval/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'
+]

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

@@ -0,0 +1,1037 @@
+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
+
+
+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 sum_of_three_squares(7) is None
+    assert sum_of_three_squares((4**5)*15) is None
+    assert sum_of_three_squares(25) == (5, 0, 0)
+    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
+
+    assert sum_of_four_squares(0) == (0, 0, 0, 0)
+    assert sum_of_four_squares(14) == (0, 1, 2, 3)
+    assert sum_of_four_squares(15) == (1, 1, 2, 3)
+    assert sum_of_four_squares(18) == (1, 2, 2, 3)
+    assert sum_of_four_squares(19) == (0, 1, 3, 3)
+    assert sum_of_four_squares(48) == (0, 4, 4, 4)
+
+
+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) is None
+    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(-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)}

env-llmeval/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'
+]

env-llmeval/lib/python3.10/site-packages/sympy/solvers/ode/hypergeometric.py

@@ -0,0 +1,272 @@
+r'''
+This module contains the implementation of the 2nd_hypergeometric hint for
+dsolve. This is an incomplete implementation of the algorithm described in [1].
+The algorithm solves 2nd order linear ODEs of the form
+
+.. math:: y'' + A(x) y' + B(x) y = 0\text{,}
+
+where `A` and `B` are rational functions. The algorithm should find any
+solution of the form
+
+.. math:: y = P(x) _pF_q(..; ..;\frac{\alpha x^k + \beta}{\gamma x^k + \delta})\text{,}
+
+where pFq is any of 2F1, 1F1 or 0F1 and `P` is an "arbitrary function".
+Currently only the 2F1 case is implemented in SymPy but the other cases are
+described in the paper and could be implemented in future (contributions
+welcome!).
+
+References
+==========
+
+.. [1] L. Chan, E.S. Cheb-Terrab, Non-Liouvillian solutions for second order
+       linear ODEs, (2004).
+       https://arxiv.org/abs/math-ph/0402063
+'''
+
+from sympy.core import S, Pow
+from sympy.core.function import expand
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol, Wild
+from sympy.functions import exp, sqrt, hyper
+from sympy.integrals import Integral
+from sympy.polys import roots, gcd
+from sympy.polys.polytools import cancel, factor
+from sympy.simplify import collect, simplify, logcombine # type: ignore
+from sympy.simplify.powsimp import powdenest
+from sympy.solvers.ode.ode import get_numbered_constants
+
+
+def match_2nd_hypergeometric(eq, func):
+    x = func.args[0]
+    df = func.diff(x)
+    a3 = Wild('a3', exclude=[func, func.diff(x), func.diff(x, 2)])
+    b3 = Wild('b3', exclude=[func, func.diff(x), func.diff(x, 2)])
+    c3 = Wild('c3', exclude=[func, func.diff(x), func.diff(x, 2)])
+    deq = a3*(func.diff(x, 2)) + b3*df + c3*func
+    r = collect(eq,
+        [func.diff(x, 2), func.diff(x), func]).match(deq)
+    if r:
+        if not all(val.is_polynomial() for val in r.values()):
+            n, d = eq.as_numer_denom()
+            eq = expand(n)
+            r = collect(eq, [func.diff(x, 2), func.diff(x), func]).match(deq)
+
+    if r and r[a3]!=0:
+        A = cancel(r[b3]/r[a3])
+        B = cancel(r[c3]/r[a3])
+        return [A, B]
+    else:
+        return []
+
+
+def equivalence_hypergeometric(A, B, func):
+    # This method for finding the equivalence is only for 2F1 type.
+    # We can extend it for 1F1 and 0F1 type also.
+    x = func.args[0]
+
+    # making given equation in normal form
+    I1 = factor(cancel(A.diff(x)/2 + A**2/4 - B))
+
+    # computing shifted invariant(J1) of the equation
+    J1 = factor(cancel(x**2*I1 + S(1)/4))
+    num, dem = J1.as_numer_denom()
+    num = powdenest(expand(num))
+    dem = powdenest(expand(dem))
+    # this function will compute the different powers of variable(x) in J1.
+    # then it will help in finding value of k. k is power of x such that we can express
+    # J1 = x**k * J0(x**k) then all the powers in J0 become integers.
+    def _power_counting(num):
+        _pow = {0}
+        for val in num:
+            if val.has(x):
+                if isinstance(val, Pow) and val.as_base_exp()[0] == x:
+                    _pow.add(val.as_base_exp()[1])
+                elif val == x:
+                    _pow.add(val.as_base_exp()[1])
+                else:
+                    _pow.update(_power_counting(val.args))
+        return _pow
+
+    pow_num = _power_counting((num, ))
+    pow_dem = _power_counting((dem, ))
+    pow_dem.update(pow_num)
+
+    _pow = pow_dem
+    k = gcd(_pow)
+
+    # computing I0 of the given equation
+    I0 = powdenest(simplify(factor(((J1/k**2) - S(1)/4)/((x**k)**2))), force=True)
+    I0 = factor(cancel(powdenest(I0.subs(x, x**(S(1)/k)), force=True)))
+
+    # Before this point I0, J1 might be functions of e.g. sqrt(x) but replacing
+    # x with x**(1/k) should result in I0 being a rational function of x or
+    # otherwise the hypergeometric solver cannot be used. Note that k can be a
+    # non-integer rational such as 2/7.
+    if not I0.is_rational_function(x):
+        return None
+
+    num, dem = I0.as_numer_denom()
+
+    max_num_pow = max(_power_counting((num, )))
+    dem_args = dem.args
+    sing_point = []
+    dem_pow = []
+    # calculating singular point of I0.
+    for arg in dem_args:
+        if arg.has(x):
+            if isinstance(arg, Pow):
+                # (x-a)**n
+                dem_pow.append(arg.as_base_exp()[1])
+                sing_point.append(list(roots(arg.as_base_exp()[0], x).keys())[0])
+            else:
+                # (x-a) type
+                dem_pow.append(arg.as_base_exp()[1])
+                sing_point.append(list(roots(arg, x).keys())[0])
+
+    dem_pow.sort()
+    # checking if equivalence is exists or not.
+
+    if equivalence(max_num_pow, dem_pow) == "2F1":
+        return {'I0':I0, 'k':k, 'sing_point':sing_point, 'type':"2F1"}
+    else:
+        return None
+
+
+def match_2nd_2F1_hypergeometric(I, k, sing_point, func):
+    x = func.args[0]
+    a = Wild("a")
+    b = Wild("b")
+    c = Wild("c")
+    t = Wild("t")
+    s = Wild("s")
+    r = Wild("r")
+    alpha = Wild("alpha")
+    beta = Wild("beta")
+    gamma = Wild("gamma")
+    delta = Wild("delta")
+    # I0 of the standerd 2F1 equation.
+    I0 = ((a-b+1)*(a-b-1)*x**2 + 2*((1-a-b)*c + 2*a*b)*x + c*(c-2))/(4*x**2*(x-1)**2)
+    if sing_point != [0, 1]:
+        # If singular point is [0, 1] then we have standerd equation.
+        eqs = []
+        sing_eqs = [-beta/alpha, -delta/gamma, (delta-beta)/(alpha-gamma)]
+        # making equations for the finding the mobius transformation
+        for i in range(3):
+            if i<len(sing_point):
+                eqs.append(Eq(sing_eqs[i], sing_point[i]))
+            else:
+                eqs.append(Eq(1/sing_eqs[i], 0))
+        # solving above equations for the mobius transformation
+        _beta = -alpha*sing_point[0]
+        _delta = -gamma*sing_point[1]
+        _gamma = alpha
+        if len(sing_point) == 3:
+            _gamma = (_beta + sing_point[2]*alpha)/(sing_point[2] - sing_point[1])
+        mob = (alpha*x + beta)/(gamma*x + delta)
+        mob = mob.subs(beta, _beta)
+        mob = mob.subs(delta, _delta)
+        mob = mob.subs(gamma, _gamma)
+        mob = cancel(mob)
+        t = (beta - delta*x)/(gamma*x - alpha)
+        t = cancel(((t.subs(beta, _beta)).subs(delta, _delta)).subs(gamma, _gamma))
+    else:
+        mob = x
+        t = x
+
+    # applying mobius transformation in I to make it into I0.
+    I = I.subs(x, t)
+    I = I*(t.diff(x))**2
+    I = factor(I)
+    dict_I = {x**2:0, x:0, 1:0}
+    I0_num, I0_dem = I0.as_numer_denom()
+    # collecting coeff of (x**2, x), of the standerd equation.
+    # substituting (a-b) = s, (a+b) = r
+    dict_I0 = {x**2:s**2 - 1, x:(2*(1-r)*c + (r+s)*(r-s)), 1:c*(c-2)}
+    # collecting coeff of (x**2, x) from I0 of the given equation.
+    dict_I.update(collect(expand(cancel(I*I0_dem)), [x**2, x], evaluate=False))
+    eqs = []
+    # We are comparing the coeff of powers of different x, for finding the values of
+    # parameters of standerd equation.
+    for key in [x**2, x, 1]:
+        eqs.append(Eq(dict_I[key], dict_I0[key]))
+
+    # We can have many possible roots for the equation.
+    # I am selecting the root on the basis that when we have
+    # standard equation eq = x*(x-1)*f(x).diff(x, 2) + ((a+b+1)*x-c)*f(x).diff(x) + a*b*f(x)
+    # then root should be a, b, c.
+
+    _c = 1 - factor(sqrt(1+eqs[2].lhs))
+    if not _c.has(Symbol):
+        _c = min(list(roots(eqs[2], c)))
+    _s = factor(sqrt(eqs[0].lhs + 1))
+    _r = _c - factor(sqrt(_c**2 + _s**2 + eqs[1].lhs - 2*_c))
+    _a = (_r + _s)/2
+    _b = (_r - _s)/2
+
+    rn = {'a':simplify(_a), 'b':simplify(_b), 'c':simplify(_c), 'k':k, 'mobius':mob, 'type':"2F1"}
+    return rn
+
+
+def equivalence(max_num_pow, dem_pow):
+    # this function is made for checking the equivalence with 2F1 type of equation.
+    # max_num_pow is the value of maximum power of x in numerator
+    # and dem_pow is list of powers of different factor of form (a*x b).
+    # reference from table 1 in paper - "Non-Liouvillian solutions for second order
+    # linear ODEs" by L. Chan, E.S. Cheb-Terrab.
+    # We can extend it for 1F1 and 0F1 type also.
+
+    if max_num_pow == 2:
+        if dem_pow in [[2, 2], [2, 2, 2]]:
+            return "2F1"
+    elif max_num_pow == 1:
+        if dem_pow in [[1, 2, 2], [2, 2, 2], [1, 2], [2, 2]]:
+            return "2F1"
+    elif max_num_pow == 0:
+        if dem_pow in [[1, 1, 2], [2, 2], [1, 2, 2], [1, 1], [2], [1, 2], [2, 2]]:
+            return "2F1"
+
+    return None
+
+
+def get_sol_2F1_hypergeometric(eq, func, match_object):
+    x = func.args[0]
+    from sympy.simplify.hyperexpand import hyperexpand
+    from sympy.polys.polytools import factor
+    C0, C1 = get_numbered_constants(eq, num=2)
+    a = match_object['a']
+    b = match_object['b']
+    c = match_object['c']
+    A = match_object['A']
+
+    sol = None
+
+    if c.is_integer == False:
+        sol = C0*hyper([a, b], [c], x) + C1*hyper([a-c+1, b-c+1], [2-c], x)*x**(1-c)
+    elif c == 1:
+        y2 = Integral(exp(Integral((-(a+b+1)*x + c)/(x**2-x), x))/(hyperexpand(hyper([a, b], [c], x))**2), x)*hyper([a, b], [c], x)
+        sol = C0*hyper([a, b], [c], x) + C1*y2
+    elif (c-a-b).is_integer == False:
+        sol = C0*hyper([a, b], [1+a+b-c], 1-x) + C1*hyper([c-a, c-b], [1+c-a-b], 1-x)*(1-x)**(c-a-b)
+
+    if sol:
+        # applying transformation in the solution
+        subs = match_object['mobius']
+        dtdx = simplify(1/(subs.diff(x)))
+        _B = ((a + b + 1)*x - c).subs(x, subs)*dtdx
+        _B = factor(_B + ((x**2 -x).subs(x, subs))*(dtdx.diff(x)*dtdx))
+        _A = factor((x**2 - x).subs(x, subs)*(dtdx**2))
+        e = exp(logcombine(Integral(cancel(_B/(2*_A)), x), force=True))
+        sol = sol.subs(x, match_object['mobius'])
+        sol = sol.subs(x, x**match_object['k'])
+        e = e.subs(x, x**match_object['k'])
+
+        if not A.is_zero:
+            e1 = Integral(A/2, x)
+            e1 = exp(logcombine(e1, force=True))
+            sol = cancel((e/e1)*x**((-match_object['k']+1)/2))*sol
+            sol = Eq(func, sol)
+            return sol
+
+        sol = cancel((e)*x**((-match_object['k']+1)/2))*sol
+        sol = Eq(func, sol)
+    return sol

env-llmeval/lib/python3.10/site-packages/sympy/solvers/ode/lie_group.py

@@ -0,0 +1,1101 @@
+r"""
+This module contains the implementation of the internal helper functions for the lie_group hint for
+dsolve. These helper functions apply different heuristics on the given equation
+and return the solution. These functions are used by :py:meth:`sympy.solvers.ode.single.LieGroup`
+
+References
+=========
+
+- `abaco1_simple`, `function_sum` and `chi`  are referenced from E.S Cheb-Terrab, L.G.S Duarte
+and L.A,C.P da Mota, Computer Algebra Solving of First Order ODEs Using
+Symmetry Methods, pp. 7 - pp. 8
+
+- `abaco1_product`, `abaco2_similar`, `abaco2_unique_unknown`, `linear`  and `abaco2_unique_general`
+are referenced from E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ODE Patterns, pp. 7 - pp. 12
+
+- `bivariate` from Lie Groups and Differential Equations pp. 327 - pp. 329
+
+"""
+from itertools import islice
+
+from sympy.core import Add, S, Mul, Pow
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Function, AppliedUndef, expand
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Symbol, Wild, Dummy, symbols
+from sympy.functions import exp, log
+from sympy.integrals.integrals import integrate
+from sympy.polys import Poly
+from sympy.polys.polytools import cancel, div
+from sympy.simplify import (collect, powsimp,  # type: ignore
+    separatevars, simplify)
+from sympy.solvers import solve
+from sympy.solvers.pde import pdsolve
+
+from sympy.utilities import numbered_symbols
+from sympy.solvers.deutils import _preprocess, ode_order
+from .ode import checkinfsol
+
+
+lie_heuristics = (
+    "abaco1_simple",
+    "abaco1_product",
+    "abaco2_similar",
+    "abaco2_unique_unknown",
+    "abaco2_unique_general",
+    "linear",
+    "function_sum",
+    "bivariate",
+    "chi"
+    )
+
+
+def _ode_lie_group_try_heuristic(eq, heuristic, func, match, inf):
+
+    xi = Function("xi")
+    eta = Function("eta")
+    f = func.func
+    x = func.args[0]
+    y = match['y']
+    h = match['h']
+    tempsol = []
+    if not inf:
+        try:
+            inf = infinitesimals(eq, hint=heuristic, func=func, order=1, match=match)
+        except ValueError:
+            return None
+    for infsim in inf:
+        xiinf = (infsim[xi(x, func)]).subs(func, y)
+        etainf = (infsim[eta(x, func)]).subs(func, y)
+        # This condition creates recursion while using pdsolve.
+        # Since the first step while solving a PDE of form
+        # a*(f(x, y).diff(x)) + b*(f(x, y).diff(y)) + c = 0
+        # is to solve the ODE dy/dx = b/a
+        if simplify(etainf/xiinf) == h:
+            continue
+        rpde = f(x, y).diff(x)*xiinf + f(x, y).diff(y)*etainf
+        r = pdsolve(rpde, func=f(x, y)).rhs
+        s = pdsolve(rpde - 1, func=f(x, y)).rhs
+        newcoord = [_lie_group_remove(coord) for coord in [r, s]]
+        r = Dummy("r")
+        s = Dummy("s")
+        C1 = Symbol("C1")
+        rcoord = newcoord[0]
+        scoord = newcoord[-1]
+        try:
+            sol = solve([r - rcoord, s - scoord], x, y, dict=True)
+            if sol == []:
+                continue
+        except NotImplementedError:
+            continue
+        else:
+            sol = sol[0]
+            xsub = sol[x]
+            ysub = sol[y]
+            num = simplify(scoord.diff(x) + scoord.diff(y)*h)
+            denom = simplify(rcoord.diff(x) + rcoord.diff(y)*h)
+            if num and denom:
+                diffeq = simplify((num/denom).subs([(x, xsub), (y, ysub)]))
+                sep = separatevars(diffeq, symbols=[r, s], dict=True)
+                if sep:
+                    # Trying to separate, r and s coordinates
+                    deq = integrate((1/sep[s]), s) + C1 - integrate(sep['coeff']*sep[r], r)
+                    # Substituting and reverting back to original coordinates
+                    deq = deq.subs([(r, rcoord), (s, scoord)])
+                    try:
+                        sdeq = solve(deq, y)
+                    except NotImplementedError:
+                        tempsol.append(deq)
+                    else:
+                        return [Eq(f(x), sol) for sol in sdeq]
+
+
+            elif denom: # (ds/dr) is zero which means s is constant
+                return [Eq(f(x), solve(scoord - C1, y)[0])]
+
+            elif num: # (dr/ds) is zero which means r is constant
+                return [Eq(f(x), solve(rcoord - C1, y)[0])]
+
+    # If nothing works, return solution as it is, without solving for y
+    if tempsol:
+        return [Eq(sol.subs(y, f(x)), 0) for sol in tempsol]
+    return None
+
+
+def _ode_lie_group( s, func, order, match):
+
+    heuristics = lie_heuristics
+    inf = {}
+    f = func.func
+    x = func.args[0]
+    df = func.diff(x)
+    xi = Function("xi")
+    eta = Function("eta")
+    xis = match['xi']
+    etas = match['eta']
+    y = match.pop('y', None)
+    if y:
+        h = -simplify(match[match['d']]/match[match['e']])
+        y = y
+    else:
+        y = Dummy("y")
+        h = s.subs(func, y)
+
+    if xis is not None and etas is not None:
+        inf = [{xi(x, f(x)): S(xis), eta(x, f(x)): S(etas)}]
+
+        if checkinfsol(Eq(df, s), inf, func=f(x), order=1)[0][0]:
+            heuristics = ["user_defined"] + list(heuristics)
+
+    match = {'h': h, 'y': y}
+
+    # This is done so that if any heuristic raises a ValueError
+    # another heuristic can be used.
+    sol = None
+    for heuristic in heuristics:
+        sol = _ode_lie_group_try_heuristic(Eq(df, s), heuristic, func, match, inf)
+        if sol:
+            return sol
+    return sol
+
+
+def infinitesimals(eq, func=None, order=None, hint='default', match=None):
+    r"""
+    The infinitesimal functions of an ordinary differential equation, `\xi(x,y)`
+    and `\eta(x,y)`, are the infinitesimals of the Lie group of point transformations
+    for which the differential equation is invariant. So, the ODE `y'=f(x,y)`
+    would admit a Lie group `x^*=X(x,y;\varepsilon)=x+\varepsilon\xi(x,y)`,
+    `y^*=Y(x,y;\varepsilon)=y+\varepsilon\eta(x,y)` such that `(y^*)'=f(x^*, y^*)`.
+    A change of coordinates, to `r(x,y)` and `s(x,y)`, can be performed so this Lie group
+    becomes the translation group, `r^*=r` and `s^*=s+\varepsilon`.
+    They are tangents to the coordinate curves of the new system.
+
+    Consider the transformation `(x, y) \to (X, Y)` such that the
+    differential equation remains invariant. `\xi` and `\eta` are the tangents to
+    the transformed coordinates `X` and `Y`, at `\varepsilon=0`.
+
+    .. math:: \left(\frac{\partial X(x,y;\varepsilon)}{\partial\varepsilon
+                }\right)|_{\varepsilon=0} = \xi,
+              \left(\frac{\partial Y(x,y;\varepsilon)}{\partial\varepsilon
+                }\right)|_{\varepsilon=0} = \eta,
+
+    The infinitesimals can be found by solving the following PDE:
+
+        >>> from sympy import Function, Eq, pprint
+        >>> from sympy.abc import x, y
+        >>> xi, eta, h = map(Function, ['xi', 'eta', 'h'])
+        >>> h = h(x, y)  # dy/dx = h
+        >>> eta = eta(x, y)
+        >>> xi = xi(x, y)
+        >>> genform = Eq(eta.diff(x) + (eta.diff(y) - xi.diff(x))*h
+        ... - (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)), 0)
+        >>> pprint(genform)
+        /d               d           \                     d              2       d
+        |--(eta(x, y)) - --(xi(x, y))|*h(x, y) - eta(x, y)*--(h(x, y)) - h (x, y)*--(x
+        \dy              dx          /                     dy                     dy
+        <BLANKLINE>
+                            d             d
+        i(x, y)) - xi(x, y)*--(h(x, y)) + --(eta(x, y)) = 0
+                            dx            dx
+
+    Solving the above mentioned PDE is not trivial, and can be solved only by
+    making intelligent assumptions for `\xi` and `\eta` (heuristics). Once an
+    infinitesimal is found, the attempt to find more heuristics stops. This is done to
+    optimise the speed of solving the differential equation. If a list of all the
+    infinitesimals is needed, ``hint`` should be flagged as ``all``, which gives
+    the complete list of infinitesimals. If the infinitesimals for a particular
+    heuristic needs to be found, it can be passed as a flag to ``hint``.
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.solvers.ode.lie_group import infinitesimals
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = f(x).diff(x) - x**2*f(x)
+    >>> infinitesimals(eq)
+    [{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0}]
+
+    References
+    ==========
+
+    - Solving differential equations by Symmetry Groups,
+      John Starrett, pp. 1 - pp. 14
+
+    """
+
+    if isinstance(eq, Equality):
+        eq = eq.lhs - eq.rhs
+    if not func:
+        eq, func = _preprocess(eq)
+    variables = func.args
+    if len(variables) != 1:
+        raise ValueError("ODE's have only one independent variable")
+    else:
+        x = variables[0]
+        if not order:
+            order = ode_order(eq, func)
+        if order != 1:
+            raise NotImplementedError("Infinitesimals for only "
+                "first order ODE's have been implemented")
+        else:
+            df = func.diff(x)
+            # Matching differential equation of the form a*df + b
+            a = Wild('a', exclude = [df])
+            b = Wild('b', exclude = [df])
+            if match:  # Used by lie_group hint
+                h = match['h']
+                y = match['y']
+            else:
+                match = collect(expand(eq), df).match(a*df + b)
+                if match:
+                    h = -simplify(match[b]/match[a])
+                else:
+                    try:
+                        sol = solve(eq, df)
+                    except NotImplementedError:
+                        raise NotImplementedError("Infinitesimals for the "
+                            "first order ODE could not be found")
+                    else:
+                        h = sol[0]  # Find infinitesimals for one solution
+                y = Dummy("y")
+                h = h.subs(func, y)
+
+            u = Dummy("u")
+            hx = h.diff(x)
+            hy = h.diff(y)
+            hinv = ((1/h).subs([(x, u), (y, x)])).subs(u, y)  # Inverse ODE
+            match = {'h': h, 'func': func, 'hx': hx, 'hy': hy, 'y': y, 'hinv': hinv}
+            if hint == 'all':
+                xieta = []
+                for heuristic in lie_heuristics:
+                    function = globals()['lie_heuristic_' + heuristic]
+                    inflist = function(match, comp=True)
+                    if inflist:
+                        xieta.extend([inf for inf in inflist if inf not in xieta])
+                if xieta:
+                    return xieta
+                else:
+                    raise NotImplementedError("Infinitesimals could not be found for "
+                        "the given ODE")
+
+            elif hint == 'default':
+                for heuristic in lie_heuristics:
+                    function = globals()['lie_heuristic_' + heuristic]
+                    xieta = function(match, comp=False)
+                    if xieta:
+                        return xieta
+
+                raise NotImplementedError("Infinitesimals could not be found for"
+                    " the given ODE")
+
+            elif hint not in lie_heuristics:
+                 raise ValueError("Heuristic not recognized: " + hint)
+
+            else:
+                 function = globals()['lie_heuristic_' + hint]
+                 xieta = function(match, comp=True)
+                 if xieta:
+                     return xieta
+                 else:
+                     raise ValueError("Infinitesimals could not be found using the"
+                         " given heuristic")
+
+
+def lie_heuristic_abaco1_simple(match, comp=False):
+    r"""
+    The first heuristic uses the following four sets of
+    assumptions on `\xi` and `\eta`
+
+    .. math:: \xi = 0, \eta = f(x)
+
+    .. math:: \xi = 0, \eta = f(y)
+
+    .. math:: \xi = f(x), \eta = 0
+
+    .. math:: \xi = f(y), \eta = 0
+
+    The success of this heuristic is determined by algebraic factorisation.
+    For the first assumption `\xi = 0` and `\eta` to be a function of `x`, the PDE
+
+    .. math:: \frac{\partial \eta}{\partial x} + (\frac{\partial \eta}{\partial y}
+                - \frac{\partial \xi}{\partial x})*h
+                - \frac{\partial \xi}{\partial y}*h^{2}
+                - \xi*\frac{\partial h}{\partial x} - \eta*\frac{\partial h}{\partial y} = 0
+
+    reduces to `f'(x) - f\frac{\partial h}{\partial y} = 0`
+    If `\frac{\partial h}{\partial y}` is a function of `x`, then this can usually
+    be integrated easily. A similar idea is applied to the other 3 assumptions as well.
+
+
+    References
+    ==========
+
+    - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
+      Solving of First Order ODEs Using Symmetry Methods, pp. 8
+
+
+    """
+
+    xieta = []
+    y = match['y']
+    h = match['h']
+    func = match['func']
+    x = func.args[0]
+    hx = match['hx']
+    hy = match['hy']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    hysym = hy.free_symbols
+    if y not in hysym:
+        try:
+            fx = exp(integrate(hy, x))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: S.Zero, eta: fx}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    factor = hy/h
+    facsym = factor.free_symbols
+    if x not in facsym:
+        try:
+            fy = exp(integrate(factor, y))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: S.Zero, eta: fy.subs(y, func)}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    factor = -hx/h
+    facsym = factor.free_symbols
+    if y not in facsym:
+        try:
+            fx = exp(integrate(factor, x))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: fx, eta: S.Zero}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    factor = -hx/(h**2)
+    facsym = factor.free_symbols
+    if x not in facsym:
+        try:
+            fy = exp(integrate(factor, y))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: fy.subs(y, func), eta: S.Zero}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    if xieta:
+        return xieta
+
+def lie_heuristic_abaco1_product(match, comp=False):
+    r"""
+    The second heuristic uses the following two assumptions on `\xi` and `\eta`
+
+    .. math:: \eta = 0, \xi = f(x)*g(y)
+
+    .. math:: \eta = f(x)*g(y), \xi = 0
+
+    The first assumption of this heuristic holds good if
+    `\frac{1}{h^{2}}\frac{\partial^2}{\partial x \partial y}\log(h)` is
+    separable in `x` and `y`, then the separated factors containing `x`
+    is `f(x)`, and `g(y)` is obtained by
+
+    .. math:: e^{\int f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)\,dy}
+
+    provided `f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)` is a function
+    of `y` only.
+
+    The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+    `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
+    satisfies. After obtaining `f(x)` and `g(y)`, the coordinates are again
+    interchanged, to get `\eta` as `f(x)*g(y)`
+
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 7 - pp. 8
+
+    """
+
+    xieta = []
+    y = match['y']
+    h = match['h']
+    hinv = match['hinv']
+    func = match['func']
+    x = func.args[0]
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+
+    inf = separatevars(((log(h).diff(y)).diff(x))/h**2, dict=True, symbols=[x, y])
+    if inf and inf['coeff']:
+        fx = inf[x]
+        gy = simplify(fx*((1/(fx*h)).diff(x)))
+        gysyms = gy.free_symbols
+        if x not in gysyms:
+            gy = exp(integrate(gy, y))
+            inf = {eta: S.Zero, xi: (fx*gy).subs(y, func)}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    u1 = Dummy("u1")
+    inf = separatevars(((log(hinv).diff(y)).diff(x))/hinv**2, dict=True, symbols=[x, y])
+    if inf and inf['coeff']:
+        fx = inf[x]
+        gy = simplify(fx*((1/(fx*hinv)).diff(x)))
+        gysyms = gy.free_symbols
+        if x not in gysyms:
+            gy = exp(integrate(gy, y))
+            etaval = fx*gy
+            etaval = (etaval.subs([(x, u1), (y, x)])).subs(u1, y)
+            inf = {eta: etaval.subs(y, func), xi: S.Zero}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    if xieta:
+        return xieta
+
+def lie_heuristic_bivariate(match, comp=False):
+    r"""
+    The third heuristic assumes the infinitesimals `\xi` and `\eta`
+    to be bi-variate polynomials in `x` and `y`. The assumption made here
+    for the logic below is that `h` is a rational function in `x` and `y`
+    though that may not be necessary for the infinitesimals to be
+    bivariate polynomials. The coefficients of the infinitesimals
+    are found out by substituting them in the PDE and grouping similar terms
+    that are polynomials and since they form a linear system, solve and check
+    for non trivial solutions. The degree of the assumed bivariates
+    are increased till a certain maximum value.
+
+    References
+    ==========
+    - Lie Groups and Differential Equations
+      pp. 327 - pp. 329
+
+    """
+
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    if h.is_rational_function():
+        # The maximum degree that the infinitesimals can take is
+        # calculated by this technique.
+        etax, etay, etad, xix, xiy, xid = symbols("etax etay etad xix xiy xid")
+        ipde = etax + (etay - xix)*h - xiy*h**2 - xid*hx - etad*hy
+        num, denom = cancel(ipde).as_numer_denom()
+        deg = Poly(num, x, y).total_degree()
+        deta = Function('deta')(x, y)
+        dxi = Function('dxi')(x, y)
+        ipde = (deta.diff(x) + (deta.diff(y) - dxi.diff(x))*h - (dxi.diff(y))*h**2
+            - dxi*hx - deta*hy)
+        xieq = Symbol("xi0")
+        etaeq = Symbol("eta0")
+
+        for i in range(deg + 1):
+            if i:
+                xieq += Add(*[
+                    Symbol("xi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+                    for power in range(i + 1)])
+                etaeq += Add(*[
+                    Symbol("eta_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+                    for power in range(i + 1)])
+            pden, denom = (ipde.subs({dxi: xieq, deta: etaeq}).doit()).as_numer_denom()
+            pden = expand(pden)
+
+            # If the individual terms are monomials, the coefficients
+            # are grouped
+            if pden.is_polynomial(x, y) and pden.is_Add:
+                polyy = Poly(pden, x, y).as_dict()
+            if polyy:
+                symset = xieq.free_symbols.union(etaeq.free_symbols) - {x, y}
+                soldict = solve(polyy.values(), *symset)
+                if isinstance(soldict, list):
+                    soldict = soldict[0]
+                if any(soldict.values()):
+                    xired = xieq.subs(soldict)
+                    etared = etaeq.subs(soldict)
+                    # Scaling is done by substituting one for the parameters
+                    # This can be any number except zero.
+                    dict_ = {sym: 1 for sym in symset}
+                    inf = {eta: etared.subs(dict_).subs(y, func),
+                        xi: xired.subs(dict_).subs(y, func)}
+                    return [inf]
+
+def lie_heuristic_chi(match, comp=False):
+    r"""
+    The aim of the fourth heuristic is to find the function `\chi(x, y)`
+    that satisfies the PDE `\frac{d\chi}{dx} + h\frac{d\chi}{dx}
+    - \frac{\partial h}{\partial y}\chi = 0`.
+
+    This assumes `\chi` to be a bivariate polynomial in `x` and `y`. By intuition,
+    `h` should be a rational function in `x` and `y`. The method used here is
+    to substitute a general binomial for `\chi` up to a certain maximum degree
+    is reached. The coefficients of the polynomials, are calculated by by collecting
+    terms of the same order in `x` and `y`.
+
+    After finding `\chi`, the next step is to use `\eta = \xi*h + \chi`, to
+    determine `\xi` and `\eta`. This can be done by dividing `\chi` by `h`
+    which would give `-\xi` as the quotient and `\eta` as the remainder.
+
+
+    References
+    ==========
+    - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
+      Solving of First Order ODEs Using Symmetry Methods, pp. 8
+
+    """
+
+    h = match['h']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    if h.is_rational_function():
+        schi, schix, schiy = symbols("schi, schix, schiy")
+        cpde = schix + h*schiy - hy*schi
+        num, denom = cancel(cpde).as_numer_denom()
+        deg = Poly(num, x, y).total_degree()
+
+        chi = Function('chi')(x, y)
+        chix = chi.diff(x)
+        chiy = chi.diff(y)
+        cpde = chix + h*chiy - hy*chi
+        chieq = Symbol("chi")
+        for i in range(1, deg + 1):
+            chieq += Add(*[
+                Symbol("chi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+                for power in range(i + 1)])
+            cnum, cden = cancel(cpde.subs({chi : chieq}).doit()).as_numer_denom()
+            cnum = expand(cnum)
+            if cnum.is_polynomial(x, y) and cnum.is_Add:
+                cpoly = Poly(cnum, x, y).as_dict()
+                if cpoly:
+                    solsyms = chieq.free_symbols - {x, y}
+                    soldict = solve(cpoly.values(), *solsyms)
+                    if isinstance(soldict, list):
+                        soldict = soldict[0]
+                    if any(soldict.values()):
+                        chieq = chieq.subs(soldict)
+                        dict_ = {sym: 1 for sym in solsyms}
+                        chieq = chieq.subs(dict_)
+                        # After finding chi, the main aim is to find out
+                        # eta, xi by the equation eta = xi*h + chi
+                        # One method to set xi, would be rearranging it to
+                        # (eta/h) - xi = (chi/h). This would mean dividing
+                        # chi by h would give -xi as the quotient and eta
+                        # as the remainder. Thanks to Sean Vig for suggesting
+                        # this method.
+                        xic, etac = div(chieq, h)
+                        inf = {eta: etac.subs(y, func), xi: -xic.subs(y, func)}
+                        return [inf]
+
+def lie_heuristic_function_sum(match, comp=False):
+    r"""
+    This heuristic uses the following two assumptions on `\xi` and `\eta`
+
+    .. math:: \eta = 0, \xi = f(x) + g(y)
+
+    .. math:: \eta = f(x) + g(y), \xi = 0
+
+    The first assumption of this heuristic holds good if
+
+    .. math:: \frac{\partial}{\partial y}[(h\frac{\partial^{2}}{
+                \partial x^{2}}(h^{-1}))^{-1}]
+
+    is separable in `x` and `y`,
+
+    1. The separated factors containing `y` is `\frac{\partial g}{\partial y}`.
+       From this `g(y)` can be determined.
+    2. The separated factors containing `x` is `f''(x)`.
+    3. `h\frac{\partial^{2}}{\partial x^{2}}(h^{-1})` equals
+       `\frac{f''(x)}{f(x) + g(y)}`. From this `f(x)` can be determined.
+
+    The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+    `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first
+    assumption satisfies. After obtaining `f(x)` and `g(y)`, the coordinates
+    are again interchanged, to get `\eta` as `f(x) + g(y)`.
+
+    For both assumptions, the constant factors are separated among `g(y)`
+    and `f''(x)`, such that `f''(x)` obtained from 3] is the same as that
+    obtained from 2]. If not possible, then this heuristic fails.
+
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 7 - pp. 8
+
+    """
+
+    xieta = []
+    h = match['h']
+    func = match['func']
+    hinv = match['hinv']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    for odefac in [h, hinv]:
+        factor = odefac*((1/odefac).diff(x, 2))
+        sep = separatevars((1/factor).diff(y), dict=True, symbols=[x, y])
+        if sep and sep['coeff'] and sep[x].has(x) and sep[y].has(y):
+            k = Dummy("k")
+            try:
+                gy = k*integrate(sep[y], y)
+            except NotImplementedError:
+                pass
+            else:
+                fdd = 1/(k*sep[x]*sep['coeff'])
+                fx = simplify(fdd/factor - gy)
+                check = simplify(fx.diff(x, 2) - fdd)
+                if fx:
+                    if not check:
+                        fx = fx.subs(k, 1)
+                        gy = (gy/k)
+                    else:
+                        sol = solve(check, k)
+                        if sol:
+                            sol = sol[0]
+                            fx = fx.subs(k, sol)
+                            gy = (gy/k)*sol
+                        else:
+                            continue
+                    if odefac == hinv:  # Inverse ODE
+                        fx = fx.subs(x, y)
+                        gy = gy.subs(y, x)
+                    etaval = factor_terms(fx + gy)
+                    if etaval.is_Mul:
+                        etaval = Mul(*[arg for arg in etaval.args if arg.has(x, y)])
+                    if odefac == hinv:  # Inverse ODE
+                        inf = {eta: etaval.subs(y, func), xi : S.Zero}
+                    else:
+                        inf = {xi: etaval.subs(y, func), eta : S.Zero}
+                    if not comp:
+                        return [inf]
+                    else:
+                        xieta.append(inf)
+
+        if xieta:
+            return xieta
+
+def lie_heuristic_abaco2_similar(match, comp=False):
+    r"""
+    This heuristic uses the following two assumptions on `\xi` and `\eta`
+
+    .. math:: \eta = g(x), \xi = f(x)
+
+    .. math:: \eta = f(y), \xi = g(y)
+
+    For the first assumption,
+
+    1. First `\frac{\frac{\partial h}{\partial y}}{\frac{\partial^{2} h}{
+       \partial yy}}` is calculated. Let us say this value is A
+
+    2. If this is constant, then `h` is matched to the form `A(x) + B(x)e^{
+       \frac{y}{C}}` then, `\frac{e^{\int \frac{A(x)}{C} \,dx}}{B(x)}` gives `f(x)`
+       and `A(x)*f(x)` gives `g(x)`
+
+    3. Otherwise `\frac{\frac{\partial A}{\partial X}}{\frac{\partial A}{
+       \partial Y}} = \gamma` is calculated. If
+
+       a] `\gamma` is a function of `x` alone
+
+       b] `\frac{\gamma\frac{\partial h}{\partial y} - \gamma'(x) - \frac{
+       \partial h}{\partial x}}{h + \gamma} = G` is a function of `x` alone.
+       then, `e^{\int G \,dx}` gives `f(x)` and `-\gamma*f(x)` gives `g(x)`
+
+    The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+    `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
+    satisfies. After obtaining `f(x)` and `g(x)`, the coordinates are again
+    interchanged, to get `\xi` as `f(x^*)` and `\eta` as `g(y^*)`
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    hinv = match['hinv']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    factor = cancel(h.diff(y)/h.diff(y, 2))
+    factorx = factor.diff(x)
+    factory = factor.diff(y)
+    if not factor.has(x) and not factor.has(y):
+        A = Wild('A', exclude=[y])
+        B = Wild('B', exclude=[y])
+        C = Wild('C', exclude=[x, y])
+        match = h.match(A + B*exp(y/C))
+        try:
+            tau = exp(-integrate(match[A]/match[C]), x)/match[B]
+        except NotImplementedError:
+            pass
+        else:
+            gx = match[A]*tau
+            return [{xi: tau, eta: gx}]
+
+    else:
+        gamma = cancel(factorx/factory)
+        if not gamma.has(y):
+            tauint = cancel((gamma*hy - gamma.diff(x) - hx)/(h + gamma))
+            if not tauint.has(y):
+                try:
+                    tau = exp(integrate(tauint, x))
+                except NotImplementedError:
+                    pass
+                else:
+                    gx = -tau*gamma
+                    return [{xi: tau, eta: gx}]
+
+    factor = cancel(hinv.diff(y)/hinv.diff(y, 2))
+    factorx = factor.diff(x)
+    factory = factor.diff(y)
+    if not factor.has(x) and not factor.has(y):
+        A = Wild('A', exclude=[y])
+        B = Wild('B', exclude=[y])
+        C = Wild('C', exclude=[x, y])
+        match = h.match(A + B*exp(y/C))
+        try:
+            tau = exp(-integrate(match[A]/match[C]), x)/match[B]
+        except NotImplementedError:
+            pass
+        else:
+            gx = match[A]*tau
+            return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
+
+    else:
+        gamma = cancel(factorx/factory)
+        if not gamma.has(y):
+            tauint = cancel((gamma*hinv.diff(y) - gamma.diff(x) - hinv.diff(x))/(
+                hinv + gamma))
+            if not tauint.has(y):
+                try:
+                    tau = exp(integrate(tauint, x))
+                except NotImplementedError:
+                    pass
+                else:
+                    gx = -tau*gamma
+                    return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
+
+
+def lie_heuristic_abaco2_unique_unknown(match, comp=False):
+    r"""
+    This heuristic assumes the presence of unknown functions or known functions
+    with non-integer powers.
+
+    1. A list of all functions and non-integer powers containing x and y
+    2. Loop over each element `f` in the list, find `\frac{\frac{\partial f}{\partial x}}{
+       \frac{\partial f}{\partial x}} = R`
+
+       If it is separable in `x` and `y`, let `X` be the factors containing `x`. Then
+
+       a] Check if `\xi = X` and `\eta = -\frac{X}{R}` satisfy the PDE. If yes, then return
+          `\xi` and `\eta`
+       b] Check if `\xi = \frac{-R}{X}` and `\eta = -\frac{1}{X}` satisfy the PDE.
+           If yes, then return `\xi` and `\eta`
+
+       If not, then check if
+
+       a] :math:`\xi = -R,\eta = 1`
+
+       b] :math:`\xi = 1, \eta = -\frac{1}{R}`
+
+       are solutions.
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    funclist = []
+    for atom in h.atoms(Pow):
+        base, exp = atom.as_base_exp()
+        if base.has(x) and base.has(y):
+            if not exp.is_Integer:
+                funclist.append(atom)
+
+    for function in h.atoms(AppliedUndef):
+        syms = function.free_symbols
+        if x in syms and y in syms:
+            funclist.append(function)
+
+    for f in funclist:
+        frac = cancel(f.diff(y)/f.diff(x))
+        sep = separatevars(frac, dict=True, symbols=[x, y])
+        if sep and sep['coeff']:
+            xitry1 = sep[x]
+            etatry1 = -1/(sep[y]*sep['coeff'])
+            pde1 = etatry1.diff(y)*h - xitry1.diff(x)*h - xitry1*hx - etatry1*hy
+            if not simplify(pde1):
+                return [{xi: xitry1, eta: etatry1.subs(y, func)}]
+            xitry2 = 1/etatry1
+            etatry2 = 1/xitry1
+            pde2 = etatry2.diff(x) - (xitry2.diff(y))*h**2 - xitry2*hx - etatry2*hy
+            if not simplify(expand(pde2)):
+                return [{xi: xitry2.subs(y, func), eta: etatry2}]
+
+        else:
+            etatry = -1/frac
+            pde = etatry.diff(x) + etatry.diff(y)*h - hx - etatry*hy
+            if not simplify(pde):
+                return [{xi: S.One, eta: etatry.subs(y, func)}]
+            xitry = -frac
+            pde = -xitry.diff(x)*h -xitry.diff(y)*h**2 - xitry*hx -hy
+            if not simplify(expand(pde)):
+                return [{xi: xitry.subs(y, func), eta: S.One}]
+
+
+def lie_heuristic_abaco2_unique_general(match, comp=False):
+    r"""
+    This heuristic finds if infinitesimals of the form `\eta = f(x)`, `\xi = g(y)`
+    without making any assumptions on `h`.
+
+    The complete sequence of steps is given in the paper mentioned below.
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    A = hx.diff(y)
+    B = hy.diff(y) + hy**2
+    C = hx.diff(x) - hx**2
+
+    if not (A and B and C):
+        return
+
+    Ax = A.diff(x)
+    Ay = A.diff(y)
+    Axy = Ax.diff(y)
+    Axx = Ax.diff(x)
+    Ayy = Ay.diff(y)
+    D = simplify(2*Axy + hx*Ay - Ax*hy + (hx*hy + 2*A)*A)*A - 3*Ax*Ay
+    if not D:
+        E1 = simplify(3*Ax**2 + ((hx**2 + 2*C)*A - 2*Axx)*A)
+        if E1:
+            E2 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
+            if not E2:
+                E3 = simplify(
+                    E1*((28*Ax + 4*hx*A)*A**3 - E1*(hy*A + Ay)) - E1.diff(x)*8*A**4)
+                if not E3:
+                    etaval = cancel((4*A**3*(Ax - hx*A) + E1*(hy*A - Ay))/(S(2)*A*E1))
+                    if x not in etaval:
+                        try:
+                            etaval = exp(integrate(etaval, y))
+                        except NotImplementedError:
+                            pass
+                        else:
+                            xival = -4*A**3*etaval/E1
+                            if y not in xival:
+                                return [{xi: xival, eta: etaval.subs(y, func)}]
+
+    else:
+        E1 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
+        if E1:
+            E2 = simplify(
+                4*A**3*D - D**2 + E1*((2*Axx - (hx**2 + 2*C)*A)*A - 3*Ax**2))
+            if not E2:
+                E3 = simplify(
+                   -(A*D)*E1.diff(y) + ((E1.diff(x) - hy*D)*A + 3*Ay*D +
+                    (A*hx - 3*Ax)*E1)*E1)
+                if not E3:
+                    etaval = cancel(((A*hx - Ax)*E1 - (Ay + A*hy)*D)/(S(2)*A*D))
+                    if x not in etaval:
+                        try:
+                            etaval = exp(integrate(etaval, y))
+                        except NotImplementedError:
+                            pass
+                        else:
+                            xival = -E1*etaval/D
+                            if y not in xival:
+                                return [{xi: xival, eta: etaval.subs(y, func)}]
+
+
+def lie_heuristic_linear(match, comp=False):
+    r"""
+    This heuristic assumes
+
+    1. `\xi = ax + by + c` and
+    2. `\eta = fx + gy + h`
+
+    After substituting the following assumptions in the determining PDE, it
+    reduces to
+
+    .. math:: f + (g - a)h - bh^{2} - (ax + by + c)\frac{\partial h}{\partial x}
+                 - (fx + gy + c)\frac{\partial h}{\partial y}
+
+    Solving the reduced PDE obtained, using the method of characteristics, becomes
+    impractical. The method followed is grouping similar terms and solving the system
+    of linear equations obtained. The difference between the bivariate heuristic is that
+    `h` need not be a rational function in this case.
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    coeffdict = {}
+    symbols = numbered_symbols("c", cls=Dummy)
+    symlist = [next(symbols) for _ in islice(symbols, 6)]
+    C0, C1, C2, C3, C4, C5 = symlist
+    pde = C3 + (C4 - C0)*h - (C0*x + C1*y + C2)*hx - (C3*x + C4*y + C5)*hy - C1*h**2
+    pde, denom = pde.as_numer_denom()
+    pde = powsimp(expand(pde))
+    if pde.is_Add:
+        terms = pde.args
+        for term in terms:
+            if term.is_Mul:
+                rem = Mul(*[m for m in term.args if not m.has(x, y)])
+                xypart = term/rem
+                if xypart not in coeffdict:
+                    coeffdict[xypart] = rem
+                else:
+                    coeffdict[xypart] += rem
+            else:
+                if term not in coeffdict:
+                    coeffdict[term] = S.One
+                else:
+                    coeffdict[term] += S.One
+
+    sollist = coeffdict.values()
+    soldict = solve(sollist, symlist)
+    if soldict:
+        if isinstance(soldict, list):
+            soldict = soldict[0]
+        subval = soldict.values()
+        if any(t for t in subval):
+            onedict = dict(zip(symlist, [1]*6))
+            xival = C0*x + C1*func + C2
+            etaval = C3*x + C4*func + C5
+            xival = xival.subs(soldict)
+            etaval = etaval.subs(soldict)
+            xival = xival.subs(onedict)
+            etaval = etaval.subs(onedict)
+            return [{xi: xival, eta: etaval}]
+
+
+def _lie_group_remove(coords):
+    r"""
+    This function is strictly meant for internal use by the Lie group ODE solving
+    method. It replaces arbitrary functions returned by pdsolve as follows:
+
+    1] If coords is an arbitrary function, then its argument is returned.
+    2] An arbitrary function in an Add object is replaced by zero.
+    3] An arbitrary function in a Mul object is replaced by one.
+    4] If there is no arbitrary function coords is returned unchanged.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.ode.lie_group import _lie_group_remove
+    >>> from sympy import Function
+    >>> from sympy.abc import x, y
+    >>> F = Function("F")
+    >>> eq = x**2*y
+    >>> _lie_group_remove(eq)
+    x**2*y
+    >>> eq = F(x**2*y)
+    >>> _lie_group_remove(eq)
+    x**2*y
+    >>> eq = x*y**2 + F(x**3)
+    >>> _lie_group_remove(eq)
+    x*y**2
+    >>> eq = (F(x**3) + y)*x**4
+    >>> _lie_group_remove(eq)
+    x**4*y
+
+    """
+    if isinstance(coords, AppliedUndef):
+        return coords.args[0]
+    elif coords.is_Add:
+        subfunc = coords.atoms(AppliedUndef)
+        if subfunc:
+            for func in subfunc:
+                coords = coords.subs(func, 0)
+        return coords
+    elif coords.is_Pow:
+        base, expr = coords.as_base_exp()
+        base = _lie_group_remove(base)
+        expr = _lie_group_remove(expr)
+        return base**expr
+    elif coords.is_Mul:
+        mulargs = []
+        coordargs = coords.args
+        for arg in coordargs:
+            if not isinstance(coords, AppliedUndef):
+                mulargs.append(_lie_group_remove(arg))
+        return Mul(*mulargs)
+    return coords

env-llmeval/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)

env-llmeval/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 {k:v for k, v in 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

env-llmeval/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)

env-llmeval/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 j, scc in enumerate(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 = {func: 2 for func in funcs}
+
+    if type == "type1":
+        if b is None:
+            b = zeros(len(eqs))
+        eqs = _second_order_subs_type1(A1, b, funcs, t)
+        sys_order = {func: 1 for func in funcs}
+
+    if type == "type2":
+        if t_ is None:
+            t_ = Symbol("{}_".format(t))
+        t = t_
+        eqs, funcs = _second_order_subs_type2(A0, funcs, t_)
+        sys_order = {func: 2 for func in funcs}
+
+    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 = {func: new_func for func, new_func in 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